Attachment #3155 for bug #2947

View | Details | Raw Unified | Return to bug 2947
Collapse All | Expand All




#include "ns3/log.h"
#include <algorithm>

using TimeInterval = boost::icl::interval<ns3::Time>;

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("InterferenceHelper");



/****************************************************************
 *       Class which records SNIR change events for a
 *       short period of time.
 ****************************************************************/

InterferenceHelper::NiChange::NiChange (double power, Ptr<InterferenceHelper::Event> event)
  : m_power (power),
    m_event (event)
{
}

double
InterferenceHelper::NiChange::GetPower (void) const
{
  return m_power;
}

void
InterferenceHelper::NiChange::AddPower (double power)
{
  m_power += power;
}

Ptr<InterferenceHelper::Event>
InterferenceHelper::NiChange::GetEvent (void) const
{
  return m_event;
}


/****************************************************************
 *       The actual InterferenceHelper
 ****************************************************************/

InterferenceHelper::InterferenceHelper ()
  : m_errorRateModel (0),
    m_numRxAntennas (1),
    m_firstPower (0),
    m_rxing (false)
{
  // Always have a zero power noise event in the list
  AddNiChangeEvent (Time (0), NiChange (0.0, 0));
}

InterferenceHelper::~InterferenceHelper ()

Time
InterferenceHelper::GetEnergyDuration (double energyW) const
{
  const Time now = Simulator::Now ();

  Time last = Time::Min();

  for (auto i = m_niChanges.find(now), end = m_niChanges.end (); i != end; ++i)
    {
      double noiseInterferenceW = i->second;
      last = i->first.upper();
      if (noiseInterferenceW < energyW)
        {
          break;
        }
    }
  return last > now ? last - now : MicroSeconds (0);
}

void
InterferenceHelper::AppendEvent (Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this);
  double previousPowerStart = 0;
  double previousPowerEnd = 0;
  previousPowerStart = GetPreviousPosition (event->GetStartTime ())->second.GetPower ();
  previousPowerEnd = GetPreviousPosition (event->GetEndTime ())->second.GetPower ();

  if (!m_rxing)
    {
      // Remove all events before this event, do not include the start time
      m_niChanges -= TimeInterval::right_open(Seconds(0), event->GetStartTime ());
      m_niChanges.erase (++(m_niChanges.begin ()),
                         GetNextPosition (event->GetStartTime ()));
    }

  auto inter = TimeInterval::closed(event->GetStartTime (), event->GetEndTime ());

  m_niChanges += std::make_pair(inter, event->GetRxPowerW());

  /*std::cout << inter << " " << event->GetRxPowerW() << std::endl;
  //std::cout << m_niChanges.size() << std::endl;
  for (auto i = m_niChanges.begin(), end = m_niChanges.end(); i != end; ++i)
  {
    std::cout << i->first << " " << i->second << std::endl;
  }
  std::cout << std::endl;*/
}

double

}

double
InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event> event, NiChangesRange *ni) const
{
  // Get all the powers between this event's start and end time inclusive
  *ni = m_niChanges.equal_range(TimeInterval::closed(event->GetStartTime (), event->GetEndTime()));

  /*auto it = m_niChanges.find (event->GetStartTime ());
  for (; it != m_niChanges.end () && it->second.GetEvent () != event; ++it)
    {
      noiseInterference = it->second.GetPower ();

    {
      ni->insert (*it);
    }
  ni->emplace (event->GetEndTime (), NiChange (0, event));*/

  // If there are no events, then there is no interference
  return ni->first == ni->second ? 0 : ni->first->second - event->GetRxPowerW ();
}

double

}

double
InterferenceHelper::CalculatePlcpPayloadPer (Ptr<const InterferenceHelper::Event> event, const NiChangesRange& ni) const
{
  NS_LOG_FUNCTION (this);
  const WifiTxVector txVector = event->GetTxVector ();
  const double powerW = event->GetRxPowerW ();

  double psr = 1.0; /* Packet Success Rate */
  
  Time previous = j->first;
  WifiMode payloadMode = event->GetPayloadMode ();
  WifiPreamble preamble = txVector.GetPreambleType ();
  Time plcpHeaderStart = event->GetStartTime() + WifiPhy::GetPlcpPreambleDuration (txVector); //packet start time + preamble
  Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (txVector); //packet start time + preamble + L-SIG
  Time plcpTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble) + WifiPhy::GetPlcpSigA1Duration (preamble) + WifiPhy::GetPlcpSigA2Duration (preamble); //packet start time + preamble + L-SIG + HT-SIG or SIG-A
  Time plcpPayloadStart = plcpTrainingSymbolsStart + WifiPhy::GetPlcpTrainingSymbolDuration (txVector) + WifiPhy::GetPlcpSigBDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG or SIG-A + Training + SIG-B
  
  for (auto j = ni.first, end = ni.second; j != end; ++j)
  while (++j != ni->end ())
    {
      const Time startt = j->first.lower();
      const Time endt = j->first.upper();

      const double noiseInterferenceW = j->second - powerW;

      NS_LOG_DEBUG ("startt= " << startt << ", endt=" << endt << ", noiseInterferenceW=" << noiseInterferenceW);

      //Case 1: This interval is after the payload has started
      if (startt >= plcpPayloadStart)
        {
          psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                          noiseInterferenceW,
                                                          txVector.GetChannelWidth ()),
                                            endt - startt,
                                            payloadMode, txVector);
          NS_LOG_DEBUG ("Both previous and current point to the payload: mode=" << payloadMode << ", psr=" << psr);
        }
      //Case 2: This interval starts before the payload, but it does include it
      else if (startt < plcpPayloadStart && plcpPayloadStart <= endt)
        {
          psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                          noiseInterferenceW,
                                                          txVector.GetChannelWidth ()),
                                            endt - plcpPayloadStart,
                                            payloadMode, txVector);
          NS_LOG_DEBUG ("previous is before payload and current is in the payload: mode=" << payloadMode << ", psr=" << psr);
        }
      noiseInterferenceW = j->second.GetPower () - powerW;
      previous = j->first;
    }
  double per = 1 - psr;
  return per;
}

double
InterferenceHelper::CalculatePlcpHeaderPer (Ptr<const InterferenceHelper::Event> event, const NiChangesRange& ni) const
{
  NS_LOG_FUNCTION (this);
  const WifiTxVector txVector = event->GetTxVector ();
  const double powerW = event->GetRxPowerW ();

  double psr = 1.0; /* Packet Success Rate */
  
  Time previous = j->first;
  WifiPreamble preamble = txVector.GetPreambleType ();
  WifiMode mcsHeaderMode;
  if (preamble == WIFI_PREAMBLE_HT_MF || preamble == WIFI_PREAMBLE_HT_GF)

      mcsHeaderMode = WifiPhy::GetHePlcpHeaderMode ();
    }
  WifiMode headerMode = WifiPhy::GetPlcpHeaderMode (txVector);
  Time plcpHeaderStart = event->GetStartTime() + WifiPhy::GetPlcpPreambleDuration (txVector); //packet start time + preamble
  Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (txVector); //packet start time + preamble + L-SIG
  Time plcpTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble) + WifiPhy::GetPlcpSigA1Duration (preamble) + WifiPhy::GetPlcpSigA2Duration (preamble); //packet start time + preamble + L-SIG + HT-SIG or SIG-A
  Time plcpPayloadStart = plcpTrainingSymbolsStart + WifiPhy::GetPlcpTrainingSymbolDuration (txVector) + WifiPhy::GetPlcpSigBDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG or SIG-A + Training + SIG-B
  
  for (auto j = ni.first, end = ni.second; j != end; ++j)
  while (++j != ni->end ())
    {
      const Time startt = j->first.lower();
      const Time endt = j->first.upper();

      const double noiseInterferenceW = j->second - powerW;

      NS_LOG_DEBUG ("startt= " << startt << ", endt=" << endt << ", noiseInterferenceW=" << noiseInterferenceW);

      //Case 1: interval after playload start: nothing to do
      if (startt >= plcpPayloadStart && endt >= plcpPayloadStart)
        {
          //psr *= 1;
          NS_LOG_DEBUG ("Case 1 - interval after playload start: nothing to do");
        }
      //Case 2: previous is in training or in SIG-B: legacy will not enter here since it didn't enter in the last two and they are all the same for legacy
      else if (previous >= plcpTrainingSymbolsStart)

              NS_LOG_DEBUG ("Case 5d - previous is in the preamble and current is in L-SIG: mode=" << headerMode << ", psr=" << psr);
            }
        }

      noiseInterferenceW = j->second.GetPower () - powerW;
      previous = j->first;
    }

  double per = 1 - psr;

struct InterferenceHelper::SnrPer
InterferenceHelper::CalculatePlcpPayloadSnrPer (Ptr<InterferenceHelper::Event> event) const
{
  NiChangesRange ni;
  double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni);
  double snr = CalculateSnr (event->GetRxPowerW (),
                             noiseInterferenceW,

  /* calculate the SNIR at the start of the packet and accumulate
   * all SNIR changes in the snir vector.
   */
  double per = CalculatePlcpPayloadPer (event, ni);

  struct SnrPer snrPer;
  snrPer.snr = snr;

struct InterferenceHelper::SnrPer
InterferenceHelper::CalculatePlcpHeaderSnrPer (Ptr<InterferenceHelper::Event> event) const
{
  NiChangesRange ni;
  double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni);
  double snr = CalculateSnr (event->GetRxPowerW (),
                             noiseInterferenceW,

  /* calculate the SNIR at the start of the plcp header and accumulate
   * all SNIR changes in the snir vector.
   */
  double per = CalculatePlcpHeaderPer (event, ni);

  struct SnrPer snrPer;
  snrPer.snr = snr;

InterferenceHelper::EraseEvents (void)
{
  m_niChanges.clear ();
  // Always have a zero power noise event in the list
  AddNiChangeEvent (Time (0), NiChange (0.0, 0));
  m_rxing = false;
  m_firstPower = 0;
}

InterferenceHelper::NiChanges::const_iterator
InterferenceHelper::GetNextPosition (Time moment) const
{
  return m_niChanges.upper_bound (moment);
}

InterferenceHelper::NiChanges::const_iterator
InterferenceHelper::GetPreviousPosition (Time moment) const
{
  auto it = GetNextPosition (moment);
  // This is safe since there is always an NiChange at time 0,
  // before moment.
  --it;
  return it;
}

InterferenceHelper::NiChanges::iterator
InterferenceHelper::AddNiChangeEvent (Time moment, NiChange change)
{
  return m_niChanges.insert (GetNextPosition (moment), std::make_pair (moment, change));
}

void

{
  NS_LOG_FUNCTION (this);
  m_rxing = false;
  //Update m_firstPower for frame capture
  auto it = m_niChanges.find (Simulator::Now ());
  it--;
  m_firstPower = it->second.GetPower ();
}

} //namespace ns3




#include "error-rate-model.h"
#include <map>

#include <boost/icl/interval_map.hpp>

namespace ns3 {

/**



private:
  typedef boost::icl::interval_map<Time, double, boost::icl::partial_enricher> NiChanges;
   * Noise and Interference (thus Ni) event.
   */
  class NiChange
  {
public:
    /**
     * Create a NiChange at the given time and the amount of NI change.
     *
     * \param power the power
     * \param event causes this NI change
     */
    NiChange (double power, Ptr<InterferenceHelper::Event> event);
    /**
     * Return the power
     *
     * \return the power
     */
    double GetPower (void) const;
    /**
     * Add a given amount of power.
     *
     * \param power the power to be added to the existing value
     */
    void AddPower (double power);
    /**
     * Return the event causes the corresponding NI change
     *
     * \return the event
     */
    Ptr<InterferenceHelper::Event> GetEvent (void) const;


private:
    double m_power; ///< power
    Ptr<InterferenceHelper::Event> m_event; ///< event
  };

  /**
   * typedef for a multimap of NiChanges
   */
  typedef std::pair<NiChanges::const_iterator, NiChanges::const_iterator> NiChangesRange;

  /**
   * Append the given Event.

   *
   * \return noise and interference power
   */
  double CalculateNoiseInterferenceW (Ptr<Event> event, NiChangesRange *ni) const;
  /**
   * Calculate SNR (linear ratio) from the given signal power and noise+interference power.
   * (Mode is not currently used)

   *
   * \return the error rate of the packet
   */
  double CalculatePlcpPayloadPer (Ptr<const Event> event, const NiChangesRange& ni) const;
  /**
   * Calculate the error rate of the plcp header. The plcp header can be divided into
   * multiple chunks (e.g. due to interference from other transmissions).

   *
   * \return the error rate of the packet
   */
  double CalculatePlcpHeaderPer (Ptr<const Event> event, const NiChangesRange& ni) const;

  double m_noiseFigure; /**< noise figure (linear) */
  Ptr<ErrorRateModel> m_errorRateModel; ///< error rate model
  uint8_t m_numRxAntennas; /**< the number of RX antennas in the corresponding receiver */
  /// Experimental: needed for energy duration calculation
  NiChanges m_niChanges; // partial_enricher allows storing intervals with 0 power
  double m_firstPower; ///< first power
  bool m_rxing; ///< flag whether it is in receiving state

  /**
   * Returns an iterator to the first nichange that is later than moment
   *
   * \param moment time to check from
   * \returns an iterator to the list of NiChanges
   */
  NiChanges::const_iterator GetNextPosition (Time moment) const;
  /**
   * Returns an iterator to the first nichange that is later than moment
   *
   * \param moment time to check from
   * \returns an iterator to the list of NiChanges
   */
  //NiChanges::iterator GetNextPosition (Time moment);
  /**
   * Returns an iterator to the last nichange that is before than moment
   *
   * \param moment time to check from
   * \returns an iterator to the list of NiChanges
   */
  NiChanges::const_iterator GetPreviousPosition (Time moment) const;

  /**
   * Add NiChange to the list at the appropriate position and
   * return the iterator of the new event.
   *
   * \param moment
   * \param change
   * \returns the iterator of the new event
   */
  NiChanges::iterator AddNiChangeEvent (Time moment, NiChange change);
};

} //namespace ns3

Return to bug 2947