Attachment #3030 for bug #2791

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




 *       short period of time.
 ****************************************************************/

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

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

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

Ptr<InterferenceHelper::Event>

  return m_event;
}

bool
InterferenceHelper::NiChange::operator < (const InterferenceHelper::NiChange& o) const
{
  return (m_time < o.m_time);
}


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

Ptr<InterferenceHelper::Event>
InterferenceHelper::Add (Ptr<const Packet> packet, WifiTxVector txVector, Time duration, double rxPowerW)
{
  Ptr<InterferenceHelper::Event> event = Create<InterferenceHelper::Event> (packet, txVector, duration, rxPowerW);
  event = Create<InterferenceHelper::Event> (packet, txVector, duration, rxPowerW);
  AppendEvent (event);
  return event;
}

InterferenceHelper::GetEnergyDuration (double energyW) const
{
  Time now = Simulator::Now ();
  auto i = GetPreviousPosition (now);
  Time end = i->first;
  while (i != m_niChanges.end ())
  for (NiChanges::const_iterator i = m_niChanges.begin (); i != m_niChanges.end (); i++)
    {
      double noiseInterferenceW = i->second.GetPower ();
      end = i->first;
      if (end < now)
        {
          continue;
        }
      if (noiseInterferenceW < energyW)
        {
          break;
        }
      ++i;
    }
  return end > now ? end - now : MicroSeconds (0);
}

void
InterferenceHelper::AppendEvent (Ptr<InterferenceHelper::Event> event)
{
  NS_LOG_FUNCTION (this);
  double previousPowerStart = 0;
  double previousPowerEnd = 0;
  if (m_niChanges.size() > 0)
    {
      previousPowerStart = GetPreviousPosition (event->GetStartTime ())->second.GetPower ();
      previousPowerEnd = GetPreviousPosition (event->GetEndTime ())->second.GetPower ();
    }
  if (!m_rxing)
    {
      m_firstPower = previousPowerStart;
      m_niChanges.erase (m_niChanges.begin (), GetNextPosition (event->GetStartTime ()));
        {
          m_firstPower += i->GetDelta ();
        }
      m_niChanges.erase (m_niChanges.begin (), nowIterator);
    }
  auto first = AddNiChangeEvent (event->GetStartTime (), NiChange (previousPowerStart, event));
  auto last = AddNiChangeEvent (event->GetEndTime (), NiChange (previousPowerEnd, event));
  for (auto i = first; i != last; ++i)
    {
      i->second.AddPower (event->GetRxPowerW ());
    }
}

double

InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event> event, NiChanges *ni) const
{
  double noiseInterference = m_firstPower;
  auto it = m_niChanges.find (event->GetStartTime ());
  for (; it != m_niChanges.end () && it->second.GetEvent () != event; ++it)
    {
      noiseInterference = it->second.GetPower ();
      // until find the position of the event in the NI change list
      // The reason of using the event that causes the NI change to identify
      // different NI changes is because in some special cases
      // different NI changes happen at the same time with the same delta
      // value. Therefore, it may be impossible to identify a NI change that belongs
      // to which event based on just the NI time and NI delta value
      if (eventIterator->GetEvent () != event)
        {
          // The NI changes which happen before the event should be considered
          // as the interference. This considers the case that the receiving event
          // arrives while another receiving event is going on. The SINR of
          // the newly arrived event is calculated for checking the possibility of frame capture
          noiseInterference += eventIterator->GetDelta ();
        }
      else
        {
          break;
        }
      ++eventIterator;
    }
  ni->emplace (event->GetStartTime (), NiChange (0, event));
  while (++it != m_niChanges.end () && event != it->second.GetEvent ())
    {
      ni->insert (*it);
        {
          break;
        }
      ni->push_back (*i);
    }
  ni->emplace(event->GetEndTime (), NiChange (0, event));
  ni->push_back (NiChange (event->GetEndTime (), 0, event));
  return noiseInterference;
}


  NS_LOG_FUNCTION (this);
  const WifiTxVector txVector = event->GetTxVector ();
  double psr = 1.0; /* Packet Success Rate */
  auto j = ni->begin ();
  Time previous = j->first;
  WifiMode payloadMode = event->GetPayloadMode ();
  WifiPreamble preamble = txVector.GetPreambleType ();
  Time plcpHeaderStart = j->first + 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
  double noiseInterferenceW = m_firstPower;
  double powerW = event->GetRxPowerW ();
  while (++j != ni->end ())
  while (ni->end () != j)
    {
      Time current = j->first;
      NS_LOG_DEBUG ("previous= " << previous << ", current=" << current);
      NS_ASSERT (current >= previous);
      //Case 1: Both previous and current point to the payload

                                            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;
      j++;
    }
  double per = 1 - psr;
  return per;

  NS_LOG_FUNCTION (this);
  const WifiTxVector txVector = event->GetTxVector ();
  double psr = 1.0; /* Packet Success Rate */
  auto j = ni->begin ();
  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 = j->first + 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
  double noiseInterferenceW = m_firstPower;
  double powerW = event->GetRxPowerW ();
  while (++j != ni->end ())
  while (ni->end () != j)
    {
      Time current = j->first;
      NS_LOG_DEBUG ("previous= " << previous << ", current=" << current);
      NS_ASSERT (current >= previous);
      //Case 1: previous and current after playload start: nothing to do

            }
        }

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

  double per = 1 - psr;

}

struct InterferenceHelper::SnrPer
InterferenceHelper::CalculatePlcpPayloadSnrPer (Ptr<InterferenceHelper::Event> event) const
{
  NiChanges ni;
  double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni);

}

struct InterferenceHelper::SnrPer
InterferenceHelper::CalculatePlcpHeaderSnrPer (Ptr<InterferenceHelper::Event> event) const
{
  NiChanges ni;
  double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni);

}

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);
  if (it == m_niChanges.begin ())
    {
      it = m_niChanges.end();
    }
  else
    {
      --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 "ns3/packet.h"
#include "wifi-tx-vector.h"
#include "error-rate-model.h"
#include <map>

namespace ns3 {


   *
   * \return struct of SNR and PER
   */
  struct InterferenceHelper::SnrPer CalculatePlcpPayloadSnrPer (Ptr<InterferenceHelper::Event> event) const;
  /**
   * Calculate the SNIR at the start of the plcp header and accumulate
   * all SNIR changes in the snir vector.

   *
   * \return struct of SNR and PER
   */
  struct InterferenceHelper::SnrPer CalculatePlcpHeaderSnrPer (Ptr<InterferenceHelper::Event> event) const ;

  /**
   * Notify that RX has started.

    /**
     * Create a NiChange at the given time and the amount of NI change.
     *
     * \param power the power
     * \param delta the power
     * \param event causes this NI change
     */
    NiChange (double power, Ptr<InterferenceHelper::Event> event);
    /**
     * Return the event time.
     *
     * \return the event time.
     */
    Time GetTime (void) const;
    /**
     * 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;
    /**
     * Compare the event time of two NiChange objects (a < o).
     *
     * \param o
     * \return true if a < o.time, false otherwise
     */
    bool operator < (const NiChange& o) const;


private:
    double m_power; ///< power
    double m_delta; ///< delta
    Ptr<InterferenceHelper::Event> m_event; ///< event
  };
  /**
   * typedef for a multimap of NiChanges
   */
  typedef std::multimap<Time, NiChange> NiChanges;

  /**
   * Append the given Event.

  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 change
   * \param moment
   * \returns the iterator of the new event
   */
  NiChanges::iterator AddNiChangeEvent (Time moment, NiChange change);
};

} //namespace ns3

Return to bug 2791