opm-common/tests/test_AggregateActionxData.cpp

#define BOOST_TEST_MODULE UDQ-ACTIONX_Data

#include <boost/test/unit_test.hpp>
#include <opm/output/eclipse/VectorItems/intehead.hpp>

#include <opm/output/eclipse/AggregateGroupData.hpp>
#include <opm/output/eclipse/AggregateWellData.hpp>
#include <opm/output/eclipse/AggregateConnectionData.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/SummaryState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>

#include <opm/parser/eclipse/Python/Python.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Action/State.hpp>
#include <opm/output/eclipse/AggregateUDQData.hpp>
#include <opm/output/eclipse/AggregateActionxData.hpp>
#include <opm/output/eclipse/WriteRestartHelpers.hpp>

#include <opm/output/eclipse/InteHEAD.hpp>
#include <opm/output/eclipse/VectorItems/intehead.hpp>
#include <opm/output/eclipse/DoubHEAD.hpp>

#include <opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQInput.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQActive.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQConfig.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/UDQ/UDQParams.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Action/ActionX.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Action/ActionContext.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellTestState.hpp>

#include <opm/parser/eclipse/Units/UnitSystem.hpp>
#include <opm/parser/eclipse/Units/Units.hpp>
#include <opm/common/utility/TimeService.hpp>
#include <opm/io/eclipse/ERst.hpp>
#include <opm/io/eclipse/RestartFileView.hpp>
#include <opm/io/eclipse/rst/state.hpp>
#include <opm/output/data/Wells.hpp>

#include <opm/io/eclipse/OutputStream.hpp>

#include <stdexcept>
#include <utility>
#include <exception>
#include <iostream>
#include <random>
#include <string>
#include <vector>
#include <fmt/format.h>

#include "tests/WorkArea.cpp"

namespace {

    Opm::Deck first_sim(std::string fname) {
        return Opm::Parser{}.parseFile(fname);
    }
}

bool compare_tokens(const std::vector<std::string>& rst_tokens, const std::vector<std::string>& 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()};
        state.update_well_var("OPU01", "WWPR", 21.);
        state.update_well_var("OPU02", "WWPR", 22.);
        state.update_well_var("OPL01", "WWPR", 23.);
        state.update_well_var("OPL02", "WWPR", 24.);

        state.update_well_var("OPU01", "WGPR", 230.);
        state.update_well_var("OPU02", "WGPR", 231.);
        state.update_well_var("OPL01", "WGPR", 232.);
        state.update_well_var("OPL02", "WGPR", 233.);

        state.update_group_var("UPPER", "GWPR", 36.);
        state.update_group_var("LOWER", "GWPR", 37.);
        state.update_group_var("TEST",  "GWPR", 73.);

        state.update_group_var("UPPER", "GGPR", 460.);
        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);

        state.update("FWPR", 73.);

        state.update("FMWPR", 4);
        state.update("MNTH", 1);
        state.update("YEAR", 2020);

        return state;
}

//int main(int argc, char* argv[])
struct SimulationCase
{
    explicit SimulationCase(const Opm::Deck& deck)
        : es   { deck }
        , grid { deck }
        , python{ std::make_shared<Opm::Python>() }
        , sched{ deck, es, python }
    {}

    // Order requirement: 'es' must be declared/initialised before 'sched'.
    Opm::EclipseState es;
    Opm::EclipseGrid  grid;
    std::shared_ptr<Opm::Python> python;
    Opm::Schedule     sched;
    Opm::Parser       parser;
};

BOOST_AUTO_TEST_SUITE(Aggregate_Actionx)



// test constructed UDQ-Actionx restart data
BOOST_AUTO_TEST_CASE(Declared_Actionx_data)
{
    const auto simCase = SimulationCase {first_sim("UDQ_ACTIONX_TEST1.DATA")};

    Opm::EclipseState es = simCase.es;
    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};
    std::string outputDir = "./";
    std::string baseName = "UDQ_ACTIONX_TEST1";
    Opm::Action::ActionX actx_14 = Opm::Action::ActionX("ACT14", 10, 0.543, start_time);
    Opm::Action::Result result = Opm::Action::Result(true);
    action_state.add_run(actx_14, start_time + 1.E09, result);

    double secs_elapsed = start_time + 2.E09;
    // set dummy value for next_step_size

    {
        WorkArea work;
        {
            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<int> ih
                = Opm::RestartIO::Helpers::createInteHead(es, grid, sched, secs_elapsed, rptStep, rptStep, rptStep-1);

            // set dummy value for next_step_size
            const double next_step_size = 0.1;
            const auto dh = Opm::RestartIO::Helpers::createDoubHead(es, sched, rptStep-1, 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-1, 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.tracer(), rptStep-1, {}, {}, 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-1);
                rstFile.write("ICON", conn_aggregator.getIConn());
                rstFile.write("SCON", conn_aggregator.getSConn());
                rstFile.write("XCON", conn_aggregator.getXConn());
            }

            const auto actDims = Opm::RestartIO::Helpers::createActionRSTDims(sched, rptStep-1);
            Opm::RestartIO::Helpers::AggregateActionxData actionxData {sched, action_state, st, rptStep-1};

            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 {1};
                const auto ih_1 = Opm::RestartIO::Helpers::createInteHead(
                    es, grid, sched, secs_elapsed, rptStep, rptStep_1, rptStep_1-1);

                BOOST_CHECK_EQUAL(ih_1[156], 2);
                BOOST_CHECK_EQUAL(ih_1[157], 7);



                const auto rptStep_2 = std::size_t {2};
                const auto ih_2 = Opm::RestartIO::Helpers::createInteHead(
                    es, grid, sched, secs_elapsed, rptStep, rptStep_2, rptStep_2-1);
                BOOST_CHECK_EQUAL(ih_2[156], 14);
                BOOST_CHECK_EQUAL(ih_2[157], 10);

                const auto rptStep_3 = std::size_t {3};
                const auto ih_3 = Opm::RestartIO::Helpers::createInteHead(
                    es, grid, sched, secs_elapsed, rptStep, rptStep_3, rptStep_3-1);

                BOOST_CHECK_EQUAL(ih_3[156], 14);
                BOOST_CHECK_EQUAL(ih_3[157], 10);
            }

            {
                /*
                  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);
            }

            {
                /*
                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
                */


                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(), "        ");

                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(), "        ");
            }

            {
                /*
                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);
            }
        }

        {
            auto rst_file = std::make_shared<Opm::EclIO::ERst>("UDQ_ACTIONX_TEST1.UNRST");
            auto rst_view = std::make_shared<Opm::EclIO::RestartFileView>(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-1].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<Opm::Action::ActionX> actions;
            for (const auto& rst_action : rst_state.actions)
                actions.emplace_back(rst_action);

            std::unordered_set<std::string> input_keys;
            std::unordered_set<std::string> 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);
                    }
                }
            }
        }
    }
}


BOOST_AUTO_TEST_SUITE_END()