diff --git a/CMakeLists_files.cmake b/CMakeLists_files.cmake index cf91ae393..88be0379d 100644 --- a/CMakeLists_files.cmake +++ b/CMakeLists_files.cmake @@ -104,6 +104,7 @@ if(ENABLE_ECL_INPUT) src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionValue.cpp src/opm/parser/eclipse/EclipseState/Schedule/Action/ASTNode.cpp src/opm/parser/eclipse/EclipseState/Schedule/Action/Condition.cpp + src/opm/parser/eclipse/EclipseState/Schedule/Action/Enums.cpp src/opm/parser/eclipse/EclipseState/Schedule/Action/State.cpp src/opm/parser/eclipse/EclipseState/Schedule/ArrayDimChecker.cpp src/opm/parser/eclipse/EclipseState/Schedule/eval_uda.cpp @@ -284,6 +285,7 @@ if(ENABLE_ECL_OUTPUT) src/opm/io/eclipse/ExtSmryOutput.cpp src/opm/io/eclipse/RestartFileView.cpp src/opm/io/eclipse/SummaryNode.cpp + src/opm/io/eclipse/rst/action.cpp src/opm/io/eclipse/rst/aquifer.cpp src/opm/io/eclipse/rst/connection.cpp src/opm/io/eclipse/rst/group.cpp @@ -489,6 +491,9 @@ if(ENABLE_ECL_OUTPUT) tests/SOFR_TEST.DATA tests/UDQ_BASE.DATA tests/UDQ_RESTART.DATA + tests/UDQ_ACTIONX.X0007 + tests/UDQ_ACTIONX.DATA + tests/UDQ_ACTIONX_RESTART.DATA tests/UDQ_TEST_WCONPROD_IUAD-2.DATA tests/9_4C_WINJ_GINJ_UDQ_MSW-UDARATE_TEST_PACK.DATA tests/UDQ_ACTIONX_TEST1.DATA @@ -763,6 +768,7 @@ if(ENABLE_ECL_INPUT) opm/parser/eclipse/EclipseState/Schedule/Action/Actions.hpp opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.hpp opm/parser/eclipse/EclipseState/Schedule/Action/Condition.hpp + opm/parser/eclipse/EclipseState/Schedule/Action/Enums.hpp opm/parser/eclipse/EclipseState/Schedule/Action/ASTNode.hpp opm/parser/eclipse/EclipseState/Schedule/Action/PyAction.hpp opm/parser/eclipse/EclipseState/Schedule/Action/State.hpp @@ -873,6 +879,7 @@ if(ENABLE_ECL_OUTPUT) opm/io/eclipse/ExtSmryOutput.hpp opm/io/eclipse/RestartFileView.hpp opm/io/eclipse/SummaryNode.hpp + opm/io/eclipse/rst/action.hpp opm/io/eclipse/rst/aquifer.hpp opm/io/eclipse/rst/connection.hpp opm/io/eclipse/rst/group.hpp diff --git a/opm/io/eclipse/rst/action.hpp b/opm/io/eclipse/rst/action.hpp new file mode 100644 index 000000000..b5c9451f8 --- /dev/null +++ b/opm/io/eclipse/rst/action.hpp @@ -0,0 +1,74 @@ +/* + Copyright 2021 Equinor 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 . +*/ + +#ifndef RST_ACTIONX +#define RST_ACTIONX + +#include +#include +#include +#include +#include + +#include + +namespace Opm { + +namespace RestartIO { + +struct RstAction { + struct Quantity { + std::variant quantity; + std::optional wgname; + + Quantity() = default; + Quantity(const std::string * zacn, double sacn_value); + Quantity(const std::string& quantity); + Quantity(double value); + }; + + + struct Condition { + static bool valid(const std::string * zacn, const int * iacn); + Condition(const std::string * zacn, const int * iacn, const double * sacn); + Action::Logical logic; + Action::Comparator cmp_op; + Quantity lhs; + Quantity rhs; + bool left_paren{false}; + bool right_paren{false}; + + std::vector tokens() const; + }; + + + RstAction(const std::string& name_arg, int max_run_arg, double min_wait_arg, std::time_t start_time, std::vector conditions_arg); + + std::string name; + int max_run; + double min_wait; + std::time_t start_time; + std::vector conditions; +}; + +} +} + + + +#endif diff --git a/opm/io/eclipse/rst/header.hpp b/opm/io/eclipse/rst/header.hpp index 88f4803c0..ddeda7114 100644 --- a/opm/io/eclipse/rst/header.hpp +++ b/opm/io/eclipse/rst/header.hpp @@ -89,7 +89,7 @@ struct RstHeader { int nwell_udq; int ngroup_udq; int nfield_udq; - + int num_action; bool e300_radial; bool e100_radial; diff --git a/opm/io/eclipse/rst/state.hpp b/opm/io/eclipse/rst/state.hpp index 767795b9e..ec37817ec 100644 --- a/opm/io/eclipse/rst/state.hpp +++ b/opm/io/eclipse/rst/state.hpp @@ -28,6 +28,7 @@ #include #include #include +#include #include @@ -37,6 +38,7 @@ namespace Opm { class EclipseGrid; class Parser; + class Actdims; } // namespace Opm namespace Opm { namespace EclIO { @@ -63,6 +65,7 @@ struct RstState { std::vector groups; std::vector udqs; RstUDQActive udq_active; + std::vector actions; Tuning tuning; private: @@ -99,6 +102,15 @@ private: const std::vector& dudg, const std::vector& dudf); + void add_actions(const Actdims& actdims, + std::time_t sim_time, + const std::vector& zact, + const std::vector& iact, + const std::vector& sact, + const std::vector& zacn, + const std::vector& iacn, + const std::vector& sacn); + }; }} // namespace Opm::RestartIO diff --git a/opm/output/eclipse/VectorItems/action.hpp b/opm/output/eclipse/VectorItems/action.hpp index d53cb2369..ca3d54593 100644 --- a/opm/output/eclipse/VectorItems/action.hpp +++ b/opm/output/eclipse/VectorItems/action.hpp @@ -38,7 +38,7 @@ namespace Opm { namespace RestartIO { namespace Helpers { namespace VectorItems // The same enum is used for both lefthand side and righthand side quantities; // although not all values can be used on both sides. namespace Value { - enum QuantiyType { + enum QuantityType { Field = 1, Well = 2, Group = 3, @@ -63,6 +63,7 @@ namespace Opm { namespace RestartIO { namespace Helpers { namespace VectorItems namespace SACN { enum index : std::vector::size_type { + LHSValue0 = 0, RHSValue0 = 2, LHSValue1 = 4, RHSValue1 = 5, @@ -78,15 +79,19 @@ namespace Opm { namespace RestartIO { namespace Helpers { namespace VectorItems namespace ZACN { enum index : std::vector::size_type { + Quantity = 0, LHSQuantity = 0, RHSQuantity = 1, Comparator = 2, + Well = 3, LHSWell = 3, RHSWell = 4, + Group = 5, LHSGroup = 5, RHSGroup = 6 }; + constexpr std::size_t RHSOffset = 1; constexpr std::size_t ConditionSize = 13; } diff --git a/opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.hpp b/opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.hpp index ded8fe0ce..6a4df798b 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.hpp +++ b/opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.hpp @@ -38,6 +38,11 @@ namespace Opm { class DeckKeyword; class WellMatcher; +namespace RestartIO { +struct RstAction; +} + + namespace Action { class State; @@ -71,6 +76,7 @@ public: ActionX(const std::string& name, size_t max_run, double max_wait, std::time_t start_time); ActionX(const DeckKeyword& kw, std::time_t start_time); ActionX(const DeckRecord& record, std::time_t start_time); + explicit ActionX(const RestartIO::RstAction& rst_action); static ActionX serializeObject(); diff --git a/opm/parser/eclipse/EclipseState/Schedule/Action/Condition.hpp b/opm/parser/eclipse/EclipseState/Schedule/Action/Condition.hpp index 16496431c..c25bc35f9 100644 --- a/opm/parser/eclipse/EclipseState/Schedule/Action/Condition.hpp +++ b/opm/parser/eclipse/EclipseState/Schedule/Action/Condition.hpp @@ -24,6 +24,8 @@ #include #include +#include +#include namespace Opm { @@ -34,7 +36,9 @@ class Quantity { public: Quantity() = default; - Quantity(const std::string& arg) : + explicit Quantity(const RestartIO::RstAction::Quantity& rst_quantity); + + explicit Quantity(const std::string& arg) : quantity(arg) {} @@ -63,23 +67,8 @@ public: class Condition { public: -enum class Logical { - AND, - OR, - END -}; - -enum class Comparator { - EQUAL, - GREATER, - LESS, - GREATER_EQUAL, - LESS_EQUAL, - INVALID -}; - - Condition() = default; + explicit Condition(const RestartIO::RstAction::Condition& rst_condition); Condition(const std::vector& tokens, const KeywordLocation& location); @@ -94,7 +83,6 @@ enum class Comparator { static Logical logic_from_int(int); int logic_as_int() const; - static Comparator comparator_from_int(int); int comparator_as_int() const; int paren_as_int() const; bool open_paren() const; diff --git a/opm/parser/eclipse/EclipseState/Schedule/Action/Enums.hpp b/opm/parser/eclipse/EclipseState/Schedule/Action/Enums.hpp new file mode 100644 index 000000000..e224124e2 --- /dev/null +++ b/opm/parser/eclipse/EclipseState/Schedule/Action/Enums.hpp @@ -0,0 +1,51 @@ +/* + Copyright 2021 Equinor 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 . +*/ + +#ifndef ACTION_ENUMS_HPP +#define ACTION_ENUMS_HPP + +#include + +namespace Opm { +namespace Action { + +enum class Logical { + AND, + OR, + END +}; + +enum class Comparator { + EQUAL, + GREATER, + LESS, + GREATER_EQUAL, + LESS_EQUAL, + INVALID +}; + + +Comparator comparator_from_int(int cmp_int); +std::string comparator_as_string(Comparator cmp); +Logical logic_from_int(int int_logic); + +} +} + +#endif diff --git a/src/opm/io/eclipse/rst/action.cpp b/src/opm/io/eclipse/rst/action.cpp new file mode 100644 index 000000000..208bbb949 --- /dev/null +++ b/src/opm/io/eclipse/rst/action.cpp @@ -0,0 +1,146 @@ +/* + Copyright 2021 Equinor 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 . +*/ +#include + +#include +#include +#include +#include + +namespace Opm { +namespace RestartIO { + +namespace IACN = Helpers::VectorItems::IACN; +namespace SACN = Helpers::VectorItems::SACN; +namespace ZACN = Helpers::VectorItems::ZACN; + + +RstAction::RstAction(const std::string& name_arg, int max_run_arg, double min_wait_arg, std::time_t start_time_arg, std::vector conditions_arg) + : name(name_arg) + , max_run(max_run_arg) + , min_wait(min_wait_arg) + , start_time(start_time_arg) + , conditions(conditions_arg) +{ +} + + +RstAction::Quantity::Quantity(const std::string * zacn, double sacn_value) { + auto str_quantity = trim_copy(zacn[ZACN::Quantity]); + if (str_quantity.empty()) { + this->quantity = sacn_value; + return; + } + + this->quantity = str_quantity; + if (str_quantity[0] == 'W') + this->wgname = trim_copy(zacn[ZACN::Well]); + else if (str_quantity[0] == 'G') + this->wgname = trim_copy(zacn[ZACN::Group]); +} + +RstAction::Quantity::Quantity(const std::string& q) + : quantity(q) +{ +} + +RstAction::Quantity::Quantity(double value) + : quantity(value) +{ +} + + + +RstAction::Condition::Condition(const std::string * zacn, const int * iacn, const double * sacn) + : logic(Action::logic_from_int(iacn[IACN::TerminalLogic])) + , cmp_op(Action::comparator_from_int(iacn[IACN::Comparator])) +{ + auto type_index = IACN::LHSQuantityType; + auto rhs_value = sacn[SACN::RHSValue0]; + if (iacn[type_index] == IACN::Value::Day) { + this->lhs = RstAction::Quantity("DAY"); + this->rhs = RstAction::Quantity(rhs_value); + return; + } + + if (iacn[type_index] == IACN::Value::Month) { + this->lhs = RstAction::Quantity("MNTH"); + this->rhs = RstAction::Quantity(TimeService::eclipseMonthNames().at(static_cast(rhs_value))); + return; + } + + if (iacn[type_index] == IACN::Value::Year) { + this->lhs = RstAction::Quantity("YEAR"); + this->rhs = RstAction::Quantity(rhs_value); + return; + } + + this->lhs = RstAction::Quantity(zacn, sacn[SACN::LHSValue0]); + this->rhs = RstAction::Quantity(&zacn[ZACN::RHSOffset], sacn[SACN::RHSValue0]); + this->left_paren = (iacn[IACN::Paren] == IACN::Value::Open); + this->right_paren = (iacn[IACN::Paren] == IACN::Value::Close); +} + +bool RstAction::Condition::valid(const std::string * zacn, const int * iacn) { + auto type_index = IACN::LHSQuantityType; + if (iacn[type_index] == IACN::Value::Day) + return true; + + if (iacn[type_index] == IACN::Value::Month) + return true; + + if (iacn[type_index] == IACN::Value::Year) + return true; + + auto str_quantity = trim_copy(zacn[ZACN::LHSQuantity]); + return !str_quantity.empty(); +} + +std::vector RstAction::Condition::tokens() const { + std::vector tokens; + if (this->left_paren) + tokens.push_back("("); + + tokens.push_back(std::get(this->lhs.quantity)); + if (this->lhs.wgname.has_value()) + tokens.push_back(this->lhs.wgname.value()); + + tokens.push_back(Action::comparator_as_string(this->cmp_op)); + + if (std::holds_alternative(this->rhs.quantity)) + tokens.push_back(std::get(this->rhs.quantity)); + else + tokens.push_back(format_double(std::get(this->rhs.quantity))); + + if (this->rhs.wgname.has_value()) + tokens.push_back(this->rhs.wgname.value()); + + if (this->right_paren) + tokens.push_back(")"); + + if (this->logic == Action::Logical::AND) + tokens.push_back("AND"); + + if (this->logic == Action::Logical::OR) + tokens.push_back("OR"); + + return tokens; +} + +} +} diff --git a/src/opm/io/eclipse/rst/header.cpp b/src/opm/io/eclipse/rst/header.cpp index e7df5970a..50d66b355 100644 --- a/src/opm/io/eclipse/rst/header.cpp +++ b/src/opm/io/eclipse/rst/header.cpp @@ -90,6 +90,7 @@ RstHeader::RstHeader(const Opm::UnitSystem& unit_system, const std::vector& nwell_udq(intehead[VI::intehead::NO_WELL_UDQS]), ngroup_udq(intehead[VI::intehead::NO_GROUP_UDQS]), nfield_udq(intehead[VI::intehead::NO_FIELD_UDQS]), + num_action(intehead[VI::intehead::NOOFACTIONS]), // e300_radial(logihead[VI::logihead::E300Radial]), e100_radial(logihead[VI::logihead::E100Radial]), @@ -127,7 +128,7 @@ RstHeader::RstHeader(const Opm::UnitSystem& unit_system, const std::vector& std::time_t RstHeader::sim_time() const { TimeStampUTC ts(this->year, this->month, this->mday); ts.hour(this->hour); - ts.minutes(this->minute); + ts.minutes(this->minute); ts.microseconds(this->microsecond); return asTimeT(ts); } diff --git a/src/opm/io/eclipse/rst/state.cpp b/src/opm/io/eclipse/rst/state.cpp index 074b0a4f8..ce9f471d0 100644 --- a/src/opm/io/eclipse/rst/state.cpp +++ b/src/opm/io/eclipse/rst/state.cpp @@ -28,6 +28,7 @@ #include #include #include +#include #include #include @@ -35,6 +36,8 @@ #include #include #include +#include +#include namespace { @@ -60,6 +63,7 @@ namespace { { return Opm::UDQ::updateType(iudq[udq_index * Opm::UDQDims::entriesPerIUDQ()]); } + } namespace VI = ::Opm::RestartIO::Helpers::VectorItems; @@ -261,6 +265,55 @@ void RstState::add_udqs(const std::vector& iudq, } } +std::string oper_string(Action::Logical logic) { + if (logic == Action::Logical::AND) + return "AND"; + + if (logic == Action::Logical::OR) + return "OR"; + + return ""; +} + + +void RstState::add_actions(const Actdims& actdims, + std::time_t sim_time, + const std::vector& zact, + const std::vector& iact, + const std::vector& sact, + const std::vector& zacn, + const std::vector& iacn, + const std::vector& sacn) +{ + auto zact_action_size = RestartIO::Helpers::entriesPerZACT(); + auto iact_action_size = RestartIO::Helpers::entriesPerIACT(); + auto sact_action_size = RestartIO::Helpers::entriesPerSACT(); + auto zacn_action_size = RestartIO::Helpers::entriesPerZACN(actdims); + auto iacn_action_size = RestartIO::Helpers::entriesPerIACN(actdims); + auto sacn_action_size = RestartIO::Helpers::entriesPerSACN(actdims); + + auto zacn_cond_size = 13; + auto iacn_cond_size = 26; + auto sacn_cond_size = 16; + + for (std::size_t index=0; index < static_cast(this->header.num_action); index++) { + std::vector conditions; + for (std::size_t icond = 0; icond < actdims.max_conditions(); icond++) { + const auto zacn_offset = index * zacn_action_size + icond * zacn_cond_size; + const auto iacn_offset = index * iacn_action_size + icond * iacn_cond_size; + const auto sacn_offset = index * sacn_action_size + icond * sacn_cond_size; + + if (RstAction::Condition::valid(&zacn[zacn_offset], &iacn[iacn_offset])) + conditions.emplace_back(&zacn[zacn_offset], &iacn[iacn_offset], &sacn[sacn_offset]); + } + + const auto& name = zact[index * zact_action_size + 0]; + const auto& max_run = iact[index * iact_action_size + 5]; + const auto& min_wait = this->unit_system.to_si(UnitSystem::measure::time, sact[index * sact_action_size + 3]); + this->actions.emplace_back(name, max_run, min_wait, sim_time, conditions ); + } +} + const RstWell& RstState::get_well(const std::string& wname) const { const auto well_iter = std::find_if(this->wells.begin(), @@ -275,7 +328,7 @@ const RstWell& RstState::get_well(const std::string& wname) const { } RstState RstState::load(std::shared_ptr rstView, - const Runspec&, + const Runspec& runspec, const Parser&, const ::Opm::EclipseGrid* grid) { @@ -330,6 +383,17 @@ RstState RstState::load(std::shared_ptr rstView, } } + if (state.header.num_action > 0) { + const auto& zact = rstView->getKeyword("ZACT"); + const auto& iact = rstView->getKeyword("IACT"); + const auto& sact = rstView->getKeyword("SACT"); + const auto& zacn = rstView->getKeyword("ZACN"); + const auto& iacn = rstView->getKeyword("IACN"); + const auto& sacn = rstView->getKeyword("SACN"); + state.add_actions(runspec.actdims(), state.header.sim_time(), zact, iact, sact, zacn, iacn, sacn); + } + + return state; } diff --git a/src/opm/output/eclipse/AggregateActionxData.cpp b/src/opm/output/eclipse/AggregateActionxData.cpp index af75bd08d..89b1ff24e 100644 --- a/src/opm/output/eclipse/AggregateActionxData.cpp +++ b/src/opm/output/eclipse/AggregateActionxData.cpp @@ -36,6 +36,7 @@ #include #include #include +#include #include #include #include @@ -73,7 +74,7 @@ namespace { {"Y", 0}, };*/ - using cmp_enum = Opm::Action::Condition::Comparator; + using cmp_enum = Opm::Action::Comparator; const std::map cmpToIacn_12 = { {cmp_enum::GREATER, 0}, {cmp_enum::LESS, 1}, @@ -90,7 +91,7 @@ const std::map rhsQuantityToIndex = { {"G", 3}, }; -using logic_enum = Opm::Action::Condition::Logical; +using logic_enum = Opm::Action::Logical; const std::map logicalToIndex_17 = { {logic_enum::AND, 1}, @@ -331,7 +332,7 @@ const std::map logicalToIndex_17 = { int first_greater = 0; { const auto& first_cond = actx_cond[0]; - if (first_cond.cmp == Opm::Action::Condition::Comparator::LESS) + if (first_cond.cmp == Opm::Action::Comparator::LESS) first_greater = 1; } @@ -378,7 +379,7 @@ const std::map logicalToIndex_17 = { parenFirstCond = true; insideParen = true; } - if (cond_it->logic == Opm::Action::Condition::Logical::AND) { + if (cond_it->logic == Opm::Action::Logical::AND) { allPrevLogicOp_AND = true; } } else { @@ -402,9 +403,9 @@ const std::map logicalToIndex_17 = { } // update the previous logic-sequence - if (parenFirstCond && cond_it->logic == Opm::Action::Condition::Logical::OR) { + if (parenFirstCond && cond_it->logic == Opm::Action::Logical::OR) { allPrevLogicOp_AND = false; - } else if (!insideParen && cond_it->logic == Opm::Action::Condition::Logical::OR) { + } else if (!insideParen && cond_it->logic == Opm::Action::Logical::OR) { allPrevLogicOp_AND = false; } } diff --git a/src/opm/output/eclipse/CreateActionRSTDims.cpp b/src/opm/output/eclipse/CreateActionRSTDims.cpp index 6afdcd715..5c7be006c 100755 --- a/src/opm/output/eclipse/CreateActionRSTDims.cpp +++ b/src/opm/output/eclipse/CreateActionRSTDims.cpp @@ -91,9 +91,7 @@ std::size_t Opm::RestartIO::Helpers::entriesPerIACN(const Opm::Actdims& actdims) std::size_t Opm::RestartIO::Helpers::entriesPerSACN(const Opm::Actdims& actdims) { - //16 - std::size_t no_entries = 16 * actdims.max_conditions(); - return no_entries; + return Opm::RestartIO::Helpers::VectorItems::SACN::ConditionSize * actdims.max_conditions(); } std::size_t Opm::RestartIO::Helpers::entriesPerIACT() diff --git a/src/opm/output/eclipse/InteHEAD.cpp b/src/opm/output/eclipse/InteHEAD.cpp index 35448e4b6..0bef2be73 100644 --- a/src/opm/output/eclipse/InteHEAD.cpp +++ b/src/opm/output/eclipse/InteHEAD.cpp @@ -755,12 +755,12 @@ Opm::RestartIO::InteHEAD& Opm::RestartIO::InteHEAD:: variousUDQ_ACTIONXParam() { - this -> data_[159] = 4; - this -> data_[160] = 5; - this -> data_[161] = 9; - this -> data_[246] = 26; - this -> data_[247] = 16; - this -> data_[248] = 13; + this -> data_[159] = 4; // entriesPerZACT?? + this -> data_[160] = 5; // entriesPerSACT?? + this -> data_[161] = 9; // entriesPerIACT?? + this -> data_[246] = 26; // entriesPerIACN (multiply max_conditions) + this -> data_[247] = 16; // entriesPerSACN (multiply max_conditions) + this -> data_[248] = 13; // entriesPerZACN (multiply max_conditions) return *this; } diff --git a/src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.cpp b/src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.cpp index 138d1f187..c92520c16 100644 --- a/src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.cpp +++ b/src/opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.cpp @@ -28,6 +28,7 @@ #include #include #include +#include #include "ActionParser.hpp" @@ -60,6 +61,22 @@ ActionX::ActionX(const std::string& name, size_t max_run, double min_wait, std:: m_start_time(start_time) {} +ActionX::ActionX(const RestartIO::RstAction& rst_action) + : m_name(rst_action.name) + , m_max_run(rst_action.max_run) + , m_min_wait(rst_action.min_wait), + m_start_time(rst_action.start_time) +{ + std::vector tokens; + for (const auto& rst_condition : rst_action.conditions) { + this->m_conditions.emplace_back(rst_condition); + const auto& cond_tokens = rst_condition.tokens(); + tokens.insert(tokens.end(), cond_tokens.begin(), cond_tokens.end()); + } + this->condition = Action::AST(tokens); +} + + ActionX::ActionX(const DeckRecord& record, std::time_t start_time) : ActionX( record.getItem("NAME").getTrimmedString(0), @@ -70,6 +87,9 @@ ActionX::ActionX(const DeckRecord& record, std::time_t start_time) : {} + + + ActionX::ActionX(const DeckKeyword& kw, std::time_t start_time) : ActionX(kw.getRecord(0), start_time) { @@ -102,8 +122,8 @@ ActionX ActionX::serializeObject() Condition cond; cond.lhs = quant; cond.rhs = quant; - cond.logic = Condition::Logical::AND; - cond.cmp = Condition::Comparator::GREATER_EQUAL; + cond.logic = Logical::AND; + cond.cmp = Comparator::GREATER_EQUAL; cond.cmp_string = "test3"; result.m_conditions = {cond}; diff --git a/src/opm/parser/eclipse/EclipseState/Schedule/Action/Condition.cpp b/src/opm/parser/eclipse/EclipseState/Schedule/Action/Condition.cpp index ca6f95ef4..1bbadaa95 100644 --- a/src/opm/parser/eclipse/EclipseState/Schedule/Action/Condition.cpp +++ b/src/opm/parser/eclipse/EclipseState/Schedule/Action/Condition.cpp @@ -17,13 +17,17 @@ along with OPM. If not, see . */ +#include #include #include +#include #include #include #include +#include +#include #include "ActionParser.hpp" @@ -34,44 +38,26 @@ namespace Action { namespace { -Condition::Comparator comparator(TokenType tt) { +Comparator comparator(TokenType tt) { if (tt == TokenType::op_eq) - return Condition::Comparator::EQUAL; + return Comparator::EQUAL; if (tt == TokenType::op_gt) - return Condition::Comparator::GREATER; + return Comparator::GREATER; if (tt == TokenType::op_lt) - return Condition::Comparator::LESS; + return Comparator::LESS; if (tt == TokenType::op_le) - return Condition::Comparator::LESS_EQUAL; + return Comparator::LESS_EQUAL; if (tt == TokenType::op_ge) - return Condition::Comparator::GREATER_EQUAL; + return Comparator::GREATER_EQUAL; - return Condition::Comparator::INVALID; + return Comparator::INVALID; } -std::string cmp2string(Condition::Comparator cmp) { - if (cmp == Condition::Comparator::EQUAL) - return "="; - - if (cmp == Condition::Comparator::GREATER) - return ">"; - - if (cmp == Condition::Comparator::LESS) - return "<"; - - if (cmp == Condition::Comparator::LESS_EQUAL) - return "<="; - - if (cmp == Condition::Comparator::GREATER_EQUAL) - return ">="; - - throw std::logic_error("Bug in opm/flow - should not be here"); -} std::string strip_quotes(const std::string& s) { if (s[0] == '\'') @@ -82,6 +68,18 @@ std::string strip_quotes(const std::string& s) { } +Quantity::Quantity(const RestartIO::RstAction::Quantity& rst_quantity) +{ + if (std::holds_alternative(rst_quantity.quantity)) + this->quantity = std::get(rst_quantity.quantity); + else + this->quantity = format_double(std::get(rst_quantity.quantity)); + + if (rst_quantity.wgname.has_value()) + this->add_arg(rst_quantity.wgname.value()); +} + + void Quantity::add_arg(const std::string& arg) { this->args.push_back(strip_quotes(arg)); } @@ -127,6 +125,17 @@ int Quantity::int_type() const { } +Condition::Condition(const RestartIO::RstAction::Condition& rst_condition) + : lhs(rst_condition.lhs) + , rhs(rst_condition.rhs) + , logic(rst_condition.logic) + , cmp(rst_condition.cmp_op) + , left_paren(rst_condition.left_paren) + , right_paren(rst_condition.right_paren) +{ +} + + Condition::Condition(const std::vector& tokens, const KeywordLocation& location) { std::size_t token_index = 0; if (tokens[0] == "(") { @@ -146,7 +155,7 @@ Condition::Condition(const std::vector& tokens, const KeywordLocati token_index += 1; } else { this->cmp = comp; - this->cmp_string = cmp2string(this->cmp); + this->cmp_string = comparator_as_string(this->cmp); token_index += 1; break; } @@ -164,9 +173,9 @@ Condition::Condition(const std::vector& tokens, const KeywordLocati auto token_type = Parser::get_type(tokens[token_index]); if (token_type == TokenType::op_and) - this->logic = Condition::Logical::AND; + this->logic = Logical::AND; else if (token_type == TokenType::op_or) - this->logic = Condition::Logical::OR; + this->logic = Logical::OR; else if (token_type == TokenType::close_paren) this->right_paren = true; else @@ -207,19 +216,6 @@ int Condition::paren_as_int() const { } -Condition::Logical Condition::logic_from_int(int int_logic) { - if (int_logic == 0) - return Logical::END; - - if (int_logic == 1) - return Logical::AND; - - if (int_logic == 2) - return Logical::OR; - - throw std::logic_error("Unknown integer value"); -} - int Condition::logic_as_int() const { switch (this->logic) { case Logical::END: @@ -233,37 +229,21 @@ int Condition::logic_as_int() const { } } -Condition::Comparator Condition::comparator_from_int(int cmp_int) { - switch (cmp_int) { - case 1: - return Condition::Comparator::GREATER; - case 2: - return Condition::Comparator::LESS; - case 3: - return Condition::Comparator::GREATER_EQUAL; - case 4: - return Condition::Comparator::LESS_EQUAL; - case 5: - return Condition::Comparator::EQUAL; - default: - throw std::logic_error("What the f...?"); - } -} int Condition::comparator_as_int() const { switch (this->cmp) { - case Condition::Comparator::GREATER: + case Comparator::GREATER: return 1; - case Condition::Comparator::LESS: + case Comparator::LESS: return 2; - case Condition::Comparator::GREATER_EQUAL: + case Comparator::GREATER_EQUAL: return 3; - case Condition::Comparator::LESS_EQUAL: + case Comparator::LESS_EQUAL: return 4; - case Condition::Comparator::EQUAL: + case Comparator::EQUAL: return 5; default: - throw std::logic_error("What the f...?"); + throw std::logic_error(fmt::format("Unhandeled value: {} in enum comparison", static_cast(this->cmp))); } } diff --git a/src/opm/parser/eclipse/EclipseState/Schedule/Action/Enums.cpp b/src/opm/parser/eclipse/EclipseState/Schedule/Action/Enums.cpp new file mode 100644 index 000000000..a7b48e875 --- /dev/null +++ b/src/opm/parser/eclipse/EclipseState/Schedule/Action/Enums.cpp @@ -0,0 +1,81 @@ +/* + Copyright 2021 Equinor 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 . +*/ + +#include +#include + +#include + +namespace Opm { +namespace Action { + +Logical logic_from_int(int int_logic) { + if (int_logic == 0) + return Logical::END; + + if (int_logic == 1) + return Logical::AND; + + if (int_logic == 2) + return Logical::OR; + + throw std::logic_error("Unknown integer value"); +} + + + + +Comparator comparator_from_int(int cmp_int) { + switch (cmp_int) { + case 1: + return Comparator::GREATER; + case 2: + return Comparator::LESS; + case 3: + return Comparator::GREATER_EQUAL; + case 4: + return Comparator::LESS_EQUAL; + case 5: + return Comparator::EQUAL; + default: + throw std::logic_error(fmt::format("Integer value: {} could not be converted to ACTIONX comparator", cmp_int)); + } +} + +std::string comparator_as_string(Comparator cmp) { + if (cmp == Comparator::EQUAL) + return "="; + + if (cmp == Comparator::GREATER) + return ">"; + + if (cmp == Comparator::LESS) + return "<"; + + if (cmp == Comparator::LESS_EQUAL) + return "<="; + + if (cmp == Comparator::GREATER_EQUAL) + return ">="; + + throw std::logic_error("Bug in opm/flow - should not be here"); +} + +} +} diff --git a/src/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp b/src/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp index 93efa91c4..63da6c111 100644 --- a/src/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp +++ b/src/opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp @@ -1467,6 +1467,14 @@ namespace { } this->snapshots.back().udq_active.update( std::move(udq_active) ); } + + + if (!rst_state.actions.empty()) { + auto actions = this->snapshots.back().actions(); + for (const auto& rst_action : rst_state.actions) + actions.add( Action::ActionX(rst_action) ); + this->snapshots.back().actions.update( std::move(actions) ); + } } std::shared_ptr Schedule::python() const diff --git a/tests/UDQ_ACTIONX.DATA b/tests/UDQ_ACTIONX.DATA new file mode 100644 index 000000000..fb4968ad6 --- /dev/null +++ b/tests/UDQ_ACTIONX.DATA @@ -0,0 +1,569 @@ +RUNSPEC +TITLE + 'Generic' 'Reservoir' +NOECHO +DIMENS + 3 5 4 / +START + 22 'AUG' 2018 / +OIL +GAS +WATER +DISGAS +METRIC +TABDIMS + 1 1 130 24 1 20 / +EQLDIMS + 2 100 20 / +WELLDIMS + 230 120 50 80 / +UNIFIN +UNIFOUT +UDQDIMS + 50 25 0 50 50 0 0 + 50 0 20 / +UDADIMS + 10 1* 10 / +GRID +NOECHO +INIT +GRIDFILE + 0 1 / +MAPAXES + 0 100 0 0 100 0 / +NOECHO +SPECGRID + 3 5 4 1 'F' / +COORD + 2000 2000 2000 1999.5638 2000 2039.9619 2199.8096 + 2000 2008.7239 2199.3735 2000 2048.6858 2399.6193 2000 + 2017.4478 2399.1831 2000 2057.4097 2599.4289 2000 2026.1716 + 2598.9927 2000 2066.1336 2000 2200 2000 1999.5638 + 2200 2039.9619 2199.8096 2200 2008.7239 2199.3735 2200 + 2048.6858 2399.6193 2200 2017.4478 2399.1831 2200 2057.4097 + 2599.4289 2200 2026.1716 2598.9927 2200 2066.1336 2000 + 2400 2000 1999.5638 2400 2039.9619 2199.8096 2400 + 2008.7239 2199.3735 2400 2048.6858 2399.6193 2400 2017.4478 + 2399.1831 2400 2057.4097 2599.4289 2400 2026.1716 2598.9927 + 2400 2066.1336 2000 2600 2000 1999.5638 2600 + 2039.9619 2199.8096 2600 2008.7239 2199.3735 2600 2048.6858 + 2399.6193 2600 2017.4478 2399.1831 2600 2057.4097 2599.4289 + 2600 2026.1716 2598.9927 2600 2066.1336 2000 2800 + 2000 1999.5638 2800 2039.9619 2199.8096 2800 2008.7239 + 2199.3735 2800 2048.6858 2399.6193 2800 2017.4478 2399.1831 + 2800 2057.4097 2599.4289 2800 2026.1716 2598.9927 2800 + 2066.1336 2000 3000 2000 1999.5638 3000 2039.9619 + 2199.8096 3000 2008.7239 2199.3735 3000 2048.6858 2399.6193 + 3000 2017.4478 2399.1831 3000 2057.4097 2599.4289 3000 + 2026.1716 2598.9927 3000 2066.1336 / +ZCORN + 2000 2008.7239 2008.7239 2017.4478 2017.4478 2026.1716 2000 + 2008.7239 2008.7239 2017.4478 2017.4478 2026.1716 2000 2008.7239 + 2008.7239 2017.4478 2017.4478 2026.1716 2000 2008.7239 2008.7239 + 2017.4478 2017.4478 2026.1716 2000 2008.7239 2008.7239 2017.4478 + 2017.4478 2026.1716 2000 2008.7239 2008.7239 2017.4478 2017.4478 + 2026.1716 2000 2008.7239 2008.7239 2017.4478 2017.4478 2026.1716 + 2000 2008.7239 2008.7239 2017.4478 2017.4478 2026.1716 2000 + 2008.7239 2008.7239 2017.4478 2017.4478 2026.1716 2000 2008.7239 + 2008.7239 2017.4478 2017.4478 2026.1716 2009.9905 2018.7144 2018.7144 + 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 + 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 + 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 + 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 + 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 + 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 + 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 + 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 + 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 + 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 + 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 + 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 + 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 + 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 + 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 + 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 + 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2019.981 2028.7048 + 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 + 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 + 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 + 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 + 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 + 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 + 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 + 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 + 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 + 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 + 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 + 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 + 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 + 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 + 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 + 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 + 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 2029.9714 + 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 + 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 + 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 + 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 + 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 + 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 + 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 + 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 + 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 + 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 + 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 + 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 + 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 + 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 + 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 + 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 + 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 + 2039.9619 2048.6858 2048.6858 2057.4097 2057.4097 2066.1336 2039.9619 + 2048.6858 2048.6858 2057.4097 2057.4097 2066.1336 2039.9619 2048.6858 + 2048.6858 2057.4097 2057.4097 2066.1336 2039.9619 2048.6858 2048.6858 + 2057.4097 2057.4097 2066.1336 2039.9619 2048.6858 2048.6858 2057.4097 + 2057.4097 2066.1336 2039.9619 2048.6858 2048.6858 2057.4097 2057.4097 + 2066.1336 2039.9619 2048.6858 2048.6858 2057.4097 2057.4097 2066.1336 + 2039.9619 2048.6858 2048.6858 2057.4097 2057.4097 2066.1336 2039.9619 + 2048.6858 2048.6858 2057.4097 2057.4097 2066.1336 2039.9619 2048.6858 + 2048.6858 2057.4097 2057.4097 2066.1336 / +PORO + 0.25 0.25 0.25 0.25 0.25 0.25 0.25 + 0.25 0.25 0.25 0.25 0.25 0.25 0.25 + 0.25 0.2 0.2 0.2 0.2 0.2 0.2 + 0.2 0.2 0.2 0.2 0.2 0.2 0.2 + 0.2 0.2 0.23 0.23 0.23 0.23 0.23 + 0.23 0.23 0.23 0.23 0.23 0.23 0.23 + 0.23 0.23 0.23 0.18 0.18 0.18 0.18 + 0.18 0.18 0.18 0.18 0.18 0.18 0.18 + 0.18 0.18 0.18 0.18 / +PERMX + 500 500 500 500 500 500 500 + 500 500 500 500 500 500 500 + 500 100 100 100 100 100 100 + 100 100 100 100 100 100 100 + 100 100 1000 1000 1000 1000 1000 + 1000 1000 1000 1000 1000 1000 1000 + 1000 1000 1000 250 250 250 250 + 250 250 250 250 250 250 250 + 250 250 250 250 / +COPY + 'PERMX' 'PERMY' / + 'PERMX' 'PERMZ' / +/ +MULTIPLY + 'PERMZ' 0.1 / +/ +MULTZ + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 0 0 0 0 0 0 + 0 0 0 0 0 0 0 + 0 0 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 1 1 / +EDIT +PROPS +SGOF + 0 0 1 0 0.0183 0.001480314 0.8127534 + 0 0.0366 0.004696335 0.675857 0 0.0549 0.009371694 + 0.5622753 0 0.0732 0.01546379 0.4663578 0 0.0915 + 0.02298664 0.385133 0 0.1098 0.03197913 0.3164995 0 + 0.1281 0.04249268 0.2587408 0 0.1464 0.05458466 0.2103665 + 0 0.1647 0.06831379 0.1700565 0 0.183 0.08373629 + 0.1366388 0 0.2013 0.1009022 0.1090792 0 0.2196 + 0.1198516 0.08647139 0 0.2379 0.1406109 0.06802822 0 + 0.2562 0.1631885 0.05307051 0 0.2745 0.1875705 0.04101619 + 0 0.2928 0.2137163 0.03136912 0 0.3111 0.2415547 + 0.02370834 0 0.3294 0.2709792 0.01767817 0 0.3477 + 0.3018447 0.01297907 0 0.366 0.3339653 0.009359652 0 + 0.3843 0.3671116 0.006609586 0 0.4026 0.401011 0.00455345 + 0 0.4209 0.4353486 0.003045475 0 0.4392 0.4697695 + 0.001965044 0 0.4575 0.5038828 0.001212868 0 0.4758 + 0.5372664 0.0007077659 0 0.4941 0.5694721 0.000383946 0 + 0.5124 0.6000285 0.0001887263 0 0.5307 0.6284408 8.062741e-05 + 0 0.549 0.6541796 2.778023e-05 0 0.5673 0.676644 + 6.602397e-06 0 0.5856 0.6950468 7.048731e-07 0 0.61 + 0.71 0 0 0.6275 0.7825 0 0 + 0.645 0.855 0 0 0.6625 0.9275 0 + 0 0.68 1 0 0 / +SWOF + 0.32 0 1 0 0.3365 3.00925e-08 0.9804566 + 0 0.353 7.541952e-07 0.9391194 0 0.3695 5.01876e-06 + 0.8832853 0 0.386 1.941502e-05 0.8178788 0 0.4025 + 5.581854e-05 0.7471578 0 0.419 0.0001330574 0.674704 0 + 0.4355 0.0002787865 0.60333 0 0.452 0.0005316304 0.535068 + 0 0.4685 0.0009436502 0.4712431 0 0.485 0.001583182 + 0.412597 0 0.5015 0.002538082 0.3594268 0 0.518 + 0.00391938 0.3117147 0 0.5345 0.005865308 0.2692366 0 + 0.551 0.008545575 0.2316458 0 0.5675 0.01216566 0.1985336 + 0 0.584 0.01697073 0.169471 0 0.6005 0.0232485 + 0.1440352 0 0.617 0.03133019 0.1218258 0 0.6335 + 0.04158825 0.1024735 0 0.65 0.05442925 0.08564409 0 + 0.6665 0.07028023 0.0710386 0 0.683 0.08956673 0.05839253 + 0 0.6995 0.1126816 0.0474734 0 0.716 0.1399451 + 0.03807806 0 0.7325 0.1715593 0.03002991 0 0.749 + 0.2075632 0.02317622 0 0.7655 0.2478002 0.01738581 0 + 0.782 0.2919105 0.01254709 0 0.7985 0.3393688 0.008566921 + 0 0.815 0.3895919 0.005370427 0 0.8315 0.4421811 + 0.002903191 0 0.848 0.4975608 0.001139647 0 0.87 + 0.59168 0 0 0.8885714 0.6500114 0 0 + 0.9071429 0.7083429 0 0 0.9257143 0.7666743 0 + 0 0.9442857 0.8250057 0 0 0.9628571 0.8833371 + 0 0 0.9814286 0.9416686 0 0 1 + 1 0 0 / +PVDG + 20 0.061895 0.01299 40 0.030252 0.01383 60 + 0.019844 0.0145 80 0.014686 0.0152 100 0.011627 + 0.01596 120 0.009619 0.01682 140 0.008213 0.0178 + 160 0.007184 0.0189 197.66 0.00582 0.0216 231.13 + 0.005042 0.02477 261.31 0.004561 0.02844 288.87 0.004255 + 0.03272 314.34 0.004062 0.03783 338.2 0.003953 0.0441 + 360.83 0.003947 0.0521 382.58 0.003915 0.06273 403.6 + 0.003912 0.07723 423.77 0.003907 0.09631 / +PVTO + 19.6 20 1.12324 0.96519 55 1.11698 1.03237 + 90 1.11127 1.10051 125 1.10602 1.16942 160 + 1.10119 1.2389 195 1.09672 1.30876 230 1.09256 + 1.37884 265 1.08868 1.44899 300 1.08504 1.51908 + 335 1.08164 1.58903 370 1.07843 1.65876 / + 31.5 40 1.15981 0.85738 75 1.15288 0.91402 + 110 1.14657 0.97137 145 1.14079 1.02927 180 + 1.13546 1.08759 215 1.13053 1.14617 250 1.12595 + 1.20488 285 1.12168 1.2636 320 1.11768 1.32224 + 355 1.11394 1.38073 390 1.11042 1.43898 / + 42.4 60 1.191 0.7868 95 1.184 0.8364 + 130 1.177 0.8866 165 1.171 0.9371 200 + 1.165 0.988 235 1.16 1.039 270 1.155 + 1.0902 305 1.15 1.1413 340 1.146 1.1922 + 375 1.142 1.2431 410 1.138 1.2936 / + 53.4 80 1.222 0.7175 115 1.214 0.7608 + 150 1.206 0.8045 185 1.2 0.8485 220 + 1.194 0.8928 255 1.188 0.9371 290 1.183 + 0.9815 325 1.178 1.0258 360 1.173 1.07 + 395 1.169 1.1141 430 1.165 1.1579 / + 64.6 100 1.252 0.6544 135 1.244 0.6923 + 170 1.236 0.7305 205 1.229 0.7689 240 + 1.222 0.8075 275 1.216 0.8461 310 1.211 + 0.8847 345 1.205 0.9233 380 1.2 0.9618 + 415 1.196 1 450 1.191 1.0381 / + 76.3 120 1.284 0.5978 155 1.275 0.6312 + 190 1.266 0.6648 225 1.259 0.6985 260 + 1.252 0.7323 295 1.245 0.7661 330 1.239 + 0.7999 365 1.234 0.8337 400 1.229 0.8673 + 435 1.224 0.9007 470 1.219 0.934 / + 88.5 140 1.316 0.5477 175 1.307 0.5749 + 210 1.298 0.602 245 1.29 0.629 280 + 1.282 0.6559 315 1.276 0.6827 350 1.269 + 0.7095 385 1.263 0.7362 420 1.258 0.7629 + 455 1.253 0.7895 490 1.248 0.8161 / + 101.3 160 1.35 0.502 195 1.34 0.5227 + 230 1.331 0.5432 265 1.322 0.5635 300 + 1.314 0.5835 335 1.307 0.6034 370 1.3 + 0.6231 405 1.294 0.6426 440 1.288 0.662 + 475 1.283 0.6813 / + 114.7 180 1.385 0.4636 215 1.375 0.482 + 250 1.365 0.5003 285 1.356 0.5183 320 + 1.347 0.5362 355 1.34 0.5538 390 1.333 + 0.5712 425 1.326 0.5885 460 1.32 0.6055 + 495 1.314 0.6222 / + 128.9 200 1.422 0.429 235 1.411 0.4455 + 270 1.401 0.4618 305 1.391 0.4779 340 + 1.382 0.4938 375 1.374 0.5096 410 1.367 + 0.5252 445 1.36 0.5406 480 1.353 0.5558 / + 143.8 220 1.461 0.3977 255 1.449 0.4125 + 290 1.438 0.4271 325 1.428 0.4415 360 + 1.419 0.4558 395 1.41 0.4699 430 1.402 + 0.4839 465 1.395 0.4977 / + 159.5 240 1.502 0.3692 275 1.489 0.3825 + 310 1.478 0.3956 345 1.467 0.4086 380 + 1.458 0.4214 415 1.449 0.4341 450 1.44 + 0.4466 485 1.432 0.459 / + 184 268.79 1.565 0.3324 303.79 1.551 0.3438 + 338.79 1.539 0.3551 373.79 1.528 0.3663 408.79 + 1.517 0.3774 443.79 1.508 0.3883 478.79 1.499 + 0.3991 / + 226.3 306.18 1.679 0.2855 341.18 1.664 0.2949 + 376.18 1.65 0.3041 411.18 1.637 0.3132 446.18 + 1.625 0.3222 481.18 1.614 0.3311 / + 268.6 339.93 1.792 0.2517 374.93 1.775 0.2597 + 409.93 1.76 0.2675 444.93 1.746 0.2751 479.93 + 1.732 0.2827 / + 310.9 371.44 1.903 0.2265 406.44 1.885 0.2333 + 441.44 1.868 0.2401 476.44 1.853 0.2468 / + 353.3 401.66 2.013 0.2071 436.66 1.993 0.2132 + 471.66 1.975 0.2192 / +/ +PVTW + 344.83 1.0292 4.002e-05 0.36 0 / +ROCK + 383 4.12e-05 / +DENSITY + 842.3 1001.1 0.9 / +REGIONS +EQLNUM + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 2 2 2 2 2 + 2 2 2 2 2 2 2 + 2 2 2 2 2 2 2 + 2 2 2 2 2 2 2 + 2 2 2 2 / +SOLUTION +EQUIL + 2030 382.4 2030 0 500 0 1 + 1 0 / + 2050 382.4 2050 0 500 0 1 + 1 0 / +RSVD + 1500 180 4000 180 / + 1500 180 4000 180 / +RPTRST + 'BASIC=2' 'PBPD' / +SUMMARY +FOPR +FOPRH +FGPR +FGPRH +FWPR +FWPRH +FWIR +FWIP +FOIP +FGIP +FWCT +FWCTH +FGOR +FGORH +FPR +RPR + / +ROIP + / +ROIPL + / +ROIPG + / +RGIP + / +RGIPL + / +RGIPG + / +RGPR + / +RGPT + / +GWIR + / +GVIR + / +GOPR + / +GWPR + / +GLPR + / +GLPR + / +GVPR + / +WOPR + / +WOPRH + / +WGPR + / +WGPRH + / +WWPR + / +WWPRH + / +WOPT + / +WWPT + / +WGPT + / +WOPTH + / +WWPTH + / +WGPTH + / +WWCT + / +WWCTH + / +WGOR + / +WGORH + / +WWIR + / +WWIRH + / +WGIR + / +WGIRH + / +WWIT + / +WWITH + / +WGIT + / +WGITH + / +WBHP + / +WTHP + / +WPI + / +WVPR + / +WBP + / +WBP4 + / +WBP9 + / +WMCTL + / +WLPR + / +FMWIN +FMWPR +GMWPR + 'UPPER' 'LOWER' / +GMWIN + 'UPPER' 'LOWER' / +WUPR1 + 'OP*' / +WUPR3 + 'OP*' / +SCHEDULE +GRUPTREE + 'UPPER' 'TEST' / + 'LOWER' 'TEST' / +/ +WELSPECS + 'OPU01' 'UPPER' 1 2 2002 'OIL' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / + 'OPU02' 'UPPER' 1 4 2002 'OIL' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / + 'OPL01' 'LOWER' 1 2 2025 'OIL' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / + 'OPL02' 'LOWER' 1 4 2025 'OIL' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / +/ +WELSPECS + 'WIU01' 'UPPER' 3 3 2030 'WATER' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / + 'WIL01' 'LOWER' 3 3 2050 'WATER' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / +/ +COMPDAT + 'OPU01' 1 2 1 1 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / + 'OPU02' 1 4 1 1 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / + 'OPL01' 1 2 3 3 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / + 'OPL02' 1 4 3 3 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / + 'WIU01' 3 3 2 2 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / + 'WIL01' 3 3 4 4 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / +/ +WCONPROD + 'OPU*' 'SHUT' 'GRUP' 1500 2* 2500 1* + 60 / + 'OPL*' 'SHUT' 'GRUP' 1500 2* 2500 1* + 60 / +/ +WCONINJE + 'WIU*' 'WATER' 'SHUT' 'GRUP' 10500 1* 500 / + 'WIL*' 'WATER' 'SHUT' 'GRUP' 10500 1* 500 / +/ +UDQ + DEFINE 'WUPR1' 1/(WWCT 'OP*' ) / + DEFINE 'WUPR3' SORTA(WUPR1) / +/ +GCONPROD + 'TEST' 'LRAT' 6000 2* 6000 'RATE' 'NO' / + 'LOWER' 'FLD' 6000 2* 6000 'RATE' 'YES' + 1* 'FORM' / + 'UPPER' 'FLD' 3000 2* 6000 'RATE' 'YES' + 1* 'FORM' / +/ +GCONINJE + 'LOWER' 'WATER' 'VREP' 3* 1.2 / + 'UPPER' 'WATER' 'VREP' 3* 2 / +/ +GUIDERAT + 0 'OIL' 1 0.5 1 1 0 + 0 'YES' 0.5 / +ACTIONX + 'ACT01' 10 / + FMWPR >= 4 AND / + WUPR3 'OP*' = 1 / +/ +WELOPEN + '?' 'SHUT' 0 0 0 / +/ +ENDACTIO +DATES + 1 'SEP' 2018 / +/ +WELOPEN + 'OPL01' 'OPEN' / +/ +DATES + 1 'OCT' 2018 / +/ +WELOPEN + 'WIL01' 'OPEN' / +/ +DATES + 1 'NOV' 2018 / +/ +WELOPEN + 'OPL02' 'OPEN' / +/ +DATES + 1 'DEC' 2018 / +/ +WELOPEN + 'OPU01' 'OPEN' / +/ +DATES + 1 'MAY' 2019 / +/ +WELOPEN + 'OPU02' 'OPEN' / +/ +DATES + 1 'JUN' 2019 / +/ +WELOPEN + 'WIU01' 'OPEN' / +/ +DATES + 1 'JAN' 2021 / +/ +DATES + 1 'MAR' 2021 / +/ +DATES + 1 'MAY' 2021 / +/ +DATES + 1 'JUL' 2021 / +/ diff --git a/tests/UDQ_ACTIONX.X0007 b/tests/UDQ_ACTIONX.X0007 new file mode 100644 index 000000000..17e634d77 Binary files /dev/null and b/tests/UDQ_ACTIONX.X0007 differ diff --git a/tests/UDQ_ACTIONX_RESTART.DATA b/tests/UDQ_ACTIONX_RESTART.DATA new file mode 100644 index 000000000..a6c016893 --- /dev/null +++ b/tests/UDQ_ACTIONX_RESTART.DATA @@ -0,0 +1,563 @@ +RUNSPEC +TITLE + 'Generic' 'Reservoir' +NOECHO +DIMENS + 3 5 4 / +START + 22 'AUG' 2018 / +OIL +GAS +WATER +DISGAS +METRIC +TABDIMS + 1 1 130 24 1 20 / +EQLDIMS + 2 100 20 / +WELLDIMS + 230 120 50 80 / +UNIFOUT +UDQDIMS + 50 25 0 50 50 0 0 + 50 0 20 / +UDADIMS + 10 1* 10 / +GRID +NOECHO +INIT +GRIDFILE + 0 1 / +MAPAXES + 0 100 0 0 100 0 / +NOECHO +SPECGRID + 3 5 4 1 'F' / +COORD + 2000 2000 2000 1999.5638 2000 2039.9619 2199.8096 + 2000 2008.7239 2199.3735 2000 2048.6858 2399.6193 2000 + 2017.4478 2399.1831 2000 2057.4097 2599.4289 2000 2026.1716 + 2598.9927 2000 2066.1336 2000 2200 2000 1999.5638 + 2200 2039.9619 2199.8096 2200 2008.7239 2199.3735 2200 + 2048.6858 2399.6193 2200 2017.4478 2399.1831 2200 2057.4097 + 2599.4289 2200 2026.1716 2598.9927 2200 2066.1336 2000 + 2400 2000 1999.5638 2400 2039.9619 2199.8096 2400 + 2008.7239 2199.3735 2400 2048.6858 2399.6193 2400 2017.4478 + 2399.1831 2400 2057.4097 2599.4289 2400 2026.1716 2598.9927 + 2400 2066.1336 2000 2600 2000 1999.5638 2600 + 2039.9619 2199.8096 2600 2008.7239 2199.3735 2600 2048.6858 + 2399.6193 2600 2017.4478 2399.1831 2600 2057.4097 2599.4289 + 2600 2026.1716 2598.9927 2600 2066.1336 2000 2800 + 2000 1999.5638 2800 2039.9619 2199.8096 2800 2008.7239 + 2199.3735 2800 2048.6858 2399.6193 2800 2017.4478 2399.1831 + 2800 2057.4097 2599.4289 2800 2026.1716 2598.9927 2800 + 2066.1336 2000 3000 2000 1999.5638 3000 2039.9619 + 2199.8096 3000 2008.7239 2199.3735 3000 2048.6858 2399.6193 + 3000 2017.4478 2399.1831 3000 2057.4097 2599.4289 3000 + 2026.1716 2598.9927 3000 2066.1336 / +ZCORN + 2000 2008.7239 2008.7239 2017.4478 2017.4478 2026.1716 2000 + 2008.7239 2008.7239 2017.4478 2017.4478 2026.1716 2000 2008.7239 + 2008.7239 2017.4478 2017.4478 2026.1716 2000 2008.7239 2008.7239 + 2017.4478 2017.4478 2026.1716 2000 2008.7239 2008.7239 2017.4478 + 2017.4478 2026.1716 2000 2008.7239 2008.7239 2017.4478 2017.4478 + 2026.1716 2000 2008.7239 2008.7239 2017.4478 2017.4478 2026.1716 + 2000 2008.7239 2008.7239 2017.4478 2017.4478 2026.1716 2000 + 2008.7239 2008.7239 2017.4478 2017.4478 2026.1716 2000 2008.7239 + 2008.7239 2017.4478 2017.4478 2026.1716 2009.9905 2018.7144 2018.7144 + 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 + 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 + 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 + 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 + 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 + 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 + 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 + 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 + 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 + 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 + 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 + 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 + 2027.4382 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 + 2027.4382 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 + 2036.1621 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 + 2009.9905 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2009.9905 + 2018.7144 2018.7144 2027.4382 2027.4382 2036.1621 2019.981 2028.7048 + 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 + 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 + 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 + 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 + 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 + 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 + 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 + 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 + 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 + 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 + 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 + 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 + 2028.7048 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 + 2037.4287 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 + 2037.4287 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 + 2046.1526 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 + 2019.981 2028.7048 2028.7048 2037.4287 2037.4287 2046.1526 2029.9714 + 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 + 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 + 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 + 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 + 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 + 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 + 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 + 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 + 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 + 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 + 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 + 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 + 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 + 2038.6953 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 + 2047.4192 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 + 2047.4192 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 + 2056.1431 2029.9714 2038.6953 2038.6953 2047.4192 2047.4192 2056.1431 + 2039.9619 2048.6858 2048.6858 2057.4097 2057.4097 2066.1336 2039.9619 + 2048.6858 2048.6858 2057.4097 2057.4097 2066.1336 2039.9619 2048.6858 + 2048.6858 2057.4097 2057.4097 2066.1336 2039.9619 2048.6858 2048.6858 + 2057.4097 2057.4097 2066.1336 2039.9619 2048.6858 2048.6858 2057.4097 + 2057.4097 2066.1336 2039.9619 2048.6858 2048.6858 2057.4097 2057.4097 + 2066.1336 2039.9619 2048.6858 2048.6858 2057.4097 2057.4097 2066.1336 + 2039.9619 2048.6858 2048.6858 2057.4097 2057.4097 2066.1336 2039.9619 + 2048.6858 2048.6858 2057.4097 2057.4097 2066.1336 2039.9619 2048.6858 + 2048.6858 2057.4097 2057.4097 2066.1336 / +PORO + 0.25 0.25 0.25 0.25 0.25 0.25 0.25 + 0.25 0.25 0.25 0.25 0.25 0.25 0.25 + 0.25 0.2 0.2 0.2 0.2 0.2 0.2 + 0.2 0.2 0.2 0.2 0.2 0.2 0.2 + 0.2 0.2 0.23 0.23 0.23 0.23 0.23 + 0.23 0.23 0.23 0.23 0.23 0.23 0.23 + 0.23 0.23 0.23 0.18 0.18 0.18 0.18 + 0.18 0.18 0.18 0.18 0.18 0.18 0.18 + 0.18 0.18 0.18 0.18 / +PERMX + 500 500 500 500 500 500 500 + 500 500 500 500 500 500 500 + 500 100 100 100 100 100 100 + 100 100 100 100 100 100 100 + 100 100 1000 1000 1000 1000 1000 + 1000 1000 1000 1000 1000 1000 1000 + 1000 1000 1000 250 250 250 250 + 250 250 250 250 250 250 250 + 250 250 250 250 / +COPY + 'PERMX' 'PERMY' / + 'PERMX' 'PERMZ' / +/ +MULTIPLY + 'PERMZ' 0.1 / +/ +MULTZ + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 0 0 0 0 0 0 + 0 0 0 0 0 0 0 + 0 0 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 1 1 / +EDIT +PROPS +SGOF + 0 0 1 0 0.0183 0.001480314 0.8127534 + 0 0.0366 0.004696335 0.675857 0 0.0549 0.009371694 + 0.5622753 0 0.0732 0.01546379 0.4663578 0 0.0915 + 0.02298664 0.385133 0 0.1098 0.03197913 0.3164995 0 + 0.1281 0.04249268 0.2587408 0 0.1464 0.05458466 0.2103665 + 0 0.1647 0.06831379 0.1700565 0 0.183 0.08373629 + 0.1366388 0 0.2013 0.1009022 0.1090792 0 0.2196 + 0.1198516 0.08647139 0 0.2379 0.1406109 0.06802822 0 + 0.2562 0.1631885 0.05307051 0 0.2745 0.1875705 0.04101619 + 0 0.2928 0.2137163 0.03136912 0 0.3111 0.2415547 + 0.02370834 0 0.3294 0.2709792 0.01767817 0 0.3477 + 0.3018447 0.01297907 0 0.366 0.3339653 0.009359652 0 + 0.3843 0.3671116 0.006609586 0 0.4026 0.401011 0.00455345 + 0 0.4209 0.4353486 0.003045475 0 0.4392 0.4697695 + 0.001965044 0 0.4575 0.5038828 0.001212868 0 0.4758 + 0.5372664 0.0007077659 0 0.4941 0.5694721 0.000383946 0 + 0.5124 0.6000285 0.0001887263 0 0.5307 0.6284408 8.062741e-05 + 0 0.549 0.6541796 2.778023e-05 0 0.5673 0.676644 + 6.602397e-06 0 0.5856 0.6950468 7.048731e-07 0 0.61 + 0.71 0 0 0.6275 0.7825 0 0 + 0.645 0.855 0 0 0.6625 0.9275 0 + 0 0.68 1 0 0 / +SWOF + 0.32 0 1 0 0.3365 3.00925e-08 0.9804566 + 0 0.353 7.541952e-07 0.9391194 0 0.3695 5.01876e-06 + 0.8832853 0 0.386 1.941502e-05 0.8178788 0 0.4025 + 5.581854e-05 0.7471578 0 0.419 0.0001330574 0.674704 0 + 0.4355 0.0002787865 0.60333 0 0.452 0.0005316304 0.535068 + 0 0.4685 0.0009436502 0.4712431 0 0.485 0.001583182 + 0.412597 0 0.5015 0.002538082 0.3594268 0 0.518 + 0.00391938 0.3117147 0 0.5345 0.005865308 0.2692366 0 + 0.551 0.008545575 0.2316458 0 0.5675 0.01216566 0.1985336 + 0 0.584 0.01697073 0.169471 0 0.6005 0.0232485 + 0.1440352 0 0.617 0.03133019 0.1218258 0 0.6335 + 0.04158825 0.1024735 0 0.65 0.05442925 0.08564409 0 + 0.6665 0.07028023 0.0710386 0 0.683 0.08956673 0.05839253 + 0 0.6995 0.1126816 0.0474734 0 0.716 0.1399451 + 0.03807806 0 0.7325 0.1715593 0.03002991 0 0.749 + 0.2075632 0.02317622 0 0.7655 0.2478002 0.01738581 0 + 0.782 0.2919105 0.01254709 0 0.7985 0.3393688 0.008566921 + 0 0.815 0.3895919 0.005370427 0 0.8315 0.4421811 + 0.002903191 0 0.848 0.4975608 0.001139647 0 0.87 + 0.59168 0 0 0.8885714 0.6500114 0 0 + 0.9071429 0.7083429 0 0 0.9257143 0.7666743 0 + 0 0.9442857 0.8250057 0 0 0.9628571 0.8833371 + 0 0 0.9814286 0.9416686 0 0 1 + 1 0 0 / +PVDG + 20 0.061895 0.01299 40 0.030252 0.01383 60 + 0.019844 0.0145 80 0.014686 0.0152 100 0.011627 + 0.01596 120 0.009619 0.01682 140 0.008213 0.0178 + 160 0.007184 0.0189 197.66 0.00582 0.0216 231.13 + 0.005042 0.02477 261.31 0.004561 0.02844 288.87 0.004255 + 0.03272 314.34 0.004062 0.03783 338.2 0.003953 0.0441 + 360.83 0.003947 0.0521 382.58 0.003915 0.06273 403.6 + 0.003912 0.07723 423.77 0.003907 0.09631 / +PVTO + 19.6 20 1.12324 0.96519 55 1.11698 1.03237 + 90 1.11127 1.10051 125 1.10602 1.16942 160 + 1.10119 1.2389 195 1.09672 1.30876 230 1.09256 + 1.37884 265 1.08868 1.44899 300 1.08504 1.51908 + 335 1.08164 1.58903 370 1.07843 1.65876 / + 31.5 40 1.15981 0.85738 75 1.15288 0.91402 + 110 1.14657 0.97137 145 1.14079 1.02927 180 + 1.13546 1.08759 215 1.13053 1.14617 250 1.12595 + 1.20488 285 1.12168 1.2636 320 1.11768 1.32224 + 355 1.11394 1.38073 390 1.11042 1.43898 / + 42.4 60 1.191 0.7868 95 1.184 0.8364 + 130 1.177 0.8866 165 1.171 0.9371 200 + 1.165 0.988 235 1.16 1.039 270 1.155 + 1.0902 305 1.15 1.1413 340 1.146 1.1922 + 375 1.142 1.2431 410 1.138 1.2936 / + 53.4 80 1.222 0.7175 115 1.214 0.7608 + 150 1.206 0.8045 185 1.2 0.8485 220 + 1.194 0.8928 255 1.188 0.9371 290 1.183 + 0.9815 325 1.178 1.0258 360 1.173 1.07 + 395 1.169 1.1141 430 1.165 1.1579 / + 64.6 100 1.252 0.6544 135 1.244 0.6923 + 170 1.236 0.7305 205 1.229 0.7689 240 + 1.222 0.8075 275 1.216 0.8461 310 1.211 + 0.8847 345 1.205 0.9233 380 1.2 0.9618 + 415 1.196 1 450 1.191 1.0381 / + 76.3 120 1.284 0.5978 155 1.275 0.6312 + 190 1.266 0.6648 225 1.259 0.6985 260 + 1.252 0.7323 295 1.245 0.7661 330 1.239 + 0.7999 365 1.234 0.8337 400 1.229 0.8673 + 435 1.224 0.9007 470 1.219 0.934 / + 88.5 140 1.316 0.5477 175 1.307 0.5749 + 210 1.298 0.602 245 1.29 0.629 280 + 1.282 0.6559 315 1.276 0.6827 350 1.269 + 0.7095 385 1.263 0.7362 420 1.258 0.7629 + 455 1.253 0.7895 490 1.248 0.8161 / + 101.3 160 1.35 0.502 195 1.34 0.5227 + 230 1.331 0.5432 265 1.322 0.5635 300 + 1.314 0.5835 335 1.307 0.6034 370 1.3 + 0.6231 405 1.294 0.6426 440 1.288 0.662 + 475 1.283 0.6813 / + 114.7 180 1.385 0.4636 215 1.375 0.482 + 250 1.365 0.5003 285 1.356 0.5183 320 + 1.347 0.5362 355 1.34 0.5538 390 1.333 + 0.5712 425 1.326 0.5885 460 1.32 0.6055 + 495 1.314 0.6222 / + 128.9 200 1.422 0.429 235 1.411 0.4455 + 270 1.401 0.4618 305 1.391 0.4779 340 + 1.382 0.4938 375 1.374 0.5096 410 1.367 + 0.5252 445 1.36 0.5406 480 1.353 0.5558 / + 143.8 220 1.461 0.3977 255 1.449 0.4125 + 290 1.438 0.4271 325 1.428 0.4415 360 + 1.419 0.4558 395 1.41 0.4699 430 1.402 + 0.4839 465 1.395 0.4977 / + 159.5 240 1.502 0.3692 275 1.489 0.3825 + 310 1.478 0.3956 345 1.467 0.4086 380 + 1.458 0.4214 415 1.449 0.4341 450 1.44 + 0.4466 485 1.432 0.459 / + 184 268.79 1.565 0.3324 303.79 1.551 0.3438 + 338.79 1.539 0.3551 373.79 1.528 0.3663 408.79 + 1.517 0.3774 443.79 1.508 0.3883 478.79 1.499 + 0.3991 / + 226.3 306.18 1.679 0.2855 341.18 1.664 0.2949 + 376.18 1.65 0.3041 411.18 1.637 0.3132 446.18 + 1.625 0.3222 481.18 1.614 0.3311 / + 268.6 339.93 1.792 0.2517 374.93 1.775 0.2597 + 409.93 1.76 0.2675 444.93 1.746 0.2751 479.93 + 1.732 0.2827 / + 310.9 371.44 1.903 0.2265 406.44 1.885 0.2333 + 441.44 1.868 0.2401 476.44 1.853 0.2468 / + 353.3 401.66 2.013 0.2071 436.66 1.993 0.2132 + 471.66 1.975 0.2192 / +/ +PVTW + 344.83 1.0292 4.002e-05 0.36 0 / +ROCK + 383 4.12e-05 / +DENSITY + 842.3 1001.1 0.9 / +REGIONS +EQLNUM + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 1 1 1 1 1 + 1 1 2 2 2 2 2 + 2 2 2 2 2 2 2 + 2 2 2 2 2 2 2 + 2 2 2 2 2 2 2 + 2 2 2 2 / +SOLUTION +RESTART + 'UDQ_ACTIONX' 7 / +RPTRST + 'BASIC=2' 'PBPD' / +SUMMARY +FOPR +FOPRH +FGPR +FGPRH +FWPR +FWPRH +FWIR +FWIP +FOIP +FGIP +FWCT +FWCTH +FGOR +FGORH +FPR +RPR + / +ROIP + / +ROIPL + / +ROIPG + / +RGIP + / +RGIPL + / +RGIPG + / +RGPR + / +RGPT + / +GWIR + / +GVIR + / +GOPR + / +GWPR + / +GLPR + / +GLPR + / +GVPR + / +WOPR + / +WOPRH + / +WGPR + / +WGPRH + / +WWPR + / +WWPRH + / +WOPT + / +WWPT + / +WGPT + / +WOPTH + / +WWPTH + / +WGPTH + / +WWCT + / +WWCTH + / +WGOR + / +WGORH + / +WWIR + / +WWIRH + / +WGIR + / +WGIRH + / +WWIT + / +WWITH + / +WGIT + / +WGITH + / +WBHP + / +WTHP + / +WPI + / +WVPR + / +WBP + / +WBP4 + / +WBP9 + / +WMCTL + / +WLPR + / +FMWIN +FMWPR +GMWPR + 'UPPER' 'LOWER' / +GMWIN + 'UPPER' 'LOWER' / +WUPR1 + 'OP*' / +WUPR3 + 'OP*' / +SCHEDULE +SKIPREST +GRUPTREE + 'UPPER' 'TEST' / + 'LOWER' 'TEST' / +/ +WELSPECS + 'OPU01' 'UPPER' 1 2 2002 'OIL' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / + 'OPU02' 'UPPER' 1 4 2002 'OIL' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / + 'OPL01' 'LOWER' 1 2 2025 'OIL' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / + 'OPL02' 'LOWER' 1 4 2025 'OIL' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / +/ +WELSPECS + 'WIU01' 'UPPER' 3 3 2030 'WATER' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / + 'WIL01' 'LOWER' 3 3 2050 'WATER' 0 + 'STD' 'SHUT' 'YES' 0 'SEG' / +/ +COMPDAT + 'OPU01' 1 2 1 1 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / + 'OPU02' 1 4 1 1 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / + 'OPL01' 1 2 3 3 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / + 'OPL02' 1 4 3 3 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / + 'WIU01' 3 3 2 2 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / + 'WIL01' 3 3 4 4 'OPEN' 0 + 1* 0.241 1* 2.5 0 'Z' / +/ +WCONPROD + 'OPU*' 'SHUT' 'GRUP' 1500 2* 2500 1* + 60 / + 'OPL*' 'SHUT' 'GRUP' 1500 2* 2500 1* + 60 / +/ +WCONINJE + 'WIU*' 'WATER' 'SHUT' 'GRUP' 10500 1* 500 / + 'WIL*' 'WATER' 'SHUT' 'GRUP' 10500 1* 500 / +/ +UDQ + DEFINE 'WUPR1' 1/(WWCT 'OP*' ) / + DEFINE 'WUPR3' SORTA(WUPR1) / +/ +GCONPROD + 'TEST' 'LRAT' 6000 2* 6000 'RATE' 'NO' / + 'LOWER' 'FLD' 6000 2* 6000 'RATE' 'YES' + 1* 'FORM' / + 'UPPER' 'FLD' 3000 2* 6000 'RATE' 'YES' + 1* 'FORM' / +/ +GCONINJE + 'LOWER' 'WATER' 'VREP' 3* 1.2 / + 'UPPER' 'WATER' 'VREP' 3* 2 / +/ +GUIDERAT + 0 'OIL' 1 0.5 1 1 0 + 0 'YES' 0.5 / +ACTIONX + 'ACT01' 10 / + FMWPR >= 4 AND / + WUPR3 'OP*' = 1 / +/ +WELOPEN + '?' 'SHUT' 0 0 0 / +/ +ENDACTIO +DATES + 1 'SEP' 2018 / +/ +WELOPEN + 'OPL01' 'OPEN' / +/ +DATES + 1 'OCT' 2018 / +/ +WELOPEN + 'WIL01' 'OPEN' / +/ +DATES + 1 'NOV' 2018 / +/ +WELOPEN + 'OPL02' 'OPEN' / +/ +DATES + 1 'DEC' 2018 / +/ +WELOPEN + 'OPU01' 'OPEN' / +/ +DATES + 1 'MAY' 2019 / +/ +WELOPEN + 'OPU02' 'OPEN' / +/ +DATES + 1 'JUN' 2019 / +/ +WELOPEN + 'WIU01' 'OPEN' / +/ +DATES + 1 'JAN' 2021 / +/ +DATES + 1 'MAR' 2021 / +/ +DATES + 1 'MAY' 2021 / +/ +DATES + 1 'JUL' 2021 / +/ diff --git a/tests/parser/ACTIONX.cpp b/tests/parser/ACTIONX.cpp index d3a327b2d..2068f9df2 100644 --- a/tests/parser/ACTIONX.cpp +++ b/tests/parser/ACTIONX.cpp @@ -702,7 +702,7 @@ BOOST_AUTO_TEST_CASE(Conditions) { BOOST_CHECK_THROW(Action::Condition cond({"WWCT", "OPX", ">"}, location), std::invalid_argument); Action::Condition cond({"WWCT", "OPX", ">", "0.75", "AND"}, location); - BOOST_CHECK(cond.cmp == Action::Condition::Comparator::GREATER); + BOOST_CHECK(cond.cmp == Action::Comparator::GREATER); BOOST_CHECK(cond.cmp_string == ">" ); BOOST_CHECK_EQUAL(cond.lhs.quantity, "WWCT"); BOOST_CHECK_EQUAL(cond.lhs.args.size(), 1U); @@ -712,10 +712,10 @@ BOOST_AUTO_TEST_CASE(Conditions) { BOOST_CHECK_EQUAL(cond.rhs.quantity, "0.75"); BOOST_CHECK_EQUAL(cond.rhs.args.size(), 0U); - BOOST_CHECK(cond.logic == Action::Condition::Logical::AND); + BOOST_CHECK(cond.logic == Action::Logical::AND); Action::Condition cond2({"WWCT", "OPX", "<=", "WSOPR", "OPX", "235"}, location); - BOOST_CHECK(cond2.cmp == Action::Condition::Comparator::LESS_EQUAL); + BOOST_CHECK(cond2.cmp == Action::Comparator::LESS_EQUAL); BOOST_CHECK(cond2.cmp_string == "<=" ); BOOST_CHECK_EQUAL(cond2.lhs.quantity, "WWCT"); BOOST_CHECK_EQUAL(cond2.lhs.args.size(), 1U); @@ -725,7 +725,7 @@ BOOST_AUTO_TEST_CASE(Conditions) { BOOST_CHECK_EQUAL(cond2.rhs.args.size(), 2U); BOOST_CHECK_EQUAL(cond2.rhs.args[0], "OPX"); BOOST_CHECK_EQUAL(cond2.rhs.args[1], "235"); - BOOST_CHECK(cond2.logic == Action::Condition::Logical::END); + BOOST_CHECK(cond2.logic == Action::Logical::END); } @@ -808,8 +808,8 @@ TSTEP const auto& cond0 = conditions[0]; BOOST_CHECK_EQUAL(cond0.lhs.quantity, "WWCT"); - BOOST_CHECK(cond0.cmp == Action::Condition::Comparator::GREATER); - BOOST_CHECK(cond0.logic == Action::Condition::Logical::AND); + BOOST_CHECK(cond0.cmp == Action::Comparator::GREATER); + BOOST_CHECK(cond0.logic == Action::Logical::AND); BOOST_CHECK_EQUAL(cond0.lhs.args.size(), 1U); BOOST_CHECK_EQUAL(cond0.lhs.args[0], "OPX"); BOOST_CHECK_EQUAL(cond0.rhs.args.size(), 0U); @@ -817,8 +817,8 @@ TSTEP const auto& cond1 = conditions[1]; BOOST_CHECK_EQUAL(cond1.lhs.quantity, "FPR"); - BOOST_CHECK(cond1.cmp == Action::Condition::Comparator::LESS); - BOOST_CHECK(cond1.logic == Action::Condition::Logical::END); + BOOST_CHECK(cond1.cmp == Action::Comparator::LESS); + BOOST_CHECK(cond1.logic == Action::Logical::END); /*****************************************************************/ @@ -829,16 +829,16 @@ TSTEP const auto& condB = actB.conditions(); BOOST_CHECK_EQUAL(condB.size() , 1U); BOOST_CHECK_EQUAL(condB[0].lhs.quantity, "FWCT"); - BOOST_CHECK(condB[0].cmp == Action::Condition::Comparator::LESS_EQUAL); - BOOST_CHECK(condB[0].logic == Action::Condition::Logical::END); + BOOST_CHECK(condB[0].cmp == Action::Comparator::LESS_EQUAL); + BOOST_CHECK(condB[0].logic == Action::Logical::END); BOOST_CHECK_EQUAL(condB[0].cmp_string, "<="); const auto& actA = actions2["A"]; const auto& condA = actA.conditions(); BOOST_CHECK_EQUAL(condA.size() , 1U); BOOST_CHECK_EQUAL(condA[0].lhs.quantity, "WOPR"); - BOOST_CHECK(condA[0].cmp == Action::Condition::Comparator::EQUAL); - BOOST_CHECK(condA[0].logic == Action::Condition::Logical::END); + BOOST_CHECK(condA[0].cmp == Action::Comparator::EQUAL); + BOOST_CHECK(condA[0].logic == Action::Logical::END); BOOST_CHECK_EQUAL(condA[0].cmp_string , "="); std::size_t index = 0; diff --git a/tests/parser/ScheduleRestartTests.cpp b/tests/parser/ScheduleRestartTests.cpp index 4f422cb8b..aa5950b0d 100644 --- a/tests/parser/ScheduleRestartTests.cpp +++ b/tests/parser/ScheduleRestartTests.cpp @@ -171,3 +171,11 @@ BOOST_AUTO_TEST_CASE(LoadUDQRestartSim) { } } } + +BOOST_AUTO_TEST_CASE(LoadActionRestartSim) { + const auto& [sched, restart_sched] = load_schedule_pair("UDQ_ACTIONX.DATA", "UDQ_ACTIONX_RESTART.DATA", "UDQ_ACTIONX.X0007", 7); + const auto& input_actions = sched[7].actions(); + const auto& rst_actions = restart_sched[7].actions(); + + BOOST_CHECK_EQUAL(input_actions.ecl_size(), rst_actions.ecl_size()); +} diff --git a/tests/test_AggregateActionxData.cpp b/tests/test_AggregateActionxData.cpp index fa3eef67f..95d8fe3e0 100644 --- a/tests/test_AggregateActionxData.cpp +++ b/tests/test_AggregateActionxData.cpp @@ -1,7 +1,11 @@ #define BOOST_TEST_MODULE UDQ-ACTIONX_Data #include +#include +#include +#include +#include #include #include #include @@ -25,10 +29,15 @@ #include #include #include +#include #include #include #include +#include +#include +#include +#include #include @@ -36,8 +45,10 @@ #include #include #include +#include #include #include +#include namespace { @@ -46,6 +57,24 @@ namespace { } } +bool compare_tokens(const std::vector& rst_tokens, const std::vector& deck_tokens) { + if (deck_tokens == rst_tokens) + return true; + + fmt::print("Deck tokens : "); + for (const auto& dt : deck_tokens) + fmt::print("{} ", dt); + fmt::print("\n"); + + fmt::print("Rst tokens : "); + for (const auto& rt : rst_tokens) + fmt::print("{} ", rt); + fmt::print("\n"); + + return false; +} + + Opm::SummaryState sum_state_TEST1() { auto state = Opm::SummaryState{Opm::TimeService::now()}; @@ -67,6 +96,8 @@ Opm::SummaryState sum_state_TEST1() state.update_group_var("LOWER", "GGPR", 461.); state.update_group_var("TEST", "GGPR", 821.); + state.update_group_var("UPPER", "GMCTW", 0); + state.update_group_var("LOWER", "GMCTW", 0); state.update_group_var("TEST", "GMWPR", 4); @@ -94,7 +125,7 @@ struct SimulationCase Opm::EclipseGrid grid; std::shared_ptr python; Opm::Schedule sched; - + Opm::Parser parser; }; BOOST_AUTO_TEST_SUITE(Aggregate_Actionx) @@ -102,21 +133,24 @@ BOOST_AUTO_TEST_SUITE(Aggregate_Actionx) // test constructed UDQ-Actionx restart data -BOOST_AUTO_TEST_CASE (Declared_Actionx_data) +BOOST_AUTO_TEST_CASE(Declared_Actionx_data) { - const auto simCase = SimulationCase{first_sim("UDQ_ACTIONX_TEST1.DATA")}; + const auto simCase = SimulationCase {first_sim("UDQ_ACTIONX_TEST1.DATA")}; Opm::EclipseState es = simCase.es; - Opm::Runspec rspec = es.runspec(); + Opm::Runspec rspec = es.runspec(); Opm::SummaryState st = sum_state_TEST1(); Opm::UDQState udq_state(1); Opm::Action::State action_state; Opm::Schedule sched = simCase.sched; Opm::EclipseGrid grid = simCase.grid; const auto& start_time = sched.getStartTime(); + const auto& ioConfig = es.getIOConfig(); + // const auto& restart = es.cfg().restart(); + // Report Step 3: 2008-08-22 --> 2018-10-01 - const auto rptStep = std::size_t{3}; + const auto rptStep = std::size_t {3}; std::string outputDir = "./"; std::string baseName = "UDQ_ACTIONX_TEST1"; Opm::Action::ActionX actx_14 = Opm::Action::ActionX("ACT14", 10, 0.543, start_time); @@ -124,780 +158,952 @@ BOOST_AUTO_TEST_CASE (Declared_Actionx_data) action_state.add_run(actx_14, start_time + 1.E09, result); double secs_elapsed = start_time + 2.E09; - const auto ih = Opm::RestartIO::Helpers:: - createInteHead(es, grid, sched, secs_elapsed, - rptStep, rptStep+1, rptStep); - //set dummy value for next_step_size - const double next_step_size= 0.1; - const auto dh = Opm::RestartIO::Helpers::createDoubHead(es, sched, rptStep, - secs_elapsed, next_step_size); - - const auto udqDims = Opm::RestartIO::Helpers::createUdqDims(sched, rptStep, ih); - auto udqData = Opm::RestartIO::Helpers::AggregateUDQData(udqDims); - udqData.captureDeclaredUDQData(sched, rptStep, udq_state, ih); - - const auto actDims = Opm::RestartIO::Helpers::createActionRSTDims(sched, rptStep); - Opm::RestartIO::Helpers::AggregateActionxData actionxData{sched, action_state, st, rptStep}; - { - /* - Check of InteHEAD and DoubHEAD data for UDQ variables - - INTEHEAD - - Intehead[156] - The number of ACTIONS - Intehead[157] - The max number of lines of schedule data including ENDACTIO keyword for any ACTION - - ---------------------------------------------------------------------------------------------------------------------] - - */ - const auto rptStep_1 = std::size_t{0}; - const auto ih_1 = Opm::RestartIO::Helpers::createInteHead(es, grid, sched, - secs_elapsed, rptStep, rptStep_1 + 1, rptStep_1); - - BOOST_CHECK_EQUAL(ih_1[156] , 2); - BOOST_CHECK_EQUAL(ih_1[157] , 7); - - - const auto rptStep_2 = std::size_t{1}; - const auto ih_2 = Opm::RestartIO::Helpers::createInteHead(es, grid, sched, - secs_elapsed, rptStep, rptStep_2 + 1, rptStep_2); - BOOST_CHECK_EQUAL(ih_2[156] , 14); - BOOST_CHECK_EQUAL(ih_2[157] , 10); - - const auto rptStep_3 = std::size_t{2}; - const auto ih_3 = Opm::RestartIO::Helpers::createInteHead(es, grid, sched, - secs_elapsed, rptStep, rptStep_3 + 1, rptStep_3); - - BOOST_CHECK_EQUAL(ih_3[156] , 14); - BOOST_CHECK_EQUAL(ih_3[157] , 10); - - } { - /* - IACT - --length is equal to 9*the number of ACTIONX keywords - //item [0]: is unknown, (=0) - //item [1]: The number of lines of schedule data including ENDACTIO - //item [2]: is the number of times an action has been triggered - //item [3]: is unknown, (=7) - //item [4]: is unknown, (=0) - //item [5]: The number of times the action is triggered - //item [6]: is unknown, (=0) - //item [7]: is unknown, (=0) - //item [8]: The number of times the action is triggered - */ + Opm::EclIO::OutputStream::Restart rstFile {Opm::EclIO::OutputStream::ResultSet {outputDir, baseName}, + rptStep, + Opm::EclIO::OutputStream::Formatted {ioConfig.getFMTOUT()}, + Opm::EclIO::OutputStream::Unified {ioConfig.getUNIFOUT()}}; + + std::vector ih + = Opm::RestartIO::Helpers::createInteHead(es, grid, sched, secs_elapsed, rptStep, rptStep + 1, rptStep); + + // set dummy value for next_step_size + const double next_step_size = 0.1; + const auto dh = Opm::RestartIO::Helpers::createDoubHead(es, sched, rptStep, secs_elapsed, next_step_size); + + const auto& lh = Opm::RestartIO::Helpers::createLogiHead(es); + + // Not really interested in the UDQ data + ih[Opm::RestartIO::Helpers::VectorItems::intehead::NO_WELL_UDQS] = 0; + ih[Opm::RestartIO::Helpers::VectorItems::intehead::NO_GROUP_UDQS] = 0; + ih[Opm::RestartIO::Helpers::VectorItems::intehead::NO_FIELD_UDQS] = 0; + + rstFile.write("INTEHEAD", ih); + rstFile.write("DOUBHEAD", dh); + rstFile.write("LOGIHEAD", lh); + { + auto group_aggregator = Opm::RestartIO::Helpers::AggregateGroupData(ih); + group_aggregator.captureDeclaredGroupData(sched, es.getUnits(), rptStep, st, ih); + rstFile.write("IGRP", group_aggregator.getIGroup()); + rstFile.write("SGRP", group_aggregator.getSGroup()); + rstFile.write("XGRP", group_aggregator.getXGroup()); + rstFile.write("ZGRP", group_aggregator.getZGroup()); + } + { + auto well_aggregator = Opm::RestartIO::Helpers::AggregateWellData(ih); + well_aggregator.captureDeclaredWellData(sched, es.getUnits(), rptStep, Opm::Action::State{}, st, ih); + rstFile.write("IWEL", well_aggregator.getIWell()); + rstFile.write("SWEL", well_aggregator.getSWell()); + rstFile.write("XWEL", well_aggregator.getXWell()); + rstFile.write("ZWEL", well_aggregator.getZWell()); + } + { + auto conn_aggregator = Opm::RestartIO::Helpers::AggregateConnectionData(ih); + auto xw = Opm::data::Wells{}; + conn_aggregator.captureDeclaredConnData(sched, grid, es.getUnits(), xw, st, rptStep); + rstFile.write("ICON", conn_aggregator.getIConn()); + rstFile.write("SCON", conn_aggregator.getSConn()); + rstFile.write("XCON", conn_aggregator.getXConn()); + } + + //const auto udqDims = Opm::RestartIO::Helpers::createUdqDims(sched, rptStep, ih); + //auto udqData = Opm::RestartIO::Helpers::AggregateUDQData(udqDims); + //udqData.captureDeclaredUDQData(sched, rptStep, udq_state, ih); + + const auto actDims = Opm::RestartIO::Helpers::createActionRSTDims(sched, rptStep); + Opm::RestartIO::Helpers::AggregateActionxData actionxData{sched, action_state, st, rptStep}; + + rstFile.write("IACT", actionxData.getIACT()); + rstFile.write("SACT", actionxData.getSACT()); + rstFile.write("ZACT", actionxData.getZACT()); + rstFile.write("ZLACT", actionxData.getZLACT()); + rstFile.write("ZACN", actionxData.getZACN()); + rstFile.write("IACN", actionxData.getIACN()); + rstFile.write("SACN", actionxData.getSACN()); + { + /* + Check of InteHEAD and DoubHEAD data for UDQ variables + + INTEHEAD + + Intehead[156] - The number of ACTIONS + Intehead[157] - The max number of lines of schedule data including ENDACTIO keyword for any ACTION + + ---------------------------------------------------------------------------------------------------------------------] + + */ + const auto rptStep_1 = std::size_t {0}; + const auto ih_1 = Opm::RestartIO::Helpers::createInteHead( + es, grid, sched, secs_elapsed, rptStep, rptStep_1 + 1, rptStep_1); + + BOOST_CHECK_EQUAL(ih_1[156], 2); + BOOST_CHECK_EQUAL(ih_1[157], 7); - const auto& iAct = actionxData.getIACT(); - auto start = 0*actDims[1]; - BOOST_CHECK_EQUAL(iAct[start + 0] , 0); - BOOST_CHECK_EQUAL(iAct[start + 1] , 10); - BOOST_CHECK_EQUAL(iAct[start + 2] , 1); - BOOST_CHECK_EQUAL(iAct[start + 3] , 7); - BOOST_CHECK_EQUAL(iAct[start + 4] , 0); - BOOST_CHECK_EQUAL(iAct[start + 5] , 10); - BOOST_CHECK_EQUAL(iAct[start + 6] , 0); - BOOST_CHECK_EQUAL(iAct[start + 7] , 0); - BOOST_CHECK_EQUAL(iAct[start + 8] , 3); + const auto rptStep_2 = std::size_t {1}; + const auto ih_2 = Opm::RestartIO::Helpers::createInteHead( + es, grid, sched, secs_elapsed, rptStep, rptStep_2 + 1, rptStep_2); + BOOST_CHECK_EQUAL(ih_2[156], 14); + BOOST_CHECK_EQUAL(ih_2[157], 10); + const auto rptStep_3 = std::size_t {2}; + const auto ih_3 = Opm::RestartIO::Helpers::createInteHead( + es, grid, sched, secs_elapsed, rptStep, rptStep_3 + 1, rptStep_3); - start = 1*actDims[1]; - BOOST_CHECK_EQUAL(iAct[start + 0] , 0); - BOOST_CHECK_EQUAL(iAct[start + 1] , 7); - BOOST_CHECK_EQUAL(iAct[start + 2] , 1); - BOOST_CHECK_EQUAL(iAct[start + 3] , 7); - BOOST_CHECK_EQUAL(iAct[start + 4] , 0); - BOOST_CHECK_EQUAL(iAct[start + 5] , 11); - BOOST_CHECK_EQUAL(iAct[start + 6] , 0); - BOOST_CHECK_EQUAL(iAct[start + 7] , 0); - BOOST_CHECK_EQUAL(iAct[start + 8] , 3); - - start = 2*actDims[1]; - BOOST_CHECK_EQUAL(iAct[start + 0] , 0); - BOOST_CHECK_EQUAL(iAct[start + 1] , 4); - BOOST_CHECK_EQUAL(iAct[start + 2] , 1); - BOOST_CHECK_EQUAL(iAct[start + 3] , 7); - BOOST_CHECK_EQUAL(iAct[start + 4] , 0); - BOOST_CHECK_EQUAL(iAct[start + 5] , 13); - BOOST_CHECK_EQUAL(iAct[start + 6] , 0); - BOOST_CHECK_EQUAL(iAct[start + 7] , 0); - BOOST_CHECK_EQUAL(iAct[start + 8] , 3); - - start = 13*actDims[1]; - BOOST_CHECK_EQUAL(iAct[start + 2] , 2); - } - - { - /* - SACT - --length is equal to 9*the number of ACTIONX keywords - //item [0]: is unknown, (=0) - //item [1]: is unknown, (=0) - //item [2]: is unknown, (=0) - //item [3]: Minimum time interval between action triggers. - //item [4]: last time that the action was triggered - */ - - - const auto& sAct = actionxData.getSACT(); - - auto start = 0*actDims[2]; - BOOST_CHECK_CLOSE(sAct[start + 3], 0.543, 1.0e-5f); - start = 1*actDims[2]; - BOOST_CHECK_CLOSE(sAct[start + 3], 0.567, 1.0e-5f); - //actx_14 - start = 13*actDims[2]; - BOOST_CHECK_CLOSE(sAct[start + 4], 1.E09/86400., 1.0e-5f); - } - - { - /* - ZACT - --length 4 times 8-chars pr ACTIONX keyword - - Name of action 4 times 8 chars (up to 8 chars for name) - - */ - - const auto& zAct = actionxData.getZACT(); - - auto start = 0*actDims[3]; - BOOST_CHECK_EQUAL(zAct[start + 0].c_str() , "ACT01 "); - - start = 1*actDims[3]; - BOOST_CHECK_EQUAL(zAct[start + 0].c_str() , "ACT02 "); - - start = 2*actDims[3]; - BOOST_CHECK_EQUAL(zAct[start + 0].c_str() , "ACT03 "); - - } - - { - /* - ZLACT - -- length = ACTDIMS_item3*(max-over-action of number of lines of data pr ACTION) - - */ - - const auto& zLact = actionxData.getZLACT(); - - //First action - auto start_a = 0*actDims[4]; - auto start = start_a + 0*actDims[8]; - BOOST_CHECK_EQUAL(zLact[start + 0].c_str() , "WELOPEN "); - - start = start_a + 1*actDims[8]; - BOOST_CHECK_EQUAL(zLact[start + 0].c_str() , "'?' 'SHU"); - BOOST_CHECK_EQUAL(zLact[start + 1].c_str() , "T' 0 0 0"); - BOOST_CHECK_EQUAL(zLact[start + 2].c_str() , " / "); - - start = start_a + 2*actDims[8]; - BOOST_CHECK_EQUAL(zLact[start + 0].c_str() , "/ "); - - start = start_a + 3*actDims[8]; - BOOST_CHECK_EQUAL(zLact[start + 0].c_str() , "WELOPEN "); - - //Second action - start_a = 1*actDims[4]; - start = start_a + 0*actDims[8]; - BOOST_CHECK_EQUAL(zLact[start + 0].c_str() , "WELOPEN "); - - start = start_a + 1*actDims[8]; - BOOST_CHECK_EQUAL(zLact[start + 0].c_str() , "'?' 'SHU"); - BOOST_CHECK_EQUAL(zLact[start + 1].c_str() , "T' 0 0 0"); - BOOST_CHECK_EQUAL(zLact[start + 2].c_str() , " / "); - - start = start_a + 2*actDims[8]; - BOOST_CHECK_EQUAL(zLact[start + 0].c_str() , "/ "); - - start = start_a + 3*actDims[8]; - BOOST_CHECK_EQUAL(zLact[start + 0].c_str() , "WELOPEN "); - - start = start_a + 4*actDims[8]; - BOOST_CHECK_EQUAL(zLact[start + 0].c_str() , "'OPL01' "); - BOOST_CHECK_EQUAL(zLact[start + 1].c_str() , "'OPEN' /"); - BOOST_CHECK_EQUAL(zLact[start + 2].c_str() , " "); - - start = start_a + 5*actDims[8]; - BOOST_CHECK_EQUAL(zLact[start + 0].c_str() , "/ "); - - - start = start_a + 6*actDims[8]; - BOOST_CHECK_EQUAL(zLact[start + 0].c_str() , "ENDACTIO"); - - - } + BOOST_CHECK_EQUAL(ih_3[156], 14); + BOOST_CHECK_EQUAL(ih_3[157], 10); + } { - /* - ZACN - //(Max number of conditions pr ACTIONX) * ((max no characters pr line = 104) / (8 - characters pr string)(104/8 = 13) + /* + SACT + --length is equal to 9*the number of ACTIONX keywords + //item [0]: is unknown, (=0) + //item [1]: is unknown, (=0) + //item [2]: is unknown, (=0) + //item [3]: Minimum time interval between action triggers. + //item [4]: last time that the action was triggered + */ - */ - const auto& zAcn = actionxData.getZACN(); + const auto& sAct = actionxData.getSACT(); - //First action - auto start_a = 0*actDims[5]; - auto start = start_a + 0*13; - BOOST_CHECK_EQUAL(zAcn[start + 0].c_str() , "FMWPR "); - BOOST_CHECK_EQUAL(zAcn[start + 1].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 2].c_str() , "> "); - BOOST_CHECK_EQUAL(zAcn[start + 3].c_str() , " "); + auto start = 0*actDims[2]; + BOOST_CHECK_CLOSE(sAct[start + 3], 0.543, 1.0e-5f); + start = 1*actDims[2]; + BOOST_CHECK_CLOSE(sAct[start + 3], 0.567, 1.0e-5f); + //actx_14 + start = 13*actDims[2]; + BOOST_CHECK_CLOSE(sAct[start + 4], 1.E09/86400., 1.0e-5f); + } - start = start_a + 1*13; - BOOST_CHECK_EQUAL(zAcn[start + 0].c_str() , "WUPR3 "); - BOOST_CHECK_EQUAL(zAcn[start + 1].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 2].c_str() , "> "); - BOOST_CHECK_EQUAL(zAcn[start + 3].c_str() , "OP* "); - BOOST_CHECK_EQUAL(zAcn[start + 4].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 5].c_str() , " "); + { + /* + IACT + --length is equal to 9*the number of ACTIONX keywords + //item [0]: is unknown, (=0) + //item [1]: The number of lines of schedule data including ENDACTIO + //item [2]: is the number of times an action has been triggered + //item [3]: is unknown, (=7) + //item [4]: is unknown, (=0) + //item [5]: The number of times the action is triggered + //item [6]: is unknown, (=0) + //item [7]: is unknown, (=0) + //item [8]: The number of times the action is triggered + */ - start = start_a + 2*13; - BOOST_CHECK_EQUAL(zAcn[start + 0].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 1].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 2].c_str() , "< "); - BOOST_CHECK_EQUAL(zAcn[start + 3].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 4].c_str() , " "); + + const auto& iAct = actionxData.getIACT(); + + auto start = 0 * actDims[1]; + BOOST_CHECK_EQUAL(iAct[start + 0], 0); + BOOST_CHECK_EQUAL(iAct[start + 1], 10); + BOOST_CHECK_EQUAL(iAct[start + 2], 1); + BOOST_CHECK_EQUAL(iAct[start + 3], 7); + BOOST_CHECK_EQUAL(iAct[start + 4], 0); + BOOST_CHECK_EQUAL(iAct[start + 5], 10); + BOOST_CHECK_EQUAL(iAct[start + 6], 0); + BOOST_CHECK_EQUAL(iAct[start + 7], 0); + BOOST_CHECK_EQUAL(iAct[start + 8], 3); + + + start = 1 * actDims[1]; + BOOST_CHECK_EQUAL(iAct[start + 0], 0); + BOOST_CHECK_EQUAL(iAct[start + 1], 7); + BOOST_CHECK_EQUAL(iAct[start + 2], 1); + BOOST_CHECK_EQUAL(iAct[start + 3], 7); + BOOST_CHECK_EQUAL(iAct[start + 4], 0); + BOOST_CHECK_EQUAL(iAct[start + 5], 11); + BOOST_CHECK_EQUAL(iAct[start + 6], 0); + BOOST_CHECK_EQUAL(iAct[start + 7], 0); + BOOST_CHECK_EQUAL(iAct[start + 8], 3); + + start = 2 * actDims[1]; + BOOST_CHECK_EQUAL(iAct[start + 0], 0); + BOOST_CHECK_EQUAL(iAct[start + 1], 4); + BOOST_CHECK_EQUAL(iAct[start + 2], 1); + BOOST_CHECK_EQUAL(iAct[start + 3], 7); + BOOST_CHECK_EQUAL(iAct[start + 4], 0); + BOOST_CHECK_EQUAL(iAct[start + 5], 13); + BOOST_CHECK_EQUAL(iAct[start + 6], 0); + BOOST_CHECK_EQUAL(iAct[start + 7], 0); + BOOST_CHECK_EQUAL(iAct[start + 8], 3); + + start = 13 * actDims[1]; + BOOST_CHECK_EQUAL(iAct[start + 2], 2); + } + + { + /* + SACT + --length is equal to 9*the number of ACTIONX keywords + //item [0]: is unknown, (=0) + //item [1]: is unknown, (=0) + //item [2]: is unknown, (=0) + //item [3]: Minimum time interval between action triggers. + //item [4]: is unknown, (=0) + */ + + + const auto& sAct = actionxData.getSACT(); + + auto start = 0 * actDims[2]; + BOOST_CHECK_CLOSE(sAct[start + 3], 0.543, 1.0e-5f); + start = 1 * actDims[2]; + BOOST_CHECK_CLOSE(sAct[start + 3], 0.567, 1.0e-5f); + } + + { + /* + ZACT + --length 4 times 8-chars pr ACTIONX keyword + + Name of action 4 times 8 chars (up to 8 chars for name) + + */ + + const auto& zAct = actionxData.getZACT(); + + auto start = 0 * actDims[3]; + BOOST_CHECK_EQUAL(zAct[start + 0].c_str(), "ACT01 "); + + start = 1 * actDims[3]; + BOOST_CHECK_EQUAL(zAct[start + 0].c_str(), "ACT02 "); + + start = 2 * actDims[3]; + BOOST_CHECK_EQUAL(zAct[start + 0].c_str(), "ACT03 "); + } + + { + /* + ZLACT + -- length = ACTDIMS_item3*(max-over-action of number of lines of data pr ACTION) + + */ + + const auto& zLact = actionxData.getZLACT(); + + // First action + auto start_a = 0 * actDims[4]; + auto start = start_a + 0 * actDims[8]; + BOOST_CHECK_EQUAL(zLact[start + 0].c_str(), "WELOPEN "); + + start = start_a + 1 * actDims[8]; + BOOST_CHECK_EQUAL(zLact[start + 0].c_str(), "'?' 'SHU"); + BOOST_CHECK_EQUAL(zLact[start + 1].c_str(), "T' 0 0 0"); + BOOST_CHECK_EQUAL(zLact[start + 2].c_str(), " / "); + + start = start_a + 2 * actDims[8]; + BOOST_CHECK_EQUAL(zLact[start + 0].c_str(), "/ "); + + start = start_a + 3 * actDims[8]; + BOOST_CHECK_EQUAL(zLact[start + 0].c_str(), "WELOPEN "); + + // Second action + start_a = 1 * actDims[4]; + start = start_a + 0 * actDims[8]; + BOOST_CHECK_EQUAL(zLact[start + 0].c_str(), "WELOPEN "); + + start = start_a + 1 * actDims[8]; + BOOST_CHECK_EQUAL(zLact[start + 0].c_str(), "'?' 'SHU"); + BOOST_CHECK_EQUAL(zLact[start + 1].c_str(), "T' 0 0 0"); + BOOST_CHECK_EQUAL(zLact[start + 2].c_str(), " / "); + + start = start_a + 2 * actDims[8]; + BOOST_CHECK_EQUAL(zLact[start + 0].c_str(), "/ "); + + start = start_a + 3 * actDims[8]; + BOOST_CHECK_EQUAL(zLact[start + 0].c_str(), "WELOPEN "); + + start = start_a + 4 * actDims[8]; + BOOST_CHECK_EQUAL(zLact[start + 0].c_str(), "'OPL01' "); + BOOST_CHECK_EQUAL(zLact[start + 1].c_str(), "'OPEN' /"); + BOOST_CHECK_EQUAL(zLact[start + 2].c_str(), " "); + + start = start_a + 5 * actDims[8]; + BOOST_CHECK_EQUAL(zLact[start + 0].c_str(), "/ "); + + + start = start_a + 6 * actDims[8]; + BOOST_CHECK_EQUAL(zLact[start + 0].c_str(), "ENDACTIO"); + } + + { + /* + ZACN + //(Max number of conditions pr ACTIONX) * ((max no characters pr line = 104) / (8 - characters pr + string)(104/8 = 13) + + */ + + const auto& zAcn = actionxData.getZACN(); + + // First action + auto start_a = 0 * actDims[5]; + auto start = start_a + 0 * 13; + BOOST_CHECK_EQUAL(zAcn[start + 0].c_str(), "FMWPR "); + BOOST_CHECK_EQUAL(zAcn[start + 1].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 2].c_str(), "> "); + BOOST_CHECK_EQUAL(zAcn[start + 3].c_str(), " "); + + start = start_a + 1 * 13; + BOOST_CHECK_EQUAL(zAcn[start + 0].c_str(), "WUPR3 "); + BOOST_CHECK_EQUAL(zAcn[start + 1].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 2].c_str(), "> "); + BOOST_CHECK_EQUAL(zAcn[start + 3].c_str(), "OP* "); + BOOST_CHECK_EQUAL(zAcn[start + 4].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 5].c_str(), " "); + + start = start_a + 2 * 13; + BOOST_CHECK_EQUAL(zAcn[start + 0].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 1].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 2].c_str(), "< "); + BOOST_CHECK_EQUAL(zAcn[start + 3].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 4].c_str(), " "); - //Second action - start_a = 1*actDims[5]; - start = start_a + 0*13; - BOOST_CHECK_EQUAL(zAcn[start + 0].c_str() , "FMWPR "); - BOOST_CHECK_EQUAL(zAcn[start + 1].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 2].c_str() , "> "); - BOOST_CHECK_EQUAL(zAcn[start + 3].c_str() , " "); + // Second action + start_a = 1 * actDims[5]; + start = start_a + 0 * 13; + BOOST_CHECK_EQUAL(zAcn[start + 0].c_str(), "FMWPR "); + BOOST_CHECK_EQUAL(zAcn[start + 1].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 2].c_str(), "> "); + BOOST_CHECK_EQUAL(zAcn[start + 3].c_str(), " "); - start = start_a + 1*13; - BOOST_CHECK_EQUAL(zAcn[start + 0].c_str() , "WGPR "); - BOOST_CHECK_EQUAL(zAcn[start + 1].c_str() , "GGPR "); - BOOST_CHECK_EQUAL(zAcn[start + 2].c_str() , "> "); - BOOST_CHECK_EQUAL(zAcn[start + 3].c_str() , "OPL02 "); - BOOST_CHECK_EQUAL(zAcn[start + 4].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 5].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 6].c_str() , "LOWER "); + start = start_a + 1 * 13; + BOOST_CHECK_EQUAL(zAcn[start + 0].c_str(), "WGPR "); + BOOST_CHECK_EQUAL(zAcn[start + 1].c_str(), "GGPR "); + BOOST_CHECK_EQUAL(zAcn[start + 2].c_str(), "> "); + BOOST_CHECK_EQUAL(zAcn[start + 3].c_str(), "OPL02 "); + BOOST_CHECK_EQUAL(zAcn[start + 4].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 5].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 6].c_str(), "LOWER "); - start = start_a + 2*13; - BOOST_CHECK_EQUAL(zAcn[start + 0].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 1].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 2].c_str() , "> "); - BOOST_CHECK_EQUAL(zAcn[start + 3].c_str() , " "); - BOOST_CHECK_EQUAL(zAcn[start + 4].c_str() , " "); + start = start_a + 2 * 13; + BOOST_CHECK_EQUAL(zAcn[start + 0].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 1].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 2].c_str(), "> "); + BOOST_CHECK_EQUAL(zAcn[start + 3].c_str(), " "); + BOOST_CHECK_EQUAL(zAcn[start + 4].c_str(), " "); + } + + { + /* + IACN + 26*Max number of conditions pr ACTIONX + + */ + + + const auto& iAcn = actionxData.getIACN(); + + auto start_a = 0 * actDims[6]; + auto start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 0], 0); + BOOST_CHECK_EQUAL(iAcn[start + 1], 0); + BOOST_CHECK_EQUAL(iAcn[start + 2], 0); + BOOST_CHECK_EQUAL(iAcn[start + 3], 0); + BOOST_CHECK_EQUAL(iAcn[start + 4], 0); + BOOST_CHECK_EQUAL(iAcn[start + 5], 0); + BOOST_CHECK_EQUAL(iAcn[start + 6], 0); + BOOST_CHECK_EQUAL(iAcn[start + 7], 0); + BOOST_CHECK_EQUAL(iAcn[start + 8], 0); + BOOST_CHECK_EQUAL(iAcn[start + 9], 0); + BOOST_CHECK_EQUAL(iAcn[start + 10], 1); + BOOST_CHECK_EQUAL(iAcn[start + 11], 8); + BOOST_CHECK_EQUAL(iAcn[start + 12], 0); + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 14], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 16], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 0], 0); + BOOST_CHECK_EQUAL(iAcn[start + 1], 0); + BOOST_CHECK_EQUAL(iAcn[start + 2], 0); + BOOST_CHECK_EQUAL(iAcn[start + 3], 0); + BOOST_CHECK_EQUAL(iAcn[start + 4], 0); + BOOST_CHECK_EQUAL(iAcn[start + 5], 0); + BOOST_CHECK_EQUAL(iAcn[start + 6], 0); + BOOST_CHECK_EQUAL(iAcn[start + 7], 0); + BOOST_CHECK_EQUAL(iAcn[start + 8], 0); + BOOST_CHECK_EQUAL(iAcn[start + 9], 0); + BOOST_CHECK_EQUAL(iAcn[start + 10], 2); + BOOST_CHECK_EQUAL(iAcn[start + 11], 8); + BOOST_CHECK_EQUAL(iAcn[start + 12], 0); + BOOST_CHECK_EQUAL(iAcn[start + 13], 2); + BOOST_CHECK_EQUAL(iAcn[start + 14], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 16], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start_a = 1 * actDims[6]; + start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 0], 0); + BOOST_CHECK_EQUAL(iAcn[start + 1], 0); + BOOST_CHECK_EQUAL(iAcn[start + 2], 0); + BOOST_CHECK_EQUAL(iAcn[start + 3], 0); + BOOST_CHECK_EQUAL(iAcn[start + 4], 0); + BOOST_CHECK_EQUAL(iAcn[start + 5], 0); + BOOST_CHECK_EQUAL(iAcn[start + 6], 0); + BOOST_CHECK_EQUAL(iAcn[start + 7], 0); + BOOST_CHECK_EQUAL(iAcn[start + 8], 0); + BOOST_CHECK_EQUAL(iAcn[start + 9], 0); + BOOST_CHECK_EQUAL(iAcn[start + 10], 1); + BOOST_CHECK_EQUAL(iAcn[start + 11], 8); + BOOST_CHECK_EQUAL(iAcn[start + 12], 0); + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 14], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 16], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 0], 0); + BOOST_CHECK_EQUAL(iAcn[start + 1], 0); + BOOST_CHECK_EQUAL(iAcn[start + 2], 0); + BOOST_CHECK_EQUAL(iAcn[start + 3], 0); + BOOST_CHECK_EQUAL(iAcn[start + 4], 0); + BOOST_CHECK_EQUAL(iAcn[start + 5], 0); + BOOST_CHECK_EQUAL(iAcn[start + 6], 0); + BOOST_CHECK_EQUAL(iAcn[start + 7], 0); + BOOST_CHECK_EQUAL(iAcn[start + 8], 0); + BOOST_CHECK_EQUAL(iAcn[start + 9], 0); + BOOST_CHECK_EQUAL(iAcn[start + 10], 2); + BOOST_CHECK_EQUAL(iAcn[start + 11], 3); + BOOST_CHECK_EQUAL(iAcn[start + 12], 0); + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 14], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 16], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 2 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 0], 0); + BOOST_CHECK_EQUAL(iAcn[start + 1], 0); + BOOST_CHECK_EQUAL(iAcn[start + 2], 0); + BOOST_CHECK_EQUAL(iAcn[start + 3], 0); + BOOST_CHECK_EQUAL(iAcn[start + 4], 0); + BOOST_CHECK_EQUAL(iAcn[start + 5], 0); + BOOST_CHECK_EQUAL(iAcn[start + 6], 0); + BOOST_CHECK_EQUAL(iAcn[start + 7], 0); + BOOST_CHECK_EQUAL(iAcn[start + 8], 0); + BOOST_CHECK_EQUAL(iAcn[start + 9], 0); + BOOST_CHECK_EQUAL(iAcn[start + 10], 11); + BOOST_CHECK_EQUAL(iAcn[start + 11], 8); + BOOST_CHECK_EQUAL(iAcn[start + 12], 0); + BOOST_CHECK_EQUAL(iAcn[start + 13], 0); + BOOST_CHECK_EQUAL(iAcn[start + 14], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 16], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start_a = 3 * actDims[6]; + start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 2); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 2 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 3 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 4 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start_a = 4 * actDims[6]; + start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 2 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 3 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 4 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start_a = 5 * actDims[6]; + start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 2); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 2 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 3 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 4 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start_a = 6 * actDims[6]; + start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 2 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 2); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 3 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 4 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start_a = 7 * actDims[6]; + start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 2 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 3 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 4 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 5 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 6 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start_a = 8 * actDims[6]; + start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 2); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 2 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 3 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 4 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 5 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 6 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + + start_a = 9 * actDims[6]; + start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 2); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 2 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 3 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 4 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 5 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 6 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + + start_a = 10 * actDims[6]; + start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 2 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 2); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 3 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 4 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 5 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 6 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + + start_a = 11 * actDims[6]; + start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 2 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 3 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 2); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 4 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 5 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 6 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + + start_a = 12 * actDims[6]; + start = start_a + 0 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 1 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 2 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 3 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 1); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 4 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 2); + BOOST_CHECK_EQUAL(iAcn[start + 15], 2); + BOOST_CHECK_EQUAL(iAcn[start + 17], 1); + + start = start_a + 5 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 1); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + + start = start_a + 6 * 26; + BOOST_CHECK_EQUAL(iAcn[start + 13], 0); + BOOST_CHECK_EQUAL(iAcn[start + 15], 0); + BOOST_CHECK_EQUAL(iAcn[start + 17], 0); + } + + + + { + /* + SACN + 26*Max number of conditions pr ACTIONX + + */ + + + const auto& sAcn = actionxData.getSACN(); + + auto start_a = 0 * actDims[6]; + auto start = start_a + 0 * 16; + BOOST_CHECK_EQUAL(sAcn[start + 0], 0); + BOOST_CHECK_EQUAL(sAcn[start + 1], 0); + BOOST_CHECK_EQUAL(sAcn[start + 2], 45); + BOOST_CHECK_EQUAL(sAcn[start + 3], 0); + BOOST_CHECK_EQUAL(sAcn[start + 4], 4); + BOOST_CHECK_EQUAL(sAcn[start + 5], 45); + BOOST_CHECK_EQUAL(sAcn[start + 6], 4); + BOOST_CHECK_EQUAL(sAcn[start + 7], 45); + BOOST_CHECK_EQUAL(sAcn[start + 8], 4); + BOOST_CHECK_EQUAL(sAcn[start + 9], 45); + BOOST_CHECK_EQUAL(sAcn[start + 10], 0); + BOOST_CHECK_EQUAL(sAcn[start + 11], 0); + BOOST_CHECK_EQUAL(sAcn[start + 12], 0); + BOOST_CHECK_EQUAL(sAcn[start + 13], 0); + BOOST_CHECK_EQUAL(sAcn[start + 14], 0); + BOOST_CHECK_EQUAL(sAcn[start + 15], 0); + + start = start_a + 1 * 16; + BOOST_CHECK_EQUAL(sAcn[start + 0], 0); + BOOST_CHECK_EQUAL(sAcn[start + 1], 0); + BOOST_CHECK_EQUAL(sAcn[start + 2], 46); + BOOST_CHECK_EQUAL(sAcn[start + 3], 0); + BOOST_CHECK_EQUAL(sAcn[start + 4], 0); + BOOST_CHECK_EQUAL(sAcn[start + 5], 46); + BOOST_CHECK_EQUAL(sAcn[start + 6], 0); + BOOST_CHECK_EQUAL(sAcn[start + 7], 46); + BOOST_CHECK_EQUAL(sAcn[start + 8], 0); + BOOST_CHECK_EQUAL(sAcn[start + 9], 46); + BOOST_CHECK_EQUAL(sAcn[start + 10], 0); + BOOST_CHECK_EQUAL(sAcn[start + 11], 0); + BOOST_CHECK_EQUAL(sAcn[start + 12], 0); + BOOST_CHECK_EQUAL(sAcn[start + 13], 0); + BOOST_CHECK_EQUAL(sAcn[start + 14], 0); + BOOST_CHECK_EQUAL(sAcn[start + 15], 0); + + start = start_a + 2 * 16; + BOOST_CHECK_EQUAL(sAcn[start + 0], 0); + BOOST_CHECK_EQUAL(sAcn[start + 1], 0); + BOOST_CHECK_EQUAL(sAcn[start + 2], 5); + BOOST_CHECK_EQUAL(sAcn[start + 3], 0); + BOOST_CHECK_EQUAL(sAcn[start + 4], 1.E+20); + BOOST_CHECK_EQUAL(sAcn[start + 5], 1.E+20); + BOOST_CHECK_EQUAL(sAcn[start + 6], 1.E+20); + BOOST_CHECK_EQUAL(sAcn[start + 7], 1.E+20); + BOOST_CHECK_EQUAL(sAcn[start + 8], 1.E+20); + BOOST_CHECK_EQUAL(sAcn[start + 9], 1.E+20); + BOOST_CHECK_EQUAL(sAcn[start + 10], 0); + BOOST_CHECK_EQUAL(sAcn[start + 11], 0); + BOOST_CHECK_EQUAL(sAcn[start + 12], 0); + BOOST_CHECK_EQUAL(sAcn[start + 13], 0); + BOOST_CHECK_EQUAL(sAcn[start + 14], 0); + BOOST_CHECK_EQUAL(sAcn[start + 15], 0); + } } { - /* - IACN - 26*Max number of conditions pr ACTIONX - - */ - - - const auto& iAcn = actionxData.getIACN(); - - auto start_a = 0*actDims[6]; - auto start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 0] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 1] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 2] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 3] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 4] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 5] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 6] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 7] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 8] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 9] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 10] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 11] , 8); - BOOST_CHECK_EQUAL(iAcn[start + 12] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 14] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 16] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 0] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 1] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 2] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 3] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 4] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 5] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 6] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 7] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 8] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 9] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 10] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 11] , 8); - BOOST_CHECK_EQUAL(iAcn[start + 12] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 13] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 14] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 16] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start_a = 1*actDims[6]; - start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 0] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 1] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 2] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 3] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 4] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 5] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 6] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 7] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 8] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 9] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 10] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 11] , 8); - BOOST_CHECK_EQUAL(iAcn[start + 12] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 14] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 16] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 0] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 1] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 2] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 3] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 4] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 5] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 6] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 7] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 8] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 9] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 10] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 11] , 3); - BOOST_CHECK_EQUAL(iAcn[start + 12] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 14] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 16] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 2*26; - BOOST_CHECK_EQUAL(iAcn[start + 0] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 1] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 2] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 3] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 4] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 5] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 6] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 7] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 8] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 9] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 10] , 11); - BOOST_CHECK_EQUAL(iAcn[start + 11] , 8); - BOOST_CHECK_EQUAL(iAcn[start + 12] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 14] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 16] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start_a = 3*actDims[6]; - start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 2*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 3*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 4*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start_a = 4*actDims[6]; - start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 2*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 3*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 4*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start_a = 5*actDims[6]; - start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 2*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 3*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 4*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start_a = 6*actDims[6]; - start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 2*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 3*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 4*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start_a = 7*actDims[6]; - start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 2*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 3*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 4*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 5*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 6*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start_a = 8*actDims[6]; - start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 2*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 3*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 4*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 5*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 6*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - - start_a = 9*actDims[6]; - start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 2*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 3*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 4*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 5*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 6*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - - start_a = 10*actDims[6]; - start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 2*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 3*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 4*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 5*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 6*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - - start_a = 11*actDims[6]; - start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 2*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 3*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 4*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 5*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 6*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - - start_a = 12*actDims[6]; - start = start_a + 0*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 1*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 2*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 3*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 4*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 2); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 1); - - start = start_a + 5*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 1); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - start = start_a + 6*26; - BOOST_CHECK_EQUAL(iAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 15] , 0); - BOOST_CHECK_EQUAL(iAcn[start + 17] , 0); - - + auto rst_file = std::make_shared("UDQ_ACTIONX_TEST1.UNRST"); + auto rst_view = std::make_shared(std::move(rst_file), 3); + auto rst_state = Opm::RestartIO::RstState::load(std::move(rst_view), es.runspec(), simCase.parser); + const auto& input_actions = sched[rptStep].actions(); + + BOOST_CHECK(rst_state.actions.size() == input_actions.ecl_size()); + + BOOST_CHECK_EQUAL(rst_state.actions[0].conditions.size(), 3); + BOOST_CHECK_EQUAL(rst_state.actions[1].conditions.size(), 3); + BOOST_CHECK_EQUAL(rst_state.actions[2].conditions.size(), 3); + BOOST_CHECK_EQUAL(rst_state.actions[3].conditions.size(), 5); + BOOST_CHECK_EQUAL(rst_state.actions[4].conditions.size(), 5); + BOOST_CHECK_EQUAL(rst_state.actions[5].conditions.size(), 5); + + + + { + const auto& action = rst_state.actions[0]; + BOOST_CHECK( compare_tokens(action.conditions[0].tokens(), {"FMWPR", ">", "45", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[1].tokens(), {"WUPR3", "OP*", ">", "46", "OR"})); + BOOST_CHECK( compare_tokens(action.conditions[2].tokens(), {"MNTH", "<", "MAY"})); + } + { + const auto& action = rst_state.actions[1]; + BOOST_CHECK( compare_tokens(action.conditions[0].tokens(), {"FMWPR", ">", "25", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[1].tokens(), {"WGPR", "OPL02", ">", "GGPR", "LOWER", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[2].tokens(), {"MNTH", ">", "NOV"})); + } + { + const auto& action = rst_state.actions[2]; + BOOST_CHECK( compare_tokens(action.conditions[0].tokens(), {"WWPR", "OPU01", ">", "WWPR", "OPU02", "OR"})); + BOOST_CHECK( compare_tokens(action.conditions[1].tokens(), {"GMWPR", "TEST", ">", "39", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[2].tokens(), {"YEAR", ">", "2020"})); + } + { + const auto& action = rst_state.actions[3]; + BOOST_CHECK( compare_tokens(action.conditions[0].tokens(), {"FMWPR", ">", "3", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[1].tokens(), {"(", "WUPR3", "OP*", ">", "46", "OR"})); + BOOST_CHECK( compare_tokens(action.conditions[2].tokens(), {"WOPR", "OP*", ">", "32", ")", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[3].tokens(), {"WWPR", "OP*", ">", "57", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[4].tokens(), {"MNTH", ">", "OCT"})); + } + { + const auto& action = rst_state.actions[7]; + BOOST_CHECK( compare_tokens(action.conditions[0].tokens(), {"(", "FMWPR", ">", "3", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[1].tokens(), {"WUPR3", "OP*", ">", "46", ")", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[2].tokens(), {"WOPR", "OP*", ">", "32", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[3].tokens(), {"(", "WLPR", "OP*", ">", "43", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[4].tokens(), {"WWCT", "OP*", ">", "0.310000", ")", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[5].tokens(), {"WWPR", "OP*", ">", "23", "AND"})); + BOOST_CHECK( compare_tokens(action.conditions[6].tokens(), {"MNTH", ">", "OCT"})); + } + + + std::vector actions; + for (const auto& rst_action : rst_state.actions) + actions.emplace_back( rst_action ); + + std::unordered_set input_keys; + std::unordered_set rst_keys; + for (std::size_t iact = 0; iact < input_actions.ecl_size(); iact++) { + const auto& input_action = input_actions[iact]; + const auto& rst_action = actions[iact]; + + BOOST_CHECK_EQUAL(input_action.name(), rst_action.name()); + BOOST_CHECK_EQUAL(input_action.max_run(), rst_action.max_run()); + BOOST_CHECK_CLOSE(input_action.min_wait(), rst_action.min_wait(), 1e-5); + + input_action.required_summary(input_keys); + rst_action.required_summary(rst_keys); + } + BOOST_CHECK( input_keys == rst_keys ); + + { + std::mt19937 rng; + std::uniform_real_distribution<> random_uniform(-100,100); + Opm::WListManager wlm; + auto year = 2020; + auto day = 1; + for (std::size_t month = 1; month <= 12; month++) { + auto state = Opm::SummaryState{ Opm::asTimePoint( Opm::TimeStampUTC(year, month, day) ) }; + Opm::Action::Context context(state, wlm); + for (const auto& key : rst_keys) { + const auto& first_char = key[0]; + if (first_char == 'W') { + for (const auto& well : {"OPU01", "OPU02", "OPL01", "OPL02"}) + state.update_well_var(well, key, random_uniform(rng)); + } else if (first_char == 'G') { + for (const auto& group : {"UPPER", "LOWER", "TEST"}) + state.update_group_var(group, key, random_uniform(rng)); + } else + state.update(key, random_uniform(rng)); + } + + for (std::size_t iact = 0; iact < input_actions.ecl_size(); iact++) { + const auto& input_action = input_actions[iact]; + const auto& rst_action = actions[iact]; + + const auto& input_res = input_action.eval(context); + const auto& rst_res = rst_action.eval(context); + + BOOST_CHECK( input_res == rst_res ); + } + } + } } - - - - { - /* - SACN - 26*Max number of conditions pr ACTIONX - - */ - - - const auto& sAcn = actionxData.getSACN(); - - auto start_a = 0*actDims[6]; - auto start = start_a + 0*16; - BOOST_CHECK_EQUAL(sAcn[start + 0] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 1] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 2] , 45); - BOOST_CHECK_EQUAL(sAcn[start + 3] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 4] , 4); - BOOST_CHECK_EQUAL(sAcn[start + 5] , 45); - BOOST_CHECK_EQUAL(sAcn[start + 6] , 4); - BOOST_CHECK_EQUAL(sAcn[start + 7] , 45); - BOOST_CHECK_EQUAL(sAcn[start + 8] , 4); - BOOST_CHECK_EQUAL(sAcn[start + 9] , 45); - BOOST_CHECK_EQUAL(sAcn[start + 10] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 11] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 12] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 14] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 15] , 0); - - start = start_a + 1*16; - BOOST_CHECK_EQUAL(sAcn[start + 0] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 1] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 2] , 46); - BOOST_CHECK_EQUAL(sAcn[start + 3] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 4] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 5] , 46); - BOOST_CHECK_EQUAL(sAcn[start + 6] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 7] , 46); - BOOST_CHECK_EQUAL(sAcn[start + 8] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 9] , 46); - BOOST_CHECK_EQUAL(sAcn[start + 10] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 11] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 12] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 14] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 15] , 0); - - start = start_a + 2*16; - BOOST_CHECK_EQUAL(sAcn[start + 0] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 1] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 2] , 5); - BOOST_CHECK_EQUAL(sAcn[start + 3] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 4] , 1.E+20); - BOOST_CHECK_EQUAL(sAcn[start + 5] , 1.E+20); - BOOST_CHECK_EQUAL(sAcn[start + 6] , 1.E+20); - BOOST_CHECK_EQUAL(sAcn[start + 7] , 1.E+20); - BOOST_CHECK_EQUAL(sAcn[start + 8] , 1.E+20); - BOOST_CHECK_EQUAL(sAcn[start + 9] , 1.E+20); - BOOST_CHECK_EQUAL(sAcn[start + 10] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 11] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 12] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 13] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 14] , 0); - BOOST_CHECK_EQUAL(sAcn[start + 15] , 0); - - } - } BOOST_AUTO_TEST_SUITE_END()