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

/**
 * @file tests/pdevs/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_PDEVS_MODELS_HPP
#define TESTS_PDEVS_MODELS_HPP

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

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

#include <chrono>
#include <iostream>

#define DELAY 100

namespace artis {
namespace tests {
namespace pdevs {

struct data {
  double x;
  double y;

  data()
      : x(0), y(0) {}

  data(double _x, double _y)
      : x(_x), y(_y) {}
};

class Inactive : public artis::pdevs::Dynamics<common::DoubleTime, Inactive> {
public:
  Inactive(const std::string &name,
           const artis::pdevs::Context<common::DoubleTime, Inactive> &context)
      :
      artis::pdevs::Dynamics<common::DoubleTime, Inactive>(name, context) {}

  ~Inactive() override = default;
};

class A : public artis::pdevs::Dynamics<common::DoubleTime, A> {
public:
  enum inputs {
    IN
  };
  enum outputs {
    OUT
  };

  A(const std::string &name,
    const artis::pdevs::Context<common::DoubleTime, A, artis::common::NoParameters> &context)
      :
      artis::pdevs::Dynamics<common::DoubleTime, A>(name, context) {
    input_ports({{IN, "in"}});
    output_ports({{OUT, "out"}});
  }

  ~A() override = default;

  void dint(const typename common::DoubleTime::type &t) override {

#ifndef WITH_TRACE
    (void)t;
#endif

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::DELTA_INT,
                                                    common::LevelType::USER);
    common::Trace<common::DoubleTime>::trace().flush();
#endif

    if (_phase == WAIT) {
      ++_value.x;
      --_value.y;
      _phase = SEND;
    } else if (_phase == SEND) {
      _phase = WAIT;
    }
  }

  void
  dext(const typename common::DoubleTime::type &t,
       const typename common::DoubleTime::type & /* e */,
       const common::Bag <common::DoubleTime> &msgs) override {

#ifndef WITH_TRACE
    (void)t;
    (void)msgs;
#endif

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::DELTA_EXT,
                                                    common::LevelType::USER)
        << "messages = " << msgs.to_string();
    common::Trace<common::DoubleTime>::trace().flush();
#endif

    _phase = SEND;
  }

  void dconf(const typename common::DoubleTime::type &t,
             const typename common::DoubleTime::type & /* e */,
             const common::Bag <common::DoubleTime> &msgs) override {

#ifndef WITH_TRACE
    (void)t;
    (void)msgs;
#endif

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::DELTA_CONF,
                                                    common::LevelType::USER)
        << "messages = " << msgs.to_string();
    common::Trace<common::DoubleTime>::trace().flush();
#endif

  }

  void start(const typename common::DoubleTime::type &t) override {

#ifndef WITH_TRACE
    (void)t;
#endif

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::START,
                                                    common::LevelType::USER);
    common::Trace<common::DoubleTime>::trace().flush();
#endif

    _phase = SEND;
  }

  typename common::DoubleTime::type
  ta(const typename common::DoubleTime::type &t) const override {

#ifndef WITH_TRACE
    (void)t;
#endif

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::TA,
                                                    common::LevelType::USER);
    common::Trace<common::DoubleTime>::trace().flush();
#endif

    if (_phase == WAIT) {
      return 1;
    } else {
      return 0;
    }
  }

  common::Bag <common::DoubleTime>
  lambda(const typename common::DoubleTime::type &t) const override {
#ifndef WITH_TRACE
    (void)t;
#endif
    common::Bag<common::DoubleTime> msgs;

    if (_phase == SEND) {
      msgs.push_back(
          artis::common::ExternalEvent<common::DoubleTime>(OUT, _value));
    }

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::LAMBDA,
                                                    common::LevelType::USER)
        << "messages = " << msgs.to_string();
    common::Trace<common::DoubleTime>::trace().flush();
#endif

    return msgs;
  }

private:
  enum Phase {
    WAIT, SEND
  };

  Phase _phase;
  data _value;
};

class B : public artis::pdevs::Dynamics<common::DoubleTime, B> {
public:
  enum inputs {
    IN
  };
  enum outputs {
    OUT
  };

  B(const std::string &name,
    const artis::pdevs::Context<common::DoubleTime, B, artis::common::NoParameters> &context)
      :
      artis::pdevs::Dynamics<common::DoubleTime, B>(name, context),
      _value(0) {
    input_ports({{IN, "in"}});
    output_ports({{OUT, "out"}});
  }

  ~B() override = default;

  void dint(const typename common::DoubleTime::type &t) override {

#ifndef WITH_TRACE
    (void)t;
#endif

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::DELTA_INT,
                                                    common::LevelType::USER);
    common::Trace<common::DoubleTime>::trace().flush();
#endif

    if (_phase == SEND) {
      _phase = WAIT;
    }
  }

  void
  dext(const typename common::DoubleTime::type &t,
       const typename common::DoubleTime::type & /* e */,
       const common::Bag <common::DoubleTime> &msgs) override {

#ifndef WITH_TRACE
    (void)t;
    (void)msgs;
#endif

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::DELTA_EXT,
                                                    common::LevelType::USER)
        << "messages = " << msgs.to_string();
    common::Trace<common::DoubleTime>::trace().flush();
#endif

    _phase = SEND;
  }

  void dconf(const typename common::DoubleTime::type &t,
             const typename common::DoubleTime::type &e,
             const common::Bag <common::DoubleTime> &msgs) override {

#ifndef WITH_TRACE
    (void)t;
    (void)msgs;
#endif

    dext(t, e, msgs);

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::DELTA_CONF,
                                                    common::LevelType::USER)
        << "messages = " << msgs.to_string();
    common::Trace<common::DoubleTime>::trace().flush();
#endif

  }

  void start(const typename common::DoubleTime::type &t) override {

#ifndef WITH_TRACE
    (void)t;
#endif

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::START,
                                                    common::LevelType::USER);
    common::Trace<common::DoubleTime>::trace().flush();
#endif

    _phase = WAIT;
  }

  typename common::DoubleTime::type ta(
      const typename common::DoubleTime::type &t) const override {

#ifndef WITH_TRACE
    (void)t;
#endif

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::TA,
                                                    common::LevelType::USER);
    common::Trace<common::DoubleTime>::trace().flush();
#endif

    if (_phase == WAIT) {
      return common::DoubleTime::infinity;
    } else {
      return 0;
    }
  }

  common::Bag <common::DoubleTime> lambda(
      const typename common::DoubleTime::type &t) const override {
#ifndef WITH_TRACE
    (void)t;
#endif
    common::Bag<common::DoubleTime> msgs;

    if (_phase == SEND) {
      msgs.push_back(
          artis::common::ExternalEvent<common::DoubleTime>(OUT, _value));
    }

#ifdef WITH_TRACE
    common::Trace<common::DoubleTime>::trace()
        << common::TraceElement<common::DoubleTime>(get_name(), t,
                                                    common::FormalismType::PDEVS,
                                                    common::FunctionType::LAMBDA,
                                                    common::LevelType::USER)
        << "messages = " << msgs.to_string();
    common::Trace<common::DoubleTime>::trace().flush();
#endif

    return msgs;
  }

private:
  enum Phase {
    WAIT, SEND
  };

  Phase _phase;
  double _value;
};

class TwoStateModel : public artis::pdevs::Dynamics<common::DoubleTime, TwoStateModel> {
public:
  TwoStateModel(const std::string &name,
                const artis::pdevs::Context<common::DoubleTime,
                                            TwoStateModel,
                                            artis::common::NoParameters> &context)
      :
      artis::pdevs::Dynamics<common::DoubleTime, TwoStateModel>(name, context) {}

  ~TwoStateModel() override = default;

  void dint(const typename common::DoubleTime::type &t) override {
    if (_phase == S1) {
      _phase = S2;
    } else if (_phase == S2) {
      _phase = S1;
    }
    _last_time = t;
  }

  void start(const typename common::DoubleTime::type &t) override {
    _phase = S1;
    _last_time = t;
  }

  typename common::DoubleTime::type
  ta(const typename common::DoubleTime::type & /* t */) const override {
    if (_phase == S1) {
      return 5;
    } else {
      return 6;
    }
  }

  common::Bag <common::DoubleTime>
  lambda(const typename common::DoubleTime::type &t) const override {

    std::cout << (t - _last_time) << std::endl;

    return common::Bag<common::DoubleTime>();
  }

private:
  enum Phase {
    S1, S2
  };

  Phase _phase;
  typename common::DoubleTime::type _last_time;
};

class ThreeStateModel
    : public artis::pdevs::Dynamics<common::DoubleTime, ThreeStateModel> {
public:
  enum outputs {
    OUT
  };

  enum states {
    HEIGHTS, SPEEDS, SCALES, N, INDEX, SIGMA, LAST_TIME
  };

  ThreeStateModel(const std::string &name,
                  const artis::pdevs::Context<common::DoubleTime,
                                              ThreeStateModel,
                                              artis::common::NoParameters> &context)
      :
      artis::pdevs::Dynamics<common::DoubleTime, ThreeStateModel>(name, context) {
    DECLARE_STATES(std::vector<double>,
                   ((HEIGHTS, &ThreeStateModel::heights), (SPEEDS, &ThreeStateModel::speeds), (SCALES, &ThreeStateModel::scales)));
    DECLARE_STATES(unsigned int,
                   ((N, &ThreeStateModel::n), (INDEX, &ThreeStateModel::index)));
    DECLARE_STATES(typename common::DoubleTime::type,
                   ((SIGMA, &ThreeStateModel::sigma), (LAST_TIME, &ThreeStateModel::_last_time)));

    output_ports({{OUT, "out"}});
  }

  ~ThreeStateModel() override = default;

  void dconf(const typename common::DoubleTime::type &t,
             const typename common::DoubleTime::type &e,
             const common::Bag <common::DoubleTime> &msgs) override {
    dext(t, e, msgs);
  }

  void dext(const typename common::DoubleTime::type & /* t */,
            const typename common::DoubleTime::type & /* e */,
            const common::Bag <common::DoubleTime> &msgs) override {
    for (common::Bag<common::DoubleTime>::const_iterator it = msgs.begin();
         it != msgs.end();
         ++it) {
      ++n;
    }
    if (sigma == 1) {
      if (n > 3) {
        ++index;
        if (index == scales.size()) {
          index = 0;
        }
        sigma = common::DoubleTime::infinity;
        if (scales[index] == 1) {
          scales[index] = 2;
        } else {
          scales[index] = 1;
        }
        n = 0;
      }
    } else {
      sigma = 1;
      n = 0;
    }
  }

  void dint(const typename common::DoubleTime::type &t) override {
    mark_full(t);
    if (full_N()) {
      raz();
    }
    compute();
  }

  void start(const typename common::DoubleTime::type &t) override {
    heights = {0, 0, 0, 0, 0};
    speeds = {0.21, 0.3, 0.7, 0.56, 0.14};
    scales = {1, 1, 1, 1, 1};
    index = 0;
    n = 0;
    sigma = 0;
    _last_time = t;
  }

  typename common::DoubleTime::type
  ta(const typename common::DoubleTime::type & /* t */) const override { return sigma; }

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

    if (full()) {
      msgs.push_back(artis::common::ExternalEvent<common::DoubleTime>(OUT, 0));
    }
    return msgs;
  }

private:
  void compute() {
    for (unsigned int i = 0; i < heights.size(); ++i) {
      if (heights[i] != -1 and heights[i] < 10) {
        heights[i] += speeds[i] * scales[i];
      }
    }
  }

  void display() const {
    for (std::vector<double>::const_iterator it = heights.begin();
         it != heights.end(); ++it) {
      std::cout << *it << " ";
    }
    std::cout << std::endl;
  }

  void display_full() const {
    unsigned int i = 1;

    for (std::vector<double>::const_iterator it = heights.begin();
         it != heights.end(); ++it, ++i) {
      if (*it > 10) {
        std::cout << "S" << i;
      }
    }
    std::cout << std::endl;
  }

  bool full() const {
    unsigned int n = 0;

    for (std::vector<double>::const_iterator it = heights.begin();
         it != heights.end(); ++it) {
      if (*it > 10) {
        ++n;
      }
    }
    return n > 0;
  }

  bool full_N() const {
    unsigned int n = 0;

    for (std::vector<double>::const_iterator it = heights.begin();
         it != heights.end(); ++it) {
      if (*it == -1) {
        ++n;
      }
    }
    return n >= 2;
  }

  void mark_full(const typename common::DoubleTime::type &t) {
    for (std::vector<double>::iterator it = heights.begin();
         it != heights.end(); ++it) {
      if (*it > 10) {
        *it = -1;
        _last_time = t;
      }
    }
  }

  void raz() {
    for (std::vector<double>::iterator it = heights.begin();
         it != heights.end(); ++it) {
      if (*it == -1) {
        *it = 0;
      }
    }
  }

  // state
  std::vector<double> heights;
  std::vector<double> speeds;
  std::vector<double> scales;
  unsigned int index;
  unsigned int n;
  typename common::DoubleTime::type sigma;
  typename common::DoubleTime::type _last_time;
};

}
}
} // namespace artis tests pdevs

#endif