PhyUtils.h

#ifndef PHYUTILS_H_
#define PHYUTILS_H_

#include "AnalogueModel.h"
#include "Mapping.h"

#include <omnetpp.h>
#include <iostream>
#include <assert.h>
#include <list>



class RSAMMapping;

class RadioStateAnalogueModel : public AnalogueModel
{
  friend class RSAMMapping;
  friend class RSAMConstMappingIterator;

protected:

  class ListEntry
  {
  protected:
    std::pair<simtime_t, double> basicTimestamp;

  public:
    ListEntry(simtime_t time, double value) {
      basicTimestamp = std::pair<simtime_t, double> (time, value);
    }

    virtual ~ListEntry() {}

    simtime_t getTime() const {
      return basicTimestamp.first;
    }

    void setTime(simtime_t time) {
      basicTimestamp.first = time;
    }

    double getValue() const {
      return basicTimestamp.second;
    }

    void setValue(double value) {
      basicTimestamp.second = value;
    }

    friend bool operator<(const ListEntry& e, const simtime_t& t) {
      return (e.getTime() < t);
    }

    friend bool operator<(const simtime_t& t, const ListEntry& e) {
      return (t < e.getTime());
    }
  };


  bool currentlyTracking;

  std::list<ListEntry> radioStateAttenuation;

public:

  RadioStateAnalogueModel(double initValue,
              bool currentlyTracking = false,
              simtime_t initTime = 0)
    : currentlyTracking(currentlyTracking)
  {
    // put the initial time-stamp to the list
    radioStateAttenuation.push_back(ListEntry(initTime, initValue));
  }

  virtual ~RadioStateAnalogueModel() {}

  virtual void filterSignal(Signal& s);

  void setTrackingModeTo(bool b) {
    currentlyTracking = b;
  }

  void cleanUpUntil(simtime_t t);

  void writeRecvEntry(simtime_t time, double value);




}; // end class RadioStateAnalogueModel




class Radio
{
public:
  enum RadioState {
    RX = 0,
    TX,
    SLEEP,
    SWITCHING,

    NUM_RADIO_STATES
  };

protected:

  cOutVector radioStates;
  cOutVector radioChannels;

  int state;
  int nextState;


  const int numRadioStates;
  simtime_t** swTimes;

  const double minAtt;
  const double maxAtt;

  RadioStateAnalogueModel rsam;

  int currentChannel;

  int nbChannels;

public:

  static Radio* createNewRadio(bool recordStats = false,
                 int initialState = RX,
                 double minAtt = 1.0,
                 double maxAtt = 0.0,
                 int currentChannel=0, int nbChannels=1)
  {
    return new Radio(NUM_RADIO_STATES,
             recordStats,
             initialState,
             minAtt, maxAtt,
             currentChannel, nbChannels);
  }

  virtual ~Radio();

  virtual simtime_t switchTo(int newState, simtime_t now);

  virtual void setSwitchTime(int from, int to, simtime_t time);

  virtual int getCurrentState() const {
    return state;
  }



  virtual void endSwitch(simtime_t now);

  virtual RadioStateAnalogueModel* getAnalogueModel() {
    return (&rsam);
  }

  virtual void cleanAnalogueModelUntil(simtime_t t) {
    rsam.cleanUpUntil(t);
  }

  void setTrackingModeTo(bool b) {
    rsam.setTrackingModeTo(b);
  }

  void setCurrentChannel(int newChannel) {
    assert(newChannel > -1);
    assert(newChannel < nbChannels);
    currentChannel = newChannel;
    radioChannels.record(currentChannel);
  }

  int getCurrentChannel() {
    return currentChannel;
  }


protected:
  Radio(int numRadioStates,
      bool recordStats,
      int initialState = RX,
      double minAtt = 1.0, double maxAtt = 0.0,
      int currentChannel = 0, int nbChannels = 1);

  virtual void makeRSAMEntry(simtime_t time, int state)
  {
    rsam.writeRecvEntry(time, mapStateToAtt(state));
  }

  virtual double mapStateToAtt(int state)
  {
    if (state == RX) {
      return minAtt;
    }
    else{
      return maxAtt;
    }
  }
}; // end class Radio



class RSAMConstMappingIterator : public ConstMappingIterator
{
protected:

  const RadioStateAnalogueModel* rsam;

  typedef std::list<RadioStateAnalogueModel::ListEntry> CurrList;
  CurrList::const_iterator it;

  Argument position;
  Argument nextPosition;

  simtime_t signalStart;
  simtime_t signalEnd;

public:

  RSAMConstMappingIterator(const RadioStateAnalogueModel* rsam,
               simtime_t signalStart,
              simtime_t signalEnd);

  virtual ~RSAMConstMappingIterator() {}

  virtual void jumpTo(const Argument& pos);

  virtual void setNextPosition();

  virtual void jumpToBegin() {
    jumpTo(signalStart);
  }

  virtual void iterateTo(const Argument& pos);


  virtual void next() {
    iterateTo(nextPosition);
  }

  virtual bool inRange() const;

  virtual bool hasNext() const;

  virtual const Argument& getPosition() const {
    return position;
  }

  virtual const Argument& getNextPosition() const {
    return nextPosition;
  }

  virtual double getValue() const {
    return it->getValue();
  }


  virtual void iterateToOverZeroSwitches(simtime_t t);

}; // end class RSAMConstMappingIterator


class RSAMMapping : public ConstMapping
{
protected:

  const RadioStateAnalogueModel* rsam;
  simtime_t signalStart;
  simtime_t signalEnd;

public:
  RSAMMapping(const RadioStateAnalogueModel* rsam,
        simtime_t signalStart,
        simtime_t signalEnd) :
    ConstMapping(),
    rsam(rsam),
    signalStart(signalStart),
    signalEnd(signalEnd)
  {
    assert(rsam);
    assert( !(signalStart < rsam->radioStateAttenuation.front().getTime()) );
  }

  virtual ~RSAMMapping() {}

  virtual double getValue(const Argument& pos) const;

  virtual ConstMappingIterator* createConstIterator()
  {
    return new RSAMConstMappingIterator(rsam, signalStart, signalEnd);
  }

  virtual ConstMappingIterator* createConstIterator(const Argument& pos);

  virtual ConstMapping* constClone() const {
    return new RSAMMapping(*this);
  }

}; // end class RSAMMapping


#endif /*PHYUTILS_H_*/