artis-test/src/tests/fddevs/models.hpp

/**
 * @file tests/fddevs/models.hpp
 * @author The ARTIS Development Team
 * See the AUTHORS or Authors.txt file
 */

/*
 * ARTIS - the multimodeling and simulation environment
 * This file is a part of the ARTIS environment
 *
 * Copyright (C) 2013-2019 ULCO http://www.univ-littoral.fr
 *
 * This program 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.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef TESTS_FDDEVS_MODELS_HPP
#define TESTS_FDDEVS_MODELS_HPP

#include <artis-star/common/time/DoubleTime.hpp>
#include <artis-star/common/utils/Trace.hpp>

#include <artis-star/kernel/fddevs/Dynamics.hpp>

namespace artis {
    namespace tests {
        namespace fddevs {

            enum CRC_state_values {
                I0 = 0, I1, G, GR, WW, W, DW
            };

            class CRC : public artis::fddevs::Dynamics<common::DoubleTime, CRC, CRC_state_values> {
            public:
                enum inputs {
                    IN_P
                };
                enum outputs {
                    OUT_G, OUT_W
                };

                CRC(const std::string& name,
                        const artis::fddevs::Context<common::DoubleTime, CRC, artis::common::NoParameters>& context)
                        :
                        artis::fddevs::Dynamics<common::DoubleTime, CRC, CRC_state_values>(name,
                                context)
                {
                    input_ports({{IN_P, "p"}});
                    output_ports({{OUT_G, "g"},
                                  {OUT_W, "w"}});

                    initial_state(I0);
                }

                ~CRC() override = default;

                void delta_tau(typename common::DoubleTime::type /* t */) override
                {
                    switch (state()) {
                    case I0: {
                        state(I1);
                        break;
                    }
                    case I1: {
                        state(G);
                        break;
                    }
                    case G: {
                        state(G);
                        break;
                    }
                    case GR: {
                        state(WW);
                        break;
                    }
                    case WW: {
                        state(W);
                        break;
                    }
                    case W: {
                        state(DW);
                        break;
                    }
                    case DW: {
                        state(G);
                        break;
                    }
                    }
                }

                void
                delta_x(typename common::DoubleTime::type /* t */,
                        typename common::DoubleTime::type /* e */,
                        const common::Bag<common::DoubleTime>& bag) override
                {
                    assert(bag.size() == 1);

                    if (bag.at(0).on_port(IN_P) and state() == G) {
                        state(GR);
                    }
                }

                common::Bag<common::DoubleTime>
                lambda(typename common::DoubleTime::type /* t */) const override
                {
                    common::Bag<common::DoubleTime> msgs;

                    switch (state()) {
                    case I0:
                        msgs.push_back(
                                artis::common::ExternalEvent<common::DoubleTime>(OUT_W, 0));
                        break;
                    case I1:
                        msgs.push_back(
                                artis::common::ExternalEvent<common::DoubleTime>(OUT_G, 1));
                        break;
                    case G:
                        break;
                    case GR:
                        msgs.push_back(
                                artis::common::ExternalEvent<common::DoubleTime>(OUT_G, 0));
                        break;
                    case WW:
                        msgs.push_back(
                                artis::common::ExternalEvent<common::DoubleTime>(OUT_W, 1));
                        break;
                    case W:
                        msgs.push_back(
                                artis::common::ExternalEvent<common::DoubleTime>(OUT_W, 0));
                        break;
                    case DW:
                        msgs.push_back(
                                artis::common::ExternalEvent<common::DoubleTime>(OUT_G, 1));
                        break;
                    }
                    return msgs;
                }

                bool rho(typename common::DoubleTime::type /* time */,
                        const common::Bag<common::DoubleTime>& bag) const override
                {
                    return state() == G and bag.at(0).on_port(IN_P);
                }

                typename common::DoubleTime::type
                tau(typename common::DoubleTime::type /* t */) const override
                {
                    switch (state()) {
                    case I0:
                        return 0;
                    case I1:
                        return 0;
                    case G:
                        return 10;
                    case GR:
                        return 5;
                    case WW:
                        return 2;
                    case W:
                        return 26;
                    case DW:
                        return 2;
                    }
                    return common::DoubleTime::infinity;
                }
            };

            enum MXR_state_values {
                A00 = 0, A01, A10, A11, R11
            };

            class MXR : public artis::fddevs::Dynamics<common::DoubleTime, MXR, MXR_state_values> {
            public:
                enum inputs {
                    IN_A, IN_B
                };

                MXR(const std::string& name,
                        const artis::fddevs::Context<common::DoubleTime, MXR, artis::common::NoParameters>& context)
                        :
                        artis::fddevs::Dynamics<common::DoubleTime, MXR, MXR_state_values>(name,
                                context)
                {
                    input_ports({{IN_A, "a"},
                                 {IN_B, "b"}});
                    initial_state(A00);
                }

                ~MXR() override = default;

                void delta_tau(typename common::DoubleTime::type /* t */) override
                {
                    if (state() == A11) { state(R11); }
                }

                void
                delta_x(typename common::DoubleTime::type /* t */,
                        typename common::DoubleTime::type /* e */,
                        const common::Bag<common::DoubleTime>& bag) override
                {
                    std::for_each(bag.begin(), bag.end(),
                            [this](const artis::common::ExternalEvent<common::DoubleTime>& e) {
                                int data;

                                e.data()(data);
                                if (e.on_port(IN_A)) {
                                    switch (state()) {
                                    case A00: {
                                        if (data == 1) { state(A01); }
                                        break;
                                    }
                                    case A01: {
                                        if (data == 0) { state(A00); }
                                        break;
                                    }
                                    case A10: {
                                        if (data == 1) { state(A11); }
                                        break;
                                    }
                                    case A11: {
                                        if (data == 0) { state(A10); }
                                        break;
                                    }
                                    case R11:
                                        break;
                                    }
                                } else if (e.on_port(IN_B)) {
                                    switch (state()) {
                                    case A00: {
                                        if (data == 1) { state(A10); }
                                        break;
                                    }
                                    case A01: {
                                        if (data == 1) { state(A11); }
                                        break;
                                    }
                                    case A10: {
                                        if (data == 0) { state(A00); }
                                        break;
                                    }
                                    case A11: {
                                        if (data == 0) { state(A01); }
                                        break;
                                    }
                                    case R11:
                                        break;
                                    }
                                }
                            });
                }

                common::Bag<common::DoubleTime>
                lambda(typename common::DoubleTime::type /* t */) const override
                {
                    common::Bag<common::DoubleTime> msgs;

                    return msgs;
                }

                bool rho(typename common::DoubleTime::type /* time */,
                        const common::Bag<common::DoubleTime>& /* bag */) const override
                {
                    return false;
                }

                typename common::DoubleTime::type
                tau(typename common::DoubleTime::type /* t */) const override
                {
                    if (state() == A11) { return 0.01; }
                    else { return common::DoubleTime::infinity; }
                }
            };

            enum Beep_state_values {
                INIT = 0, SEND
            };

            class Beep
                    : public artis::fddevs::Dynamics<common::DoubleTime, Beep, Beep_state_values> {
            public:
                enum outputs {
                    OUT_P
                };

                Beep(const std::string& name,
                        const artis::fddevs::Context<common::DoubleTime, Beep, artis::common::NoParameters>& context)
                        :
                        artis::fddevs::Dynamics<common::DoubleTime, Beep, Beep_state_values>(name,
                                context)
                {
                    output_ports({{OUT_P, "p"}});

                    initial_state(INIT);
                }

                ~Beep() override = default;

                void delta_tau(typename common::DoubleTime::type /* t */) override
                {
                    if (state() == INIT) { state(SEND); }
                }

                common::Bag<common::DoubleTime>
                lambda(typename common::DoubleTime::type /* t */) const override
                {
                    common::Bag<common::DoubleTime> msgs;

                    switch (state()) {
                    case INIT:
                        msgs.push_back(
                                artis::common::ExternalEvent<common::DoubleTime>(OUT_P, 1));
                        break;
                    case SEND:
                        break;
                    }
                    return msgs;
                }

                bool rho(typename common::DoubleTime::type /* time */,
                        const common::Bag<common::DoubleTime>& /* bag */) const override
                {
                    return false;
                }

                typename common::DoubleTime::type
                tau(typename common::DoubleTime::type /* t */) const override
                {
                    switch (state()) {
                    case INIT:
                        return 27;
                    case SEND:
                        return common::DoubleTime::infinity;
                    }
                    return common::DoubleTime::infinity;
                }
            };

        }
    }
} // namespace artis tests fddevs

#endif