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

first complete version that satisfies all unit tests

Browse Source
This commit is contained in:
Jostein Alvestad 2021-05-25 10:15:34 +02:00
parent 31c55af919
commit 5907a7520a
10 changed files with 189 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
opm/parser/eclipse/EclipseState/Schedule/Well/WList.hpp
View File

@ -31,11 +31,12 @@ public:
using storage = std::vector<std::string>;
WList() = default;
WList(const storage& wlist);
WList(const storage& wlist, std::string wlname);
std::size_t size() const;
void add(const std::string& well);
void del(const std::string& well);
bool has(const std::string& well) const;
std::string getName() const;
std::vector<std::string> wells() const;
bool operator==(const WList& data) const;
@ -44,10 +45,12 @@ public:
void serializeOp(Serializer& serializer)
{
serializer(well_list);
serializer(name);
}
private:
storage well_list;
std::string name;
};

7
opm/parser/eclipse/EclipseState/Schedule/Well/WListManager.hpp
View File

@ -33,14 +33,16 @@ public:
static WListManager serializeObject();
//const std::vector<std::string> wListInputSeq()const;
std::size_t WListSize() const;
bool hasList(const std::string&) const;
WList& getList(const std::string& name);
const WList& getList(const std::string& name) const;
WList& newList(const std::string& name);
WList& newList(const std::string& name, const std::vector<std::string>& wname);
//void delWell(const std::string& well);
const std::vector<std::string>& getWListNames(const std::string& wname) const;
std::size_t getNoWListsWell(std::string wname) const;
bool hasWList(const std::string& wname) const;
void addWListWell(const std::string& wname, const std::string& wlname);
void delWell(const std::string& wname);
@ -53,11 +55,14 @@ public:
{
serializer.map(wlists);
serializer.map(well_wlist_names);
//serializer.vector(wlist_input_seq);
}
private:
std::map<std::string, WList> wlists;
std::map<std::string, std::vector<std::string>> well_wlist_names;
std::map<std::string, std::size_t> no_wlists_well;
//std::vector<std::string> wlist_input_seq;
};
}

13
src/opm/output/eclipse/AggregateWListData.cpp
View File

@ -112,6 +112,19 @@ std::vector<std::vector<std::size_t>> wellOrderInWList(const Opm::Schedule& sc
throw std::logic_error(msg);
}
}
/*for (const auto& wlst_name : wlmngr.wListInputSeq()) {
if (std::count(wListNames.begin(), wListNames.end(), wlst_name) > 0) {
if (wlmngr.hasList(wlst_name)) {
wlist = wlmngr.getList(wlst_name);
auto well_no = findInVector<std::string>(wlist.wells(), wname);
if (well_no) well_order[iwlst] = well_no.value() + 1;
iwlst += 1;
} else {
auto msg = fmt::format("Well List Manager does not contain WLIST: {} ", wlst_name);
throw std::logic_error(msg);
}
}
}*/
}
//store vector in map - and reset vector values to zero
curWelOrd.push_back(well_order);

2
src/opm/parser/eclipse/EclipseState/Schedule/KeywordHandlers.cpp
View File

@ -1595,7 +1595,7 @@ namespace {
throw std::invalid_argument("The list name in WLIST must start with a '*'");
if (action == "NEW") {
new_wlm.newList(name);
new_wlm.newList(name, wells);
}
if (!new_wlm.hasList(name))

9
src/opm/parser/eclipse/EclipseState/Schedule/Well/WList.cpp
View File

@ -22,8 +22,9 @@
namespace Opm {
WList::WList(const storage& wlist) :
well_list(wlist)
WList::WList(const storage& wlist, std::string wlname) :
well_list(wlist),
name(wlname)
{
}
@ -33,6 +34,10 @@ std::size_t WList::size() const {
}
std::string WList::getName() const {
return this->name;
}
bool WList::has(const std::string& well) const {
return (std::count(this->well_list.begin(), this->well_list.end(), well) > 0);
}

76
src/opm/parser/eclipse/EclipseState/Schedule/Well/WListManager.cpp
View File

@ -27,10 +27,20 @@
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WListManager.hpp>
namespace Opm {
template <typename T>
std::optional<int> findInVector(const std::vector<T> & vecOfElements, const T & element)
{
// Find given element in vector
auto it = std::find(vecOfElements.begin(), vecOfElements.end(), element);
return (it != vecOfElements.end()) ? std::optional<int> {std::distance(vecOfElements.begin(), it)} :
std::nullopt;
}
WListManager WListManager::serializeObject()
{
WListManager result;
result.wlists = {{"test1", WList({"test2", "test3"})}};
result.wlists = {{"test1", WList({"test2", "test3"}, "test1")}};
return result;
}
@ -44,12 +54,36 @@ namespace Opm {
}
WList& WListManager::newList(const std::string& name) {
/*WList& WListManager::newList(const std::string& name) {
this->wlists.erase(name);
this->wlists.insert( {name, WList() });
this->wlists.insert({name, WList({}, name)});
return this->getList(name);
}*/
WList& WListManager::newList(const std::string& name, const std::vector<std::string>& new_well_names) {
if (this->hasList(name)) {
auto& wlist = getList(name);
std::vector<std::string> replace_wellnames;
for (const auto& wname : wlist.wells()){
if (std::count(new_well_names.begin(), new_well_names.end(), wname) == 0) {
this->delWListWell(wname, name);
} else {
replace_wellnames.push_back(wname);
}
}
for (const auto& rwname : replace_wellnames) {
wlist.del(rwname);
}
} else {
//this->wlist_input_seq.push_back(name);
this->wlists.insert( {name, WList({}, name)} );
}
return this->getList(name);
}
//const std::vector<std::string> WListManager::wListInputSeq() const {
// return this->wlist_input_seq;
//}
WList& WListManager::getList(const std::string& name) {
return this->wlists.at(name);
@ -78,20 +112,29 @@ namespace Opm {
}
}
std::size_t WListManager::getNoWListsWell(std::string wname) const {
return this->no_wlists_well.at(wname);
}
void WListManager::addWListWell(const std::string& wname, const std::string& wlname) {
//add well to wlist if it is not already in the well list
auto& wlist = this->getList(wlname);
wlist.add(wname);
//add well list to well if not in vector already
if (this->well_wlist_names.count(wname) > 0) {
auto& no_wl = this->no_wlists_well.at(wname);
auto& wlist_vec = this->well_wlist_names.at(wname);
if (std::count(wlist_vec.begin(), wlist_vec.end(), wlname) == 0)
if (std::count(wlist_vec.begin(), wlist_vec.end(), wlname) == 0) {
wlist_vec.push_back(wlname);
no_wl += 1;
}
} else {
//make wlist vector for new well
std::vector<std::string> new_wlvec;
std::size_t sz = 1;
new_wlvec.push_back(wlname);
this->well_wlist_names.insert({wname, new_wlvec});
this->no_wlists_well.insert({wname, sz});
}
}
@ -99,21 +142,38 @@ namespace Opm {
for (auto& pair: this->wlists) {
auto& wlist = pair.second;
wlist.del(wname);
if (this->well_wlist_names.count(wname) > 0) {
auto& wlist_vec = this->well_wlist_names.at(wname);
auto& no_wl = this->no_wlists_well.at(wname);
auto itwl = std::find(wlist_vec.begin(), wlist_vec.end(), wlist.getName());
if (itwl != wlist_vec.end()) {
wlist_vec.erase(itwl);
no_wl -= 1;
if (no_wl == 0) {
wlist_vec.clear();
}
}
}
}
const auto& it = this->well_wlist_names.find(wname);
this->well_wlist_names.erase(it);
}
void WListManager::delWListWell(const std::string& wname, const std::string& wlname) {
//delete well from well list
auto& wlist = this->getList(wlname);
wlist.del(wname);
if (this->well_wlist_names.count(wname) > 0) {
auto& wlist_vec = this->well_wlist_names.at(wname);
// remove wlist element from vector of well lists for a well
auto& no_wl = this->no_wlists_well.at(wname);
// reduce the no of well lists associated with a well, delete whole list if no wlists is zero
const auto& it = std::find(wlist_vec.begin(), wlist_vec.end(), wlname);
if (it != wlist_vec.end()) {
wlist_vec.erase(it);
//wlist_vec.erase(it);
no_wl -= 1;
if (no_wl == 0) {
wlist_vec.clear();
}
}
}
}

14
tests/TEST_WLIST.DATA
View File

@ -2564,6 +2564,17 @@ WLIST --written by schedule script
DATES
10 SEP 2020 /
/
WLIST --written by schedule script
'*PRD1' NEW 'P2' 'P3' /
/
WLIST --written by schedule script
'*PRD2' NEW 'P1' /
/
DATES
20 SEP 2020 /
1 OCT 2020 /
10 OCT 2020 /
@ -2573,9 +2584,6 @@ DATES
1 JAN 2021 /
/
-- 1.5 2 2 5 10 10 30 30 30 30 30 30 30 /
END

9
tests/parser/ACTIONX.cpp
View File

@ -651,10 +651,11 @@ BOOST_AUTO_TEST_CASE(TestWLIST) {
Action::Context context(st, wlm);
auto& wl = wlm.newList("*LIST1");
wl.add("W1");
wl.add("W3");
wl.add("W5");
//auto& wl = wlm.newList("*LIST1");
auto& wl = wlm.newList("*LIST1", {"W1", "W3", "W5"});
//wl.add("W1");
//wl.add("W3");
//wl.add("W5");
auto res = ast.eval(context);
auto wells = res.wells();
BOOST_CHECK(res);

18
tests/parser/WLIST.cpp
View File

@ -76,28 +76,28 @@ BOOST_AUTO_TEST_CASE(WLISTManager) {
{
auto& wlist1 = wlm.newList("LIST1");
wlist1.add("A");
wlist1.add("B");
wlist1.add("C");
auto& wlist1 = wlm.newList("LIST1", {"A", "B", "C"});
//wlist1.add("A");
//wlist1.add("B");
//wlist1.add("C");
}
// If a new list is added with the same name as an existing list the old
// list is dropped and a new list is created.
{
auto& wlist1 = wlm.newList("LIST1");
auto& wlist1 = wlm.newList("LIST1", {});
BOOST_CHECK_EQUAL(wlist1.size(), 0U);
}
auto& wlist1 = wlm.newList("LIST1");
auto& wlist2 = wlm.newList("LIST2");
auto& wlist1 = wlm.newList("LIST1", {"W1", "W2", "W3"});
auto& wlist2 = wlm.newList("LIST2", {"W1", "W2", "W3"});
wlist1.add("W1");
/*wlist1.add("W1");
wlist1.add("W2");
wlist1.add("W3");
wlist2.add("W1");
wlist2.add("W2");
wlist2.add("W3");
wlist2.add("W3"); */
// The delWell operation will work across all well lists.
wlm.delWell("W1");

66
tests/test_AggregateWListData.cpp
View File

@ -84,7 +84,7 @@ struct SimulationCase
BOOST_AUTO_TEST_SUITE(Aggregate_WList)
// test dimensions of multisegment data
// test dimensions for IWLS and ZWLS plus the vectors for different cases
BOOST_AUTO_TEST_CASE (Constructor)
{
namespace VI = ::Opm::RestartIO::Helpers::VectorItems;
@ -424,6 +424,70 @@ BOOST_AUTO_TEST_CASE (Constructor)
BOOST_CHECK_EQUAL(zWLs[start + 3].c_str(), blank8);
}
// Report Step 9 (10.09.20)
{
const auto simStep = std::size_t {8};
double secs_elapsed = 3.1536E07;
const auto ih
= Opm::RestartIO::Helpers::createInteHead(es, grid, sched, secs_elapsed, simStep, simStep + 1, simStep);
auto wListData = Opm::RestartIO::Helpers::AggregateWListData(ih);
wListData.captureDeclaredWListData(sched, simStep, ih);
// IWls-parameters
auto iWLs = wListData.getIWls();
auto start = 0 * ih[VI::intehead::MXWLSTPRWELL];
BOOST_CHECK_EQUAL(iWLs[start + 0], 1);
BOOST_CHECK_EQUAL(iWLs[start + 1], 0);
BOOST_CHECK_EQUAL(iWLs[start + 2], 0);
BOOST_CHECK_EQUAL(iWLs[start + 3], 0);
start = 1 * ih[VI::intehead::MXWLSTPRWELL];
BOOST_CHECK_EQUAL(iWLs[start + 0], 0);
BOOST_CHECK_EQUAL(iWLs[start + 1], 1);
BOOST_CHECK_EQUAL(iWLs[start + 2], 0);
BOOST_CHECK_EQUAL(iWLs[start + 3], 0);
start = 2 * ih[VI::intehead::MXWLSTPRWELL];
BOOST_CHECK_EQUAL(iWLs[start + 0], 0);
BOOST_CHECK_EQUAL(iWLs[start + 1], 2);
BOOST_CHECK_EQUAL(iWLs[start + 2], 0);
BOOST_CHECK_EQUAL(iWLs[start + 3], 0);
start = 3 * ih[VI::intehead::MXWLSTPRWELL];
BOOST_CHECK_EQUAL(iWLs[start + 0], 1);
BOOST_CHECK_EQUAL(iWLs[start + 1], 0);
BOOST_CHECK_EQUAL(iWLs[start + 2], 0);
BOOST_CHECK_EQUAL(iWLs[start + 3], 0);
// ZWLs-parameters
const std::string blank8 = " ";
auto zWLs = wListData.getZWls();
start = 0 * ih[VI::intehead::MXWLSTPRWELL];
BOOST_CHECK_EQUAL(zWLs[start + 0].c_str(), pad8("*PRD2"));
BOOST_CHECK_EQUAL(zWLs[start + 1].c_str(), blank8);
BOOST_CHECK_EQUAL(zWLs[start + 2].c_str(), blank8);
BOOST_CHECK_EQUAL(zWLs[start + 3].c_str(), blank8);
start = 1 * ih[VI::intehead::MXWLSTPRWELL];
BOOST_CHECK_EQUAL(zWLs[start + 0].c_str(), blank8);
BOOST_CHECK_EQUAL(zWLs[start + 1].c_str(), pad8("*PRD1"));
BOOST_CHECK_EQUAL(zWLs[start + 2].c_str(), blank8);
BOOST_CHECK_EQUAL(zWLs[start + 3].c_str(), blank8);
start = 2 * ih[VI::intehead::MXWLSTPRWELL];
BOOST_CHECK_EQUAL(zWLs[start + 0].c_str(), blank8);
BOOST_CHECK_EQUAL(zWLs[start + 1].c_str(), pad8("*PRD1"));
BOOST_CHECK_EQUAL(zWLs[start + 2].c_str(), blank8);
BOOST_CHECK_EQUAL(zWLs[start + 3].c_str(), blank8);
start = 3 * ih[VI::intehead::MXWLSTPRWELL];
BOOST_CHECK_EQUAL(zWLs[start + 0].c_str(), pad8("*INJ1"));
BOOST_CHECK_EQUAL(zWLs[start + 1].c_str(), blank8);
BOOST_CHECK_EQUAL(zWLs[start + 2].c_str(), blank8);
BOOST_CHECK_EQUAL(zWLs[start + 3].c_str(), blank8);
}
}
BOOST_AUTO_TEST_SUITE_END()