interference-helper.h

Go to the documentation of this file.

/*
 * Copyright (c) 2005,2006 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
 
#ifndef INTERFERENCE_HELPER_H
#define INTERFERENCE_HELPER_H
 
#include "phy-entity.h"
 
#include "ns3/object.h"
 
namespace ns3
{
 
class WifiPpdu;
class WifiPsdu;
class ErrorRateModel;
 
class Event : public SimpleRefCount<Event>
{
  public:
    Event(Ptr<const WifiPpdu> ppdu,
          const WifiTxVector& txVector,
          Time duration,
          RxPowerWattPerChannelBand&& rxPower);
    ~Event();
 
    Ptr<const WifiPpdu> GetPpdu() const;
    Time GetStartTime() const;
    Time GetEndTime() const;
    Time GetDuration() const;
    double GetRxPowerW() const;
    double GetRxPowerW(WifiSpectrumBand band) const;
    const RxPowerWattPerChannelBand& GetRxPowerWPerBand() const;
    const WifiTxVector& GetTxVector() const;
    void UpdateRxPowerW(const RxPowerWattPerChannelBand& rxPower);
 
  private:
    Ptr<const WifiPpdu> m_ppdu;           
    WifiTxVector m_txVector;              
    Time m_startTime;                     
    Time m_endTime;                       
    RxPowerWattPerChannelBand m_rxPowerW; 
};
 
std::ostream& operator<<(std::ostream& os, const Event& event);
 
class InterferenceHelper : public Object
{
  public:
    InterferenceHelper();
    ~InterferenceHelper() override;
 
    static TypeId GetTypeId();
 
    void AddBand(WifiSpectrumBand band);
 
    void RemoveBands();
 
    void SetNoiseFigure(double value);
    void SetErrorRateModel(const Ptr<ErrorRateModel> rate);
 
    Ptr<ErrorRateModel> GetErrorRateModel() const;
    void SetNumberOfReceiveAntennas(uint8_t rx);
 
    Time GetEnergyDuration(double energyW, WifiSpectrumBand band);
 
    Ptr<Event> Add(Ptr<const WifiPpdu> ppdu,
                   const WifiTxVector& txVector,
                   Time duration,
                   RxPowerWattPerChannelBand& rxPower,
                   bool isStartOfdmaRxing = false);
 
    void AddForeignSignal(Time duration, RxPowerWattPerChannelBand& rxPower);
    struct PhyEntity::SnrPer CalculatePayloadSnrPer(
        Ptr<Event> event,
        uint16_t channelWidth,
        WifiSpectrumBand band,
        uint16_t staId,
        std::pair<Time, Time> relativeMpduStartStop) const;
    double CalculateSnr(Ptr<Event> event,
                        uint16_t channelWidth,
                        uint8_t nss,
                        WifiSpectrumBand band) const;
    struct PhyEntity::SnrPer CalculatePhyHeaderSnrPer(Ptr<Event> event,
                                                      uint16_t channelWidth,
                                                      WifiSpectrumBand band,
                                                      WifiPpduField header) const;
 
    void NotifyRxStart();
    void NotifyRxEnd(Time endTime);
    void EraseEvents();
 
    void UpdateEvent(Ptr<Event> event, const RxPowerWattPerChannelBand& rxPower);
 
  protected:
    void DoDispose() override;
 
    double CalculateSnr(double signal,
                        double noiseInterference,
                        uint16_t channelWidth,
                        uint8_t nss) const;
    double CalculateChunkSuccessRate(double snir,
                                     Time duration,
                                     WifiMode mode,
                                     const WifiTxVector& txVector,
                                     WifiPpduField field) const;
    double CalculatePayloadChunkSuccessRate(double snir,
                                            Time duration,
                                            const WifiTxVector& txVector,
                                            uint16_t staId = SU_STA_ID) const;
 
  private:
    class NiChange
    {
      public:
        NiChange(double power, Ptr<Event> event);
        ~NiChange();
        double GetPower() const;
        void AddPower(double power);
        Ptr<Event> GetEvent() const;
 
      private:
        double m_power;     
        Ptr<Event> m_event; 
    };
 
    typedef std::multimap<Time, NiChange> NiChanges;
 
    typedef std::map<WifiSpectrumBand, NiChanges> NiChangesPerBand;
 
    void AppendEvent(Ptr<Event> event, bool isStartOfdmaRxing);
 
    double CalculateNoiseInterferenceW(Ptr<Event> event,
                                       NiChangesPerBand* nis,
                                       WifiSpectrumBand band) const;
    double CalculatePayloadPer(Ptr<const Event> event,
                               uint16_t channelWidth,
                               NiChangesPerBand* nis,
                               WifiSpectrumBand band,
                               uint16_t staId,
                               std::pair<Time, Time> window) const;
    double CalculatePhyHeaderPer(Ptr<const Event> event,
                                 NiChangesPerBand* nis,
                                 uint16_t channelWidth,
                                 WifiSpectrumBand band,
                                 WifiPpduField header) const;
    double CalculatePhyHeaderSectionPsr(Ptr<const Event> event,
                                        NiChangesPerBand* nis,
                                        uint16_t channelWidth,
                                        WifiSpectrumBand band,
                                        PhyEntity::PhyHeaderSections phyHeaderSections) const;
 
    double m_noiseFigure;                 
    Ptr<ErrorRateModel> m_errorRateModel; 
    uint8_t m_numRxAntennas; 
    NiChangesPerBand m_niChangesPerBand;                    
    std::map<WifiSpectrumBand, double> m_firstPowerPerBand; 
    bool m_rxing; 
 
    NiChanges::iterator GetNextPosition(Time moment, NiChangesPerBand::iterator niIt);
    NiChanges::iterator GetPreviousPosition(Time moment, NiChangesPerBand::iterator niIt);
 
    NiChanges::iterator AddNiChangeEvent(Time moment,
                                         NiChange change,
                                         NiChangesPerBand::iterator niIt);
};
 
} // namespace ns3
 
#endif /* INTERFERENCE_HELPER_H */