OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
9d3ec9be61
opm-common/tests/test_RFT.cpp

2423 lines
109 KiB
C++
Raw Normal View History

Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
/*
Copyright 2015 Statoil ASA.
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/>.
*/
#include "config.h"
#define BOOST_TEST_MODULE EclipseRFTWriter
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
#include <boost/test/unit_test.hpp>
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
#include <opm/io/eclipse/ERft.hpp>
#include <opm/io/eclipse/OutputStream.hpp>
#include <opm/output/data/Solution.hpp>
Moved Cells.hpp and Wells.hpp opm/output/data/
2016-10-03 07:52:39 -05:00
#include <opm/output/data/Wells.hpp>
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
#include <opm/output/eclipse/EclipseIO.hpp>
#include <opm/output/eclipse/InteHEAD.hpp>
Add New RFT File Writer This commit implements a new file writing function void Opm::RftIO::write() that is intended to replace the current RFT output functionality defined in terms of private class 'RFT' in EclipseIO.cpp. We support the basic RFT output consisting of - Timestamp (elapsed and date) - WELLETC metadata including all unit conventions - Connection cell (I,J,K), connection cell hostgrid (blank for main grid only), connection cell centre depth, connection cell pressure, and connection cell water and gas saturations Connections in inactive cells are omitted. Note that unit of measure strings aren't implemented in terms of UnitSystem::name() due to the strings being padded on the left for centering effect. Add unit tests to exercise the new writer.
2019-08-28 03:31:26 -05:00
#include <opm/output/eclipse/WriteRFT.hpp>
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/IOConfig/IOConfig.hpp>
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp>
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
#include <opm/parser/eclipse/Parser/ParseContext.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Add New RFT File Writer This commit implements a new file writing function void Opm::RftIO::write() that is intended to replace the current RFT output functionality defined in terms of private class 'RFT' in EclipseIO.cpp. We support the basic RFT output consisting of - Timestamp (elapsed and date) - WELLETC metadata including all unit conventions - Connection cell (I,J,K), connection cell hostgrid (blank for main grid only), connection cell centre depth, connection cell pressure, and connection cell water and gas saturations Connections in inactive cells are omitted. Note that unit of measure strings aren't implemented in terms of UnitSystem::name() due to the strings being padded on the left for centering effect. Add unit tests to exercise the new writer.
2019-08-28 03:31:26 -05:00
#include <opm/parser/eclipse/Units/Units.hpp>
#include <opm/parser/eclipse/Units/UnitSystem.hpp>
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
#include <cstddef>
#include <ctime>
#include <map>
#include <iomanip>
#include <ostream>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
#include <vector>
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
#include <boost/date_time/posix_time/posix_time.hpp>
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>
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
using namespace Opm;
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
namespace std { // hack...
// For printing ERft::RftDate objects. Needed by EQUAL_COLLECTIONS.
static ostream& operator<<(ostream& os, const tuple<int,int,int>& d)
{
os << setw(4) << get<0>(d)
<< "-" << setw(2) << setfill('0') << get<1>(d)
<< "-" << setw(2) << setfill('0') << get<2>(d);
return os;
}
}
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
namespace {
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
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-%%%%"))
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -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_);
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -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_);
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
}
std::string outputDir() const
{
return this->odir_.string();
}
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
operator ::Opm::EclIO::OutputStream::ResultSet() const
{
return { this->odir_.string(), this->base_ };
}
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
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_;
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
std::string base_;
};
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
class RFTRresults
{
public:
explicit RFTRresults(const ::Opm::EclIO::ERft& rft,
const std::string& well,
const ::Opm::EclIO::ERft::RftDate& date);
float depth(const int i, const int j, const int k) const
{
return this->depth_[this->conIx(i, j, k)];
}
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
float pressure(const int i, const int j, const int k) const
{
return this->press_[this->conIx(i, j, k)];
}
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
float sgas(const int i, const int j, const int k) const
{
return this->sgas_[this->conIx(i, j, k)];
}
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
float swat(const int i, const int j, const int k) const
{
return this->swat_[this->conIx(i, j, k)];
}
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
private:
std::vector<float> depth_;
std::vector<float> press_;
std::vector<float> sgas_;
std::vector<float> swat_;
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
std::map<std::tuple<int, int, int>, std::size_t> xConIx_;
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
std::size_t conIx(const int i, const int j, const int k) const;
};
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
RFTRresults::RFTRresults(const ::Opm::EclIO::ERft& rft,
const std::string& well,
const ::Opm::EclIO::ERft::RftDate& date)
{
BOOST_REQUIRE(rft.hasRft(well, date));
BOOST_REQUIRE(rft.hasArray("CONIPOS", well, date));
BOOST_REQUIRE(rft.hasArray("CONJPOS", well, date));
BOOST_REQUIRE(rft.hasArray("CONKPOS", well, date));
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
const auto& I = rft.getRft<int>("CONIPOS", well, date);
const auto& J = rft.getRft<int>("CONJPOS", well, date);
const auto& K = rft.getRft<int>("CONKPOS", well, date);
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
for (auto ncon = I.size(), con = 0*ncon; con < ncon; ++con) {
this->xConIx_[std::make_tuple(I[con], J[con], K[con])] = con;
}
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
BOOST_REQUIRE(rft.hasArray("DEPTH" , well, date));
BOOST_REQUIRE(rft.hasArray("PRESSURE", well, date));
BOOST_REQUIRE(rft.hasArray("SGAS" , well, date));
BOOST_REQUIRE(rft.hasArray("SWAT" , well, date));
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
this->depth_ = rft.getRft<float>("DEPTH" , well, date);
this->press_ = rft.getRft<float>("PRESSURE", well, date);
this->sgas_ = rft.getRft<float>("SGAS" , well, date);
this->swat_ = rft.getRft<float>("SWAT" , well, date);
}
std::size_t RFTRresults::conIx(const int i, const int j, const int k) const
{
auto conIx = this->xConIx_.find(std::make_tuple(i, j, k));
if (conIx == this->xConIx_.end()) {
RFT Unit Test: Use Actual 'BOOST_FAIL' Macro BOOST_TEST_FAIL was a figment of my imagination.
2019-08-30 02:39:15 -05:00
BOOST_FAIL("Invalid IJK Tuple (" << i << ", "
<< j << ", " << k << ')');
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
}
return conIx->second;
}
void verifyRFTFile(const std::string& rft_filename)
{
using RftDate = ::Opm::EclIO::ERft::RftDate;
const auto rft = ::Opm::EclIO::ERft{ rft_filename };
const auto xRFT = RFTRresults {
rft, "OP_1", RftDate{ 2008, 10, 10 }
};
const auto tol = 1.0e-5;
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 1), 0.0 , tol);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 2), 1.0e-5, tol);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 3), 2.0e-5, tol);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 1), 0.0, tol);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 2), 0.2, tol);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 3), 0.4, tol);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 1), 0.0, tol);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 2), 0.1, tol);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 3), 0.2, tol);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 1), 1*0.250 + 0.250/2, tol);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 2), 2*0.250 + 0.250/2, tol);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 3), 3*0.250 + 0.250/2, tol);
}
data::Solution createBlackoilState(int timeStepIdx, int numCells)
{
std::vector< double > pressure( numCells );
std::vector< double > swat( numCells, 0 );
std::vector< double > sgas( numCells, 0 );
for (int i = 0; i < numCells; ++i) {
pressure[i] = timeStepIdx*1e5 + 1e4 + i;
}
data::Solution sol;
sol.insert( "PRESSURE", UnitSystem::measure::pressure, pressure , data::TargetType::RESTART_SOLUTION );
sol.insert( "SWAT", UnitSystem::measure::identity, swat , data::TargetType::RESTART_SOLUTION );
sol.insert( "SGAS", UnitSystem::measure::identity, sgas, data::TargetType::RESTART_SOLUTION );
return sol;
}
std::time_t timeStamp(const ::Opm::EclIO::ERft::RftDate& date)
{
auto tp = std::tm{};
tp.tm_year = std::get<0>(date) - 1900;
tp.tm_mon = std::get<1>(date) - 1; // 0..11
tp.tm_mday = std::get<2>(date); // 1..31
return ::Opm::RestartIO::makeUTCTime(tp);
}
} // Anonymous namespace
Add New RFT File Writer This commit implements a new file writing function void Opm::RftIO::write() that is intended to replace the current RFT output functionality defined in terms of private class 'RFT' in EclipseIO.cpp. We support the basic RFT output consisting of - Timestamp (elapsed and date) - WELLETC metadata including all unit conventions - Connection cell (I,J,K), connection cell hostgrid (blank for main grid only), connection cell centre depth, connection cell pressure, and connection cell water and gas saturations Connections in inactive cells are omitted. Note that unit of measure strings aren't implemented in terms of UnitSystem::name() due to the strings being padded on the left for centering effect. Add unit tests to exercise the new writer.
2019-08-28 03:31:26 -05:00
BOOST_AUTO_TEST_SUITE(Using_EclipseIO)
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
BOOST_AUTO_TEST_CASE(test_RFT)
{
const auto rset = RSet{ "TESTRFT" };
const auto eclipse_data_filename = std::string{ "testrft.DATA" };
const auto deck = Parser{}.parseFile(eclipse_data_filename);
auto eclipseState = EclipseState { deck };
eclipseState.getIOConfig().setOutputDir(rset.outputDir());
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
{
/* eclipseWriter is scoped here to ensure it is destroyed after the
* file itself has been written, because we're going to reload it
* immediately. first upon destruction can we guarantee it being
* written to disk and flushed.
*/
Update to shared_ptr-less parser interface.
2016-10-13 07:15:58 -05:00
const auto& grid = eclipseState.getInputGrid();
const auto numCells = grid.getCartesianSize( );
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
const Schedule schedule(deck, eclipseState);
const SummaryConfig summary_config( deck, schedule, eclipseState.getTableManager( ));
Extract Schedule and SummaryConfig.
2017-10-02 05:40:28 -05:00
EclipseIO eclipseWriter( eclipseState, grid, schedule, summary_config );
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
const auto start_time = schedule.posixStartTime();
const auto step_time = timeStamp(::Opm::EclIO::ERft::RftDate{ 2008, 10, 10 });
Add start_time argument to SummaryState
2019-09-19 09:17:38 -05:00
SummaryState st(std::chrono::system_clock::now());
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Prefer named data members over vectors in OPM_XWEL Change the structure used to populate OPM_XWEL to use a plain map of data::Wells objects rather than dumping a series of vectors to data::Wells. Tests are added for serialising and restoring wells.
2016-09-25 11:31:34 -05:00
data::Rates r1, r2;
r1.set( data::Rates::opt::wat, 4.11 );
r1.set( data::Rates::opt::oil, 4.12 );
r1.set( data::Rates::opt::gas, 4.13 );
r2.set( data::Rates::opt::wat, 4.21 );
r2.set( data::Rates::opt::oil, 4.22 );
r2.set( data::Rates::opt::gas, 4.23 );
Rename CompletionSet -> ConnectionSet
2018-06-10 13:54:34 -05:00
std::vector<Opm::data::Connection> well1_comps(9);
Add cell data in perforation cells to data::well::completion With this no cell data is needed in opm-output
2018-02-07 07:32:01 -06:00
for (size_t i = 0; i < 9; ++i) {
Unit Tests: Supply Enough Parameters for data::Connection We must provide cell_pressure, cell_saturation_water, cell_saturation_gas, and effective_Kh. Forgotten in commit 687f108.
2018-07-11 17:41:09 -05:00
Opm::data::Connection well_comp { grid.getGlobalIndex(8,8,i) ,r1, 0.0 , 0.0, (double)i, 0.1*i,0.2*i, 1.2e3};
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
well1_comps[i] = std::move(well_comp);
Add cell data in perforation cells to data::well::completion With this no cell data is needed in opm-output
2018-02-07 07:32:01 -06:00
}
Rename CompletionSet -> ConnectionSet
2018-06-10 13:54:34 -05:00
std::vector<Opm::data::Connection> well2_comps(6);
Add cell data in perforation cells to data::well::completion With this no cell data is needed in opm-output
2018-02-07 07:32:01 -06:00
for (size_t i = 0; i < 6; ++i) {
Unit Tests: Supply Enough Parameters for data::Connection We must provide cell_pressure, cell_saturation_water, cell_saturation_gas, and effective_Kh. Forgotten in commit 687f108.
2018-07-11 17:41:09 -05:00
Opm::data::Connection well_comp { grid.getGlobalIndex(3,3,i+3) ,r2, 0.0 , 0.0, (double)i, i*0.1,i*0.2, 0.15};
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
well2_comps[i] = std::move(well_comp);
Add cell data in perforation cells to data::well::completion With this no cell data is needed in opm-output
2018-02-07 07:32:01 -06:00
}
Use RestartValue container for Eclipse output
2018-04-28 05:52:28 -05:00
Opm::data::Solution solution = createBlackoilState(2, numCells);
Extended data::Wells to inherit from std::map.
2016-10-25 04:45:29 -05:00
Opm::data::Wells wells;
Restore Build on GCC 4.9 Commit 334dbe4e broke GCC 4.9 (invoking explicit constructor with an empty initializer_list). Restore build by using the actual type.
2018-12-11 10:30:43 -06:00
using SegRes = decltype(wells["w"].segments);
Add Restart Infrastructure for Well's Active Control This commit introduces a new protocol for communicating a well's active constraint (i.e., its current target control mode) between the running simulator and the restart file. In particular, we add a new type Opm::data::CurrentControl whose data members indicate if the well is a producer or injector and, depending on that state, carries information about the pertinent active control mode. The 'prod' member should be defined for producing wells and the 'inj' member should be defined for injectors. Default-constructed objects of this type are 'invalid' and not output to the restart file. Add a CurrentControl member to the Opm::data::Well type to enable communicating this information using existing restart interfaces. Expand existing unit tests to exercise the new data member.
2020-01-29 16:08:02 -06:00
using Ctrl = decltype(wells["w"].current_control);
Restore Build on GCC 4.9 Commit 334dbe4e broke GCC 4.9 (invoking explicit constructor with an empty initializer_list). Restore build by using the actual type.
2018-12-11 10:30:43 -06:00
Add Restart Infrastructure for Well's Active Control This commit introduces a new protocol for communicating a well's active constraint (i.e., its current target control mode) between the running simulator and the restart file. In particular, we add a new type Opm::data::CurrentControl whose data members indicate if the well is a producer or injector and, depending on that state, carries information about the pertinent active control mode. The 'prod' member should be defined for producing wells and the 'inj' member should be defined for injectors. Default-constructed objects of this type are 'invalid' and not output to the restart file. Add a CurrentControl member to the Opm::data::Well type to enable communicating this information using existing restart interfaces. Expand existing unit tests to exercise the new data member.
2020-01-29 16:08:02 -06:00
wells["OP_1"] = { std::move(r1), 1.0, 1.1, 3.1, 1, std::move(well1_comps), SegRes{}, Ctrl{} };
wells["OP_2"] = { std::move(r2), 1.0, 1.1, 3.2, 1, std::move(well2_comps), SegRes{}, Ctrl{} };
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
RestartValue restart_value(std::move(solution), std::move(wells));
Use RestartValue container for Eclipse output
2018-04-28 05:52:28 -05:00
Extract Summary::eval() out from Summary::add_timestep()
2019-06-03 10:35:26 -05:00
eclipseWriter.writeTimeStep( st,
2,
Moved argument 'sub_step' to 2. in argument list.
2016-08-20 11:50:43 -05:00
false,
step_time - start_time,
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
std::move(restart_value));
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
}
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
verifyRFTFile(Opm::EclIO::OutputStream::outputFileName(rset, "RFT"));
Remove opm-core dependency in RFT test; rename Rewrites the RFT test to be independent of opm-core data types and functions, and renames it to test_RFT since the class now represents the full file, not some open-closing handle.
2016-05-13 07:06:11 -05:00
}
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
namespace {
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
void verifyRFTFile2(const std::string& rft_filename)
{
using RftDate = Opm::EclIO::ERft::RftDate;
const auto rft = ::Opm::EclIO::ERft{ rft_filename };
auto dates = std::unordered_map<
std::string, std::vector<RftDate>
>{};
for (const auto& wellDate : rft.listOfRftReports()) {
Updates of C++ class ERft to be used with python bindings -> Support for extracting data based on report index -> adding extra float (time) to RftReportList
2020-03-18 13:10:21 -05:00
dates[std::get<0>(wellDate)].push_back(std::get<1>(wellDate));
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
}
// Well OP_1
{
auto op_1 = dates.find("OP_1");
if (op_1 == dates.end()) {
RFT Unit Test: Use Actual 'BOOST_FAIL' Macro BOOST_TEST_FAIL was a figment of my imagination.
2019-08-30 02:39:15 -05:00
BOOST_FAIL("Missing RFT Data for Well OP_1");
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
}
const auto expect = std::vector<Opm::EclIO::ERft::RftDate> {
RftDate{ 2008, 10, 10 },
};
BOOST_CHECK_EQUAL_COLLECTIONS(op_1->second.begin(),
op_1->second.end(),
expect.begin(), expect.end());
}
// Well OP_2
{
auto op_2 = dates.find("OP_2");
if (op_2 == dates.end()) {
RFT Unit Test: Use Actual 'BOOST_FAIL' Macro BOOST_TEST_FAIL was a figment of my imagination.
2019-08-30 02:39:15 -05:00
BOOST_FAIL("Missing RFT Data for Well OP_2");
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
}
const auto expect = std::vector<RftDate> {
RftDate{ 2008, 10, 10 },
RftDate{ 2008, 11, 10 },
};
BOOST_CHECK_EQUAL_COLLECTIONS(op_2->second.begin(),
op_2->second.end(),
expect.begin(), expect.end());
}
}
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
}
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
BOOST_AUTO_TEST_CASE(test_RFT2)
{
const auto rset = RSet{ "TESTRFT" };
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
const auto eclipse_data_filename = std::string{ "testrft.DATA" };
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
const auto deck = Parser().parseFile( eclipse_data_filename );
Add overloads without ParseContext and ErrorGuard - update all tests
2019-01-03 11:05:19 -06:00
auto eclipseState = EclipseState(deck);
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
eclipseState.getIOConfig().setOutputDir(rset.outputDir());
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
{
/* eclipseWriter is scoped here to ensure it is destroyed after the
* file itself has been written, because we're going to reload it
* immediately. first upon destruction can we guarantee it being
* written to disk and flushed.
*/
const auto& grid = eclipseState.getInputGrid();
const auto numCells = grid.getCartesianSize( );
Add overloads without ParseContext and ErrorGuard - update all tests
2019-01-03 11:05:19 -06:00
Schedule schedule(deck, eclipseState);
SummaryConfig summary_config( deck, schedule, eclipseState.getTableManager( ));
Add start_time argument to SummaryState
2019-09-19 09:17:38 -05:00
SummaryState st(std::chrono::system_clock::now());
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
const auto start_time = schedule.posixStartTime();
const auto& time_map = schedule.getTimeMap( );
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
for (int counter = 0; counter < 2; counter++) {
Summary: Ensure that we don't step backwards during simulation This commit, a preparation for restoring cumulative quantities from a restart file, reinitialises Summary::prev_time_elapsed in the case of simulation restart and adds a check to Summary::write_timestep() which throws if the input argument 'secs_elapsed' is prior to the previously recorded elapsed time. The latter is a change in the behaviour of write_timestep(), but ensures that we don't integrate rate quantities across a very large timestep in the case of simulation restart and also prevents double accumulation. Update impacted unit tests accordingly, and move FIRST_SIM's START date into the RUNSPEC section where it belongs.
2018-11-02 07:15:43 -05:00
EclipseIO eclipseWriter( eclipseState, grid, schedule, summary_config );
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
for (size_t step = 0; step < time_map.size(); step++) {
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
const auto step_time = time_map[step];
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
data::Rates r1, r2;
r1.set( data::Rates::opt::wat, 4.11 );
r1.set( data::Rates::opt::oil, 4.12 );
r1.set( data::Rates::opt::gas, 4.13 );
r2.set( data::Rates::opt::wat, 4.21 );
r2.set( data::Rates::opt::oil, 4.22 );
r2.set( data::Rates::opt::gas, 4.23 );
Rename CompletionSet -> ConnectionSet
2018-06-10 13:54:34 -05:00
std::vector<Opm::data::Connection> well1_comps(9);
Add cell data in perforation cells to data::well::completion With this no cell data is needed in opm-output
2018-02-07 07:32:01 -06:00
for (size_t i = 0; i < 9; ++i) {
Unit Tests: Supply Enough Parameters for data::Connection We must provide cell_pressure, cell_saturation_water, cell_saturation_gas, and effective_Kh. Forgotten in commit 687f108.
2018-07-11 17:41:09 -05:00
Opm::data::Connection well_comp { grid.getGlobalIndex(8,8,i) ,r1, 0.0 , 0.0, (double)i, 0.1*i,0.2*i, 3.14e5};
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
well1_comps[i] = std::move(well_comp);
Add cell data in perforation cells to data::well::completion With this no cell data is needed in opm-output
2018-02-07 07:32:01 -06:00
}
Rename CompletionSet -> ConnectionSet
2018-06-10 13:54:34 -05:00
std::vector<Opm::data::Connection> well2_comps(6);
Add cell data in perforation cells to data::well::completion With this no cell data is needed in opm-output
2018-02-07 07:32:01 -06:00
for (size_t i = 0; i < 6; ++i) {
Unit Tests: Supply Enough Parameters for data::Connection We must provide cell_pressure, cell_saturation_water, cell_saturation_gas, and effective_Kh. Forgotten in commit 687f108.
2018-07-11 17:41:09 -05:00
Opm::data::Connection well_comp { grid.getGlobalIndex(3,3,i+3) ,r2, 0.0 , 0.0, (double)i, i*0.1,i*0.2, 355.113};
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
well2_comps[i] = std::move(well_comp);
Add cell data in perforation cells to data::well::completion With this no cell data is needed in opm-output
2018-02-07 07:32:01 -06:00
}
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
Opm::data::Wells wells;
Use RestartValue container for Eclipse output
2018-04-28 05:52:28 -05:00
Opm::data::Solution solution = createBlackoilState(2, numCells);
Restore Build on GCC 4.9 Commit 334dbe4e broke GCC 4.9 (invoking explicit constructor with an empty initializer_list). Restore build by using the actual type.
2018-12-11 10:30:43 -06:00
using SegRes = decltype(wells["w"].segments);
Add Restart Infrastructure for Well's Active Control This commit introduces a new protocol for communicating a well's active constraint (i.e., its current target control mode) between the running simulator and the restart file. In particular, we add a new type Opm::data::CurrentControl whose data members indicate if the well is a producer or injector and, depending on that state, carries information about the pertinent active control mode. The 'prod' member should be defined for producing wells and the 'inj' member should be defined for injectors. Default-constructed objects of this type are 'invalid' and not output to the restart file. Add a CurrentControl member to the Opm::data::Well type to enable communicating this information using existing restart interfaces. Expand existing unit tests to exercise the new data member.
2020-01-29 16:08:02 -06:00
using Ctrl = decltype(wells["w"].current_control);
Restore Build on GCC 4.9 Commit 334dbe4e broke GCC 4.9 (invoking explicit constructor with an empty initializer_list). Restore build by using the actual type.
2018-12-11 10:30:43 -06:00
Add Restart Infrastructure for Well's Active Control This commit introduces a new protocol for communicating a well's active constraint (i.e., its current target control mode) between the running simulator and the restart file. In particular, we add a new type Opm::data::CurrentControl whose data members indicate if the well is a producer or injector and, depending on that state, carries information about the pertinent active control mode. The 'prod' member should be defined for producing wells and the 'inj' member should be defined for injectors. Default-constructed objects of this type are 'invalid' and not output to the restart file. Add a CurrentControl member to the Opm::data::Well type to enable communicating this information using existing restart interfaces. Expand existing unit tests to exercise the new data member.
2020-01-29 16:08:02 -06:00
wells["OP_1"] = { std::move(r1), 1.0, 1.1, 3.1, 1, std::move(well1_comps), SegRes{}, Ctrl{} };
wells["OP_2"] = { std::move(r2), 1.0, 1.1, 3.2, 1, std::move(well2_comps), SegRes{}, Ctrl{} };
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
RestartValue restart_value(std::move(solution), std::move(wells));
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
Extract Summary::eval() out from Summary::add_timestep()
2019-06-03 10:35:26 -05:00
eclipseWriter.writeTimeStep( st,
step,
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
false,
step_time - start_time,
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
std::move(restart_value));
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
}
Reimplement RFT Unit Test in Terms of 'ERft' Class This commit switches the `test_RFT` unit test to using the `ERft` class introduced in commit 24a8efb2 (PR #699). This is the first step towards reimplementing the RFT file output in terms of class EclOutput. The downside to doing this is that we can no longer use the node-based queries of libecl and have to implement a wrapper on top of the raw vectors to be able to ask for the pressure in a given connection's cell.
2019-08-26 08:44:49 -05:00
verifyRFTFile2(Opm::EclIO::OutputStream::outputFileName(rset, "RFT"));
Make sure RFT file is opened in correct mode.
2017-09-09 02:11:30 -05:00
}
}
}
Add New RFT File Writer This commit implements a new file writing function void Opm::RftIO::write() that is intended to replace the current RFT output functionality defined in terms of private class 'RFT' in EclipseIO.cpp. We support the basic RFT output consisting of - Timestamp (elapsed and date) - WELLETC metadata including all unit conventions - Connection cell (I,J,K), connection cell hostgrid (blank for main grid only), connection cell centre depth, connection cell pressure, and connection cell water and gas saturations Connections in inactive cells are omitted. Note that unit of measure strings aren't implemented in terms of UnitSystem::name() due to the strings being padded on the left for centering effect. Add unit tests to exercise the new writer.
2019-08-28 03:31:26 -05:00
BOOST_AUTO_TEST_SUITE_END() // Using_EclipseIO
// =====================================================================
BOOST_AUTO_TEST_SUITE(Using_Direct_Write)
namespace {
struct Setup
{
explicit Setup(const std::string& deckfile)
: Setup{ ::Opm::Parser{}.parseFile(deckfile) }
{}
explicit Setup(const ::Opm::Deck& deck)
: es { deck }
, sched{ deck, es }
{
}
::Opm::EclipseState es;
::Opm::Schedule sched;
};
std::vector<Opm::data::Connection>
connRes_OP1(const ::Opm::EclipseGrid& grid)
{
auto xcon = std::vector<Opm::data::Connection>{};
xcon.reserve(9);
for (auto con = 0; con < 9; ++con) {
xcon.emplace_back();
auto& c = xcon.back();
c.index = grid.getGlobalIndex(8, 8, con);
c.cell_pressure = (120 + con*10)*::Opm::unit::barsa;
c.cell_saturation_gas = 0.15;
c.cell_saturation_water = 0.3 + con/20.0;
}
return xcon;
}
::Opm::data::Well wellSol_OP1(const ::Opm::EclipseGrid& grid)
{
auto xw = ::Opm::data::Well{};
xw.connections = connRes_OP1(grid);
return xw;
}
std::vector<Opm::data::Connection>
connRes_OP2(const ::Opm::EclipseGrid& grid)
{
auto xcon = std::vector<Opm::data::Connection>{};
xcon.reserve(6);
for (auto con = 3; con < 9; ++con) {
xcon.emplace_back();
auto& c = xcon.back();
c.index = grid.getGlobalIndex(3, 3, con);
c.cell_pressure = (120 + con*10)*::Opm::unit::barsa;
c.cell_saturation_gas = 0.6 - con/20.0;
c.cell_saturation_water = 0.25;
}
return xcon;
}
::Opm::data::Well wellSol_OP2(const ::Opm::EclipseGrid& grid)
{
auto xw = ::Opm::data::Well{};
xw.connections = connRes_OP2(grid);
return xw;
}
::Opm::data::WellRates wellSol(const ::Opm::EclipseGrid& grid)
{
auto xw = ::Opm::data::Wells{};
xw["OP_1"] = wellSol_OP1(grid);
xw["OP_2"] = wellSol_OP2(grid);
return xw;
}
}
BOOST_AUTO_TEST_CASE(Basic_Unformatted)
{
using RftDate = ::Opm::EclIO::ERft::RftDate;
const auto rset = RSet { "TESTRFT" };
const auto model = Setup{ "testrft.DATA" };
{
auto rftFile = ::Opm::EclIO::OutputStream::RFT {
rset, ::Opm::EclIO::OutputStream::Formatted { false },
::Opm::EclIO::OutputStream::RFT::OpenExisting{ false }
};
const auto reportStep = 2;
const auto elapsed = model.sched.seconds(reportStep);
const auto& grid = model.es.getInputGrid();
::Opm::RftIO::write(reportStep, elapsed, model.es.getUnits(),
grid, model.sched, wellSol(grid), rftFile);
}
{
const auto rft = ::Opm::EclIO::ERft {
::Opm::EclIO::OutputStream::outputFileName(rset, "RFT")
};
{
const auto xRFT = RFTRresults {
rft, "OP_1", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 1), 1*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 2), 2*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 3), 3*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 1), 120.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 2), 130.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 3), 140.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 4), 150.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 5), 160.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 6), 170.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 7), 180.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 8), 190.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 9), 200.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 1), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 2), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 3), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 4), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 5), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 6), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 7), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 8), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 9), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 1), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 2), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 3), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 5), 0.50f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 6), 0.55f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 7), 0.60f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 8), 0.65f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 9), 0.70f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 150.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 160.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 170.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 180.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 190.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 200.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_1", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_1", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_1");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " BARSA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " BARSA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
}
{
auto rftFile = ::Opm::EclIO::OutputStream::RFT {
rset, ::Opm::EclIO::OutputStream::Formatted { false },
::Opm::EclIO::OutputStream::RFT::OpenExisting{ true }
};
const auto reportStep = 3;
const auto elapsed = model.sched.seconds(reportStep);
const auto& grid = model.es.getInputGrid();
::Opm::RftIO::write(reportStep, elapsed, model.es.getUnits(),
grid, model.sched, wellSol(grid), rftFile);
}
{
const auto rft = ::Opm::EclIO::ERft {
::Opm::EclIO::OutputStream::outputFileName(rset, "RFT")
};
{
const auto xRFT = RFTRresults {
rft, "OP_1", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 1), 1*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 2), 2*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 3), 3*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 1), 120.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 2), 130.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 3), 140.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 4), 150.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 5), 160.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 6), 170.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 7), 180.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 8), 190.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 9), 200.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 1), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 2), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 3), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 4), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 5), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 6), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 7), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 8), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 9), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 1), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 2), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 3), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 5), 0.50f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 6), 0.55f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 7), 0.60f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 8), 0.65f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 9), 0.70f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 150.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 160.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 170.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 180.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 190.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 200.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 11, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 150.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 160.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 170.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 180.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 190.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 200.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_1", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_1", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_1");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " BARSA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " BARSA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
{
const auto date = RftDate{2008, 11, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " BARSA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
}
}
BOOST_AUTO_TEST_CASE(Basic_Formatted)
{
using RftDate = ::Opm::EclIO::ERft::RftDate;
const auto rset = RSet { "TESTRFT" };
const auto model = Setup{ "testrft.DATA" };
{
auto rftFile = ::Opm::EclIO::OutputStream::RFT {
rset, ::Opm::EclIO::OutputStream::Formatted { true },
::Opm::EclIO::OutputStream::RFT::OpenExisting{ false }
};
const auto reportStep = 2;
const auto elapsed = model.sched.seconds(reportStep);
const auto& grid = model.es.getInputGrid();
::Opm::RftIO::write(reportStep, elapsed, model.es.getUnits(),
grid, model.sched, wellSol(grid), rftFile);
}
{
const auto rft = ::Opm::EclIO::ERft {
::Opm::EclIO::OutputStream::outputFileName(rset, "FRFT")
};
{
const auto xRFT = RFTRresults {
rft, "OP_1", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 1), 1*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 2), 2*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 3), 3*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 1), 120.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 2), 130.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 3), 140.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 4), 150.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 5), 160.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 6), 170.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 7), 180.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 8), 190.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 9), 200.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 1), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 2), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 3), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 4), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 5), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 6), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 7), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 8), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 9), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 1), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 2), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 3), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 5), 0.50f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 6), 0.55f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 7), 0.60f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 8), 0.65f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 9), 0.70f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 150.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 160.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 170.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 180.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 190.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 200.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_1", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_1", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_1");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " BARSA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " BARSA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
}
{
auto rftFile = ::Opm::EclIO::OutputStream::RFT {
rset, ::Opm::EclIO::OutputStream::Formatted { true },
::Opm::EclIO::OutputStream::RFT::OpenExisting{ true }
};
const auto reportStep = 3;
const auto elapsed = model.sched.seconds(reportStep);
const auto& grid = model.es.getInputGrid();
::Opm::RftIO::write(reportStep, elapsed, model.es.getUnits(),
grid, model.sched, wellSol(grid), rftFile);
}
{
const auto rft = ::Opm::EclIO::ERft {
::Opm::EclIO::OutputStream::outputFileName(rset, "FRFT")
};
{
const auto xRFT = RFTRresults {
rft, "OP_1", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 1), 1*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 2), 2*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 3), 3*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 1), 120.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 2), 130.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 3), 140.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 4), 150.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 5), 160.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 6), 170.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 7), 180.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 8), 190.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 9), 200.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 1), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 2), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 3), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 4), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 5), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 6), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 7), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 8), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 9), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 1), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 2), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 3), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 5), 0.50f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 6), 0.55f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 7), 0.60f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 8), 0.65f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 9), 0.70f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 150.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 160.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 170.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 180.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 190.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 200.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 11, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 150.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 160.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 170.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 180.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 190.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 200.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_1", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_1", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_1");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " BARSA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " BARSA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
{
const auto date = RftDate{2008, 11, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " BARSA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
}
}
BOOST_AUTO_TEST_CASE(Field_Units)
{
using RftDate = ::Opm::EclIO::ERft::RftDate;
const auto rset = RSet { "TESTRFT" };
const auto model = Setup{ "testrft.DATA" };
const auto usys = ::Opm::UnitSystem::newFIELD();
{
auto rftFile = ::Opm::EclIO::OutputStream::RFT {
rset, ::Opm::EclIO::OutputStream::Formatted { false },
::Opm::EclIO::OutputStream::RFT::OpenExisting{ false }
};
const auto reportStep = 2;
const auto elapsed = model.sched.seconds(reportStep);
const auto& grid = model.es.getInputGrid();
::Opm::RftIO::write(reportStep, elapsed, usys, grid,
model.sched, wellSol(grid), rftFile);
}
{
const auto rft = ::Opm::EclIO::ERft {
::Opm::EclIO::OutputStream::outputFileName(rset, "RFT")
};
{
const auto xRFT = RFTRresults {
rft, "OP_1", RftDate{ 2008, 10, 10 }
};
const auto thick = ::Opm::unit::convert::to(0.25f, ::Opm::unit::feet);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 1), 1*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 2), 2*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 3), 3*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 4), 4*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 5), 5*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 6), 6*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 7), 7*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 8), 8*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 9), 9*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 1), 1.740452852762511e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 2), 1.885490590492720e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 3), 2.030528328222930e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 4), 2.175566065953139e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 5), 2.320603803683348e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 6), 2.465641541413557e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 7), 2.610679279143767e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 8), 2.755717016873976e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 9), 2.900754754604185e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 1), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 2), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 3), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 4), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 5), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 6), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 7), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 8), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 9), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 1), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 2), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 3), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 5), 0.50f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 6), 0.55f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 7), 0.60f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 8), 0.65f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 9), 0.70f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 10, 10 }
};
const auto thick = ::Opm::unit::convert::to(0.25f, ::Opm::unit::feet);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 2.175566065953139e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 2.320603803683348e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 2.465641541413557e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 2.610679279143767e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 2.755717016873976e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 2.900754754604185e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_1", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_1", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_1");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " FEET");
BOOST_CHECK_EQUAL(welletc[ 4], " PSIA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " STB/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], "MSCF/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RB/DAY");
BOOST_CHECK_EQUAL(welletc[10], " FT/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " LB/STB");
BOOST_CHECK_EQUAL(welletc[14], " LB/DAY");
BOOST_CHECK_EQUAL(welletc[15], " LB/LB");
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " FEET");
BOOST_CHECK_EQUAL(welletc[ 4], " PSIA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " STB/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], "MSCF/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RB/DAY");
BOOST_CHECK_EQUAL(welletc[10], " FT/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " LB/STB");
BOOST_CHECK_EQUAL(welletc[14], " LB/DAY");
BOOST_CHECK_EQUAL(welletc[15], " LB/LB");
}
}
{
auto rftFile = ::Opm::EclIO::OutputStream::RFT {
rset, ::Opm::EclIO::OutputStream::Formatted { false },
::Opm::EclIO::OutputStream::RFT::OpenExisting{ true }
};
const auto reportStep = 3;
const auto elapsed = model.sched.seconds(reportStep);
const auto& grid = model.es.getInputGrid();
::Opm::RftIO::write(reportStep, elapsed, usys, grid,
model.sched, wellSol(grid), rftFile);
}
{
const auto rft = ::Opm::EclIO::ERft {
::Opm::EclIO::OutputStream::outputFileName(rset, "RFT")
};
{
const auto xRFT = RFTRresults {
rft, "OP_1", RftDate{ 2008, 10, 10 }
};
const auto thick = ::Opm::unit::convert::to(0.25f, ::Opm::unit::feet);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 1), 1*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 2), 2*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 3), 3*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 4), 4*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 5), 5*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 6), 6*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 7), 7*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 8), 8*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 9), 9*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 1), 1.740452852762511e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 2), 1.885490590492720e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 3), 2.030528328222930e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 4), 2.175566065953139e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 5), 2.320603803683348e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 6), 2.465641541413557e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 7), 2.610679279143767e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 8), 2.755717016873976e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 9), 2.900754754604185e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 1), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 2), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 3), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 4), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 5), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 6), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 7), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 8), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 9), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 1), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 2), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 3), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 5), 0.50f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 6), 0.55f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 7), 0.60f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 8), 0.65f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 9), 0.70f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 10, 10 }
};
const auto thick = ::Opm::unit::convert::to(0.25f, ::Opm::unit::feet);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 2.175566065953139e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 2.320603803683348e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 2.465641541413557e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 2.610679279143767e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 2.755717016873976e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 2.900754754604185e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 11, 10 }
};
const auto thick = ::Opm::unit::convert::to(0.25f, ::Opm::unit::feet);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 5.0e-6f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 2.175566065953139e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 2.320603803683348e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 2.465641541413557e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 2.610679279143767e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 2.755717016873976e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 2.900754754604185e+03f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_1", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_1", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_1");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " FEET");
BOOST_CHECK_EQUAL(welletc[ 4], " PSIA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " STB/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], "MSCF/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RB/DAY");
BOOST_CHECK_EQUAL(welletc[10], " FT/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " LB/STB");
BOOST_CHECK_EQUAL(welletc[14], " LB/DAY");
BOOST_CHECK_EQUAL(welletc[15], " LB/LB");
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " FEET");
BOOST_CHECK_EQUAL(welletc[ 4], " PSIA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " STB/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], "MSCF/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RB/DAY");
BOOST_CHECK_EQUAL(welletc[10], " FT/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " LB/STB");
BOOST_CHECK_EQUAL(welletc[14], " LB/DAY");
BOOST_CHECK_EQUAL(welletc[15], " LB/LB");
}
{
const auto date = RftDate{2008, 11, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " FEET");
BOOST_CHECK_EQUAL(welletc[ 4], " PSIA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " STB/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], "MSCF/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RB/DAY");
BOOST_CHECK_EQUAL(welletc[10], " FT/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " LB/STB");
BOOST_CHECK_EQUAL(welletc[14], " LB/DAY");
BOOST_CHECK_EQUAL(welletc[15], " LB/LB");
}
}
}
BOOST_AUTO_TEST_CASE(Lab_Units)
{
using RftDate = ::Opm::EclIO::ERft::RftDate;
const auto rset = RSet { "TESTRFT" };
const auto model = Setup{ "testrft.DATA" };
const auto usys = ::Opm::UnitSystem::newLAB();
{
auto rftFile = ::Opm::EclIO::OutputStream::RFT {
rset, ::Opm::EclIO::OutputStream::Formatted { false },
::Opm::EclIO::OutputStream::RFT::OpenExisting{ false }
};
const auto reportStep = 2;
const auto elapsed = model.sched.seconds(reportStep);
const auto& grid = model.es.getInputGrid();
::Opm::RftIO::write(reportStep, elapsed, usys, grid,
model.sched, wellSol(grid), rftFile);
}
{
const auto rft = ::Opm::EclIO::ERft {
::Opm::EclIO::OutputStream::outputFileName(rset, "RFT")
};
{
const auto xRFT = RFTRresults {
rft, "OP_1", RftDate{ 2008, 10, 10 }
};
const auto thick = 25.0f; // cm
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 1), 1*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 2), 2*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 3), 3*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 1), 1.184307920059215e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 2), 1.283000246730817e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 3), 1.381692573402418e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 4), 1.480384900074019e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 5), 1.579077226745621e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 6), 1.677769553417222e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 7), 1.776461880088823e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 8), 1.875154206760424e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 9), 1.973846533432026e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 1), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 2), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 3), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 4), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 5), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 6), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 7), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 8), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 9), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 1), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 2), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 3), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 5), 0.50f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 6), 0.55f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 7), 0.60f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 8), 0.65f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 9), 0.70f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 10, 10 }
};
const auto thick = 25.0f; // cm
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 1.480384900074019e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 1.579077226745621e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 1.677769553417222e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 1.776461880088823e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 1.875154206760424e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 1.973846533432026e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_1", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_1", date);
BOOST_CHECK_EQUAL(welletc[ 0], " HR");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_1");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " CM");
BOOST_CHECK_EQUAL(welletc[ 4], " ATMA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SCC/HR");
BOOST_CHECK_EQUAL(welletc[ 8], " SCC/HR");
BOOST_CHECK_EQUAL(welletc[ 9], " RCC/HR");
BOOST_CHECK_EQUAL(welletc[10], " CM/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " GM/SCC");
BOOST_CHECK_EQUAL(welletc[14], " GM/HR");
BOOST_CHECK_EQUAL(welletc[15], " GM/GM");
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " HR");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " CM");
BOOST_CHECK_EQUAL(welletc[ 4], " ATMA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SCC/HR");
BOOST_CHECK_EQUAL(welletc[ 8], " SCC/HR");
BOOST_CHECK_EQUAL(welletc[ 9], " RCC/HR");
BOOST_CHECK_EQUAL(welletc[10], " CM/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " GM/SCC");
BOOST_CHECK_EQUAL(welletc[14], " GM/HR");
BOOST_CHECK_EQUAL(welletc[15], " GM/GM");
}
}
{
auto rftFile = ::Opm::EclIO::OutputStream::RFT {
rset, ::Opm::EclIO::OutputStream::Formatted { false },
::Opm::EclIO::OutputStream::RFT::OpenExisting{ true }
};
const auto reportStep = 3;
const auto elapsed = model.sched.seconds(reportStep);
const auto& grid = model.es.getInputGrid();
::Opm::RftIO::write(reportStep, elapsed, usys, grid,
model.sched, wellSol(grid), rftFile);
}
{
const auto rft = ::Opm::EclIO::ERft {
::Opm::EclIO::OutputStream::outputFileName(rset, "RFT")
};
{
const auto xRFT = RFTRresults {
rft, "OP_1", RftDate{ 2008, 10, 10 }
};
const auto thick = 25.0f; // cm
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 1), 1*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 2), 2*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 3), 3*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 1), 1.184307920059215e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 2), 1.283000246730817e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 3), 1.381692573402418e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 4), 1.480384900074019e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 5), 1.579077226745621e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 6), 1.677769553417222e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 7), 1.776461880088823e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 8), 1.875154206760424e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 9), 1.973846533432026e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 1), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 2), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 3), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 4), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 5), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 6), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 7), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 8), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 9), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 1), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 2), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 3), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 5), 0.50f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 6), 0.55f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 7), 0.60f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 8), 0.65f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 9), 0.70f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 10, 10 }
};
const auto thick = 25.0f; // cm
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 1.480384900074019e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 1.579077226745621e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 1.677769553417222e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 1.776461880088823e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 1.875154206760424e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 1.973846533432026e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 11, 10 }
};
const auto thick = 25.0f; // cm
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 1.480384900074019e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 1.579077226745621e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 1.677769553417222e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 1.776461880088823e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 1.875154206760424e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 1.973846533432026e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_1", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_1", date);
BOOST_CHECK_EQUAL(welletc[ 0], " HR");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_1");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " CM");
BOOST_CHECK_EQUAL(welletc[ 4], " ATMA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SCC/HR");
BOOST_CHECK_EQUAL(welletc[ 8], " SCC/HR");
BOOST_CHECK_EQUAL(welletc[ 9], " RCC/HR");
BOOST_CHECK_EQUAL(welletc[10], " CM/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " GM/SCC");
BOOST_CHECK_EQUAL(welletc[14], " GM/HR");
BOOST_CHECK_EQUAL(welletc[15], " GM/GM");
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " HR");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " CM");
BOOST_CHECK_EQUAL(welletc[ 4], " ATMA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SCC/HR");
BOOST_CHECK_EQUAL(welletc[ 8], " SCC/HR");
BOOST_CHECK_EQUAL(welletc[ 9], " RCC/HR");
BOOST_CHECK_EQUAL(welletc[10], " CM/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " GM/SCC");
BOOST_CHECK_EQUAL(welletc[14], " GM/HR");
BOOST_CHECK_EQUAL(welletc[15], " GM/GM");
}
{
const auto date = RftDate{2008, 11, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " HR");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " CM");
BOOST_CHECK_EQUAL(welletc[ 4], " ATMA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SCC/HR");
BOOST_CHECK_EQUAL(welletc[ 8], " SCC/HR");
BOOST_CHECK_EQUAL(welletc[ 9], " RCC/HR");
BOOST_CHECK_EQUAL(welletc[10], " CM/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " GM/SCC");
BOOST_CHECK_EQUAL(welletc[14], " GM/HR");
BOOST_CHECK_EQUAL(welletc[15], " GM/GM");
}
}
}
BOOST_AUTO_TEST_CASE(PVT_M_Units)
{
using RftDate = ::Opm::EclIO::ERft::RftDate;
const auto rset = RSet { "TESTRFT" };
const auto model = Setup{ "testrft.DATA" };
const auto usys = ::Opm::UnitSystem::newPVT_M();
{
auto rftFile = ::Opm::EclIO::OutputStream::RFT {
rset, ::Opm::EclIO::OutputStream::Formatted { false },
::Opm::EclIO::OutputStream::RFT::OpenExisting{ false }
};
const auto reportStep = 2;
const auto elapsed = model.sched.seconds(reportStep);
const auto& grid = model.es.getInputGrid();
::Opm::RftIO::write(reportStep, elapsed, usys, grid,
model.sched, wellSol(grid), rftFile);
}
{
const auto rft = ::Opm::EclIO::ERft {
::Opm::EclIO::OutputStream::outputFileName(rset, "RFT")
};
{
const auto xRFT = RFTRresults {
rft, "OP_1", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 1), 1*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 2), 2*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 3), 3*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 1), 1.184307920059215e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 2), 1.283000246730817e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 3), 1.381692573402418e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 4), 1.480384900074019e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 5), 1.579077226745621e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 6), 1.677769553417222e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 7), 1.776461880088823e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 8), 1.875154206760424e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 9), 1.973846533432026e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 1), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 2), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 3), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 4), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 5), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 6), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 7), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 8), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 9), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 1), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 2), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 3), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 5), 0.50f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 6), 0.55f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 7), 0.60f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 8), 0.65f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 9), 0.70f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25f;
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 1.480384900074019e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 1.579077226745621e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 1.677769553417222e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 1.776461880088823e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 1.875154206760424e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 1.973846533432026e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_1", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_1", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_1");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " ATMA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " ATMA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
}
{
auto rftFile = ::Opm::EclIO::OutputStream::RFT {
rset, ::Opm::EclIO::OutputStream::Formatted { false },
::Opm::EclIO::OutputStream::RFT::OpenExisting{ true }
};
const auto reportStep = 3;
const auto elapsed = model.sched.seconds(reportStep);
const auto& grid = model.es.getInputGrid();
::Opm::RftIO::write(reportStep, elapsed, usys, grid,
model.sched, wellSol(grid), rftFile);
}
{
const auto rft = ::Opm::EclIO::ERft {
::Opm::EclIO::OutputStream::outputFileName(rset, "RFT")
};
{
const auto xRFT = RFTRresults {
rft, "OP_1", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25;
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 1), 1*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 2), 2*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 3), 3*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(9, 9, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 1), 1.184307920059215e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 2), 1.283000246730817e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 3), 1.381692573402418e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 4), 1.480384900074019e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 5), 1.579077226745621e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 6), 1.677769553417222e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 7), 1.776461880088823e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 8), 1.875154206760424e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(9, 9, 9), 1.973846533432026e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 1), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 2), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 3), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 4), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 5), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 6), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 7), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 8), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(9, 9, 9), 0.15f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 1), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 2), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 3), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 5), 0.50f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 6), 0.55f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 7), 0.60f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 8), 0.65f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(9, 9, 9), 0.70f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 10, 10 }
};
const auto thick = 0.25;
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 1.480384900074019e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 1.579077226745621e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 1.677769553417222e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 1.776461880088823e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 1.875154206760424e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 1.973846533432026e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto xRFT = RFTRresults {
rft, "OP_2", RftDate{ 2008, 11, 10 }
};
const auto thick = 0.25;
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 4), 4*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 5), 5*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 6), 6*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 7), 7*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 8), 8*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.depth(4, 4, 9), 9*thick + thick/2.0f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 4), 1.480384900074019e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 5), 1.579077226745621e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 6), 1.677769553417222e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 7), 1.776461880088823e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 8), 1.875154206760424e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.pressure(4, 4, 9), 1.973846533432026e+02f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 4), 0.45f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 5), 0.40f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 6), 0.35f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 7), 0.30f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.sgas(4, 4, 9), 0.20f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 4), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 5), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 6), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 7), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 8), 0.25f, 1.0e-10f);
BOOST_CHECK_CLOSE(xRFT.swat(4, 4, 9), 0.25f, 1.0e-10f);
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_1", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_1", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_1");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " ATMA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
{
const auto date = RftDate{2008, 10, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " ATMA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
{
const auto date = RftDate{2008, 11, 10};
BOOST_CHECK(rft.hasArray("WELLETC", "OP_2", date));
const auto& welletc = rft.getRft<std::string>("WELLETC", "OP_2", date);
BOOST_CHECK_EQUAL(welletc[ 0], " DAYS");
BOOST_CHECK_EQUAL(welletc[ 1], "OP_2");
BOOST_CHECK_EQUAL(welletc[ 2], "");
BOOST_CHECK_EQUAL(welletc[ 3], " METRES");
BOOST_CHECK_EQUAL(welletc[ 4], " ATMA");
BOOST_CHECK_EQUAL(welletc[ 5], "R");
BOOST_CHECK_EQUAL(welletc[ 6], "STANDARD");
BOOST_CHECK_EQUAL(welletc[ 7], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 8], " SM3/DAY");
BOOST_CHECK_EQUAL(welletc[ 9], " RM3/DAY");
BOOST_CHECK_EQUAL(welletc[10], " M/SEC");
// No check for welletc[11]
BOOST_CHECK_EQUAL(welletc[12], " CP");
BOOST_CHECK_EQUAL(welletc[13], " KG/SM3");
BOOST_CHECK_EQUAL(welletc[14], " KG/DAY");
BOOST_CHECK_EQUAL(welletc[15], " KG/KG");
}
}
}
BOOST_AUTO_TEST_SUITE_END() // Using_Direct_Write
Reference in New Issue Copy Permalink