Attachment #738 for bug #799

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




{
  return m_endTime;
}
bool 
InterferenceHelper::Event::Overlaps (Time time) const
{
  if (m_startTime <= time &&
      m_endTime >= time) 
    {
      return true;
    } 
  else 
    {
      return false;
    }
}
double 
InterferenceHelper::Event::GetRxPowerW (void) const
{

 ****************************************************************/

InterferenceHelper::InterferenceHelper ()
  : m_errorRateModel (0),
    m_firstPower (0.0),
    m_rxing (false)
{}
InterferenceHelper::~InterferenceHelper ()
{

     preamble,
     duration,
     rxPowerW);

  m_maxPacketDuration = std::max(duration, m_maxPacketDuration);
  AppendEvent (event);
  return event;
}

Time 
InterferenceHelper::GetMaxPacketDuration (void) const
{
  return m_maxPacketDuration;
}

void 
InterferenceHelper::SetNoiseFigure (double value)

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

  // first, we iterate over all events and, each event
  // which contributes energy to the channel now is 
  // appended to the noise interference array.
  Events::const_iterator i = m_events.begin ();
  double noiseInterferenceW = 0.0;
  NiChanges ni;
  while (i != m_events.end ()) 
    {
      Ptr<Event> ev = *i;
      NS_ASSERT (ev->GetStartTime () <= now);
      if (ev->GetEndTime () > now)
	{
          ni.push_back (NiChange (ev->GetEndTime (), -ev->GetRxPowerW ()));
          noiseInterferenceW += ev->GetRxPowerW ();
	}
      i++;
    }
  if (noiseInterferenceW < energyW)
    {
      return MicroSeconds (0);
    }

  /* quicksort vector of NI changes by time. 
   */
  std::sort (ni.begin (), ni.end (), std::less<NiChange> ());

  // Now, we iterate the piecewise linear noise function
  Time end = now;
  noiseInterferenceW = m_firstPower;
  for (NiChanges::const_iterator i = m_niChanges.begin (); i != m_niChanges.end (); i++)
    {
      noiseInterferenceW += i->GetDelta ();
      end = i->GetTime ();
      if (end < now)
        {
          continue;
        }
      if (noiseInterferenceW < energyW)
	      {
	        break;
	      }
    }
  return end > now ? end - now : MicroSeconds (0);
}

WifiMode 

void 
InterferenceHelper::AppendEvent (Ptr<InterferenceHelper::Event> event)
{
  Time now = Simulator::Now ();
  if (!m_rxing)
   * i.e.: all events which end _before_
   *       now - m_maxPacketDuration
   */
  
  if (Simulator::Now () > GetMaxPacketDuration ())
    {
      NiChanges::iterator nowIterator = GetPosition (now);
      for (NiChanges::iterator i = m_niChanges.begin (); i != nowIterator; i++)
      while (i != m_events.end () &&
             (*i)->GetEndTime () <= end) 
        {
          m_firstPower += i->GetDelta ();
        }
      m_niChanges.erase (m_niChanges.begin (), nowIterator);
      m_niChanges.insert (m_niChanges.begin (), NiChange (event->GetStartTime (), event->GetRxPowerW ())); 
    }
  else
    {
      AddNiChangeEvent (NiChange (event->GetStartTime (), event->GetRxPowerW ()));
    }
  AddNiChangeEvent(NiChange (event->GetEndTime (), -event->GetRxPowerW ()));

}



double
InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event> event, NiChanges *ni) const
{
  double noiseInterference = m_firstPower;
  NS_ASSERT (m_rxing);
  for (NiChanges::const_iterator i = m_niChanges.begin () + 1; i != m_niChanges.end (); i++)
    {
      if ((event->GetEndTime () == i->GetTime ()) && event->GetRxPowerW () == -i->GetDelta ())
        {
          break;
          continue;
        }
      ni->push_back (*i);
        {
          noiseInterference += (*i)->GetRxPowerW ();
        }
      else if (event->Overlaps ((*i)->GetStartTime ())) 
        {
          ni->push_back (NiChange ((*i)->GetStartTime (), (*i)->GetRxPowerW ()));
        }
      if (event->Overlaps ((*i)->GetEndTime ())) 
        {
          ni->push_back (NiChange ((*i)->GetEndTime (), -(*i)->GetRxPowerW ()));
        }
      i++;
    }
  ni->insert (ni->begin (), NiChange (event->GetStartTime (), noiseInterference));
  ni->push_back (NiChange (event->GetEndTime (), 0));

  /* quicksort vector of NI changes by time. */
  std::sort (ni->begin (), ni->end (), std::less<NiChange> ());

  return noiseInterference;
}


void
InterferenceHelper::EraseEvents (void) 
{  
  m_niChanges.clear ();
  m_firstPower = 0.0;
      *i = 0;
    }
  m_events.clear ();
}
InterferenceHelper::NiChanges::iterator
InterferenceHelper::GetPosition (Time moment)
{
  return std::upper_bound (m_niChanges.begin (), m_niChanges.end (), NiChange (moment, 0));

}
void
InterferenceHelper::AddNiChangeEvent (NiChange change)
{
  m_niChanges.insert (GetPosition (change.GetTime ()), change);
    {
      *i = 0;
    }
  m_events.erase (start, end);
}
void
InterferenceHelper::NotifyRxStart ()
{
  m_rxing = true;
}
void
InterferenceHelper::NotifyRxEnd ()
{
  m_rxing = false;
}
} // namespace ns3

(-)a/src/devices/wifi/interference-helper.h (-6 / +9 lines)

Lines 47-53	Link Here

    Time GetDuration (void) const;

    Time GetDuration (void) const;

    Time GetStartTime (void) const;

    Time GetStartTime (void) const;

    Time GetEndTime (void) const;

    Time GetEndTime (void) const;

    bool Overlaps (Time time) const;

    double GetRxPowerW (void) const;

    double GetRxPowerW (void) const;

    uint32_t GetSize (void) const;

    uint32_t GetSize (void) const;

    WifiMode GetPayloadMode (void) const;

    WifiMode GetPayloadMode (void) const;

Lines 95-100	Link Here

				      Time duration, double rxPower);

				      Time duration, double rxPower);

  struct InterferenceHelper::SnrPer CalculateSnrPer (Ptr<InterferenceHelper::Event> event);

  struct InterferenceHelper::SnrPer CalculateSnrPer (Ptr<InterferenceHelper::Event> event);

  void NotifyRxStart ();

  void NotifyRxEnd ();

  void EraseEvents (void);

  void EraseEvents (void);

private:

100

private:

100

  class NiChange {

101

  class NiChange {

Lines 110-117	Link Here

110

  typedef std::vector <NiChange> NiChanges;

111

  typedef std::vector <NiChange> NiChanges;

111

  typedef std::list<Ptr<Event> > Events;

112

  typedef std::list<Ptr<Event> > Events;

112

113

  void EraseEvents (Events::iterator start, Events::iterator end);

114

115

  InterferenceHelper (const InterferenceHelper &o);

114

  InterferenceHelper (const InterferenceHelper &o);

116

  InterferenceHelper &operator = (const InterferenceHelper &o);

115

  InterferenceHelper &operator = (const InterferenceHelper &o);

117

  void AppendEvent (Ptr<Event> event);

116

  void AppendEvent (Ptr<Event> event);

Lines 119-130	Link Here

119

  double CalculateSnr (double signal, double noiseInterference, WifiMode mode) const;

118

  double CalculateSnr (double signal, double noiseInterference, WifiMode mode) const;

120

  double CalculateChunkSuccessRate (double snir, Time delay, WifiMode mode) const;

119

  double CalculateChunkSuccessRate (double snir, Time delay, WifiMode mode) const;

121

  double CalculatePer (Ptr<const Event> event, NiChanges *ni) const;

120

  double CalculatePer (Ptr<const Event> event, NiChanges *ni) const;

122

  Time GetMaxPacketDuration (void) const;

123

121

124

  Time m_maxPacketDuration;

125

  double m_noiseFigure; /**< noise figure (linear) */

122

  double m_noiseFigure; /**< noise figure (linear) */

126

  Events m_events;

127

  Ptr<ErrorRateModel> m_errorRateModel;

123

  Ptr<ErrorRateModel> m_errorRateModel;

124

  ///Experimental: needed for energy duration calculation

125

  NiChanges m_niChanges;

126

  double m_firstPower;

127

  bool m_rxing;

128

  /// Returns an iterator to the first nichange, which is later than moment

129

  NiChanges::iterator GetPosition (Time moment);

130

  void AddNiChangeEvent (NiChange change);

128

};

131

};

129

132

130

} // namespace ns3

133

} // namespace ns3




        m_state->SwitchToRx (rxDuration);
        NS_ASSERT (m_endRxEvent.IsExpired ());
        NotifyRxBegin (packet);
        m_interference.NotifyRxStart();
        m_endRxEvent = Simulator::Schedule (rxDuration, &YansWifiPhy::EndReceive, this, 
                                            packet,
                                            event);

  if (m_state->IsStateRx ())
    {
      m_endRxEvent.Cancel ();
      m_interference.NotifyRxEnd ();
    }
  NotifyTxBegin (packet);
  uint32_t dataRate500KbpsUnits = txMode.GetDataRate () / 500000;   


  struct InterferenceHelper::SnrPer snrPer;
  snrPer = m_interference.CalculateSnrPer (event);
  m_interference.NotifyRxEnd();

  NS_LOG_DEBUG ("mode="<<(event->GetPayloadMode ().GetDataRate ())<<
                ", snr="<<snrPer.snr<<", per="<<snrPer.per<<", size="<<packet->GetSize ());

Return to bug 799