nr-interference.h

// Copyright (c) 2019 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
//
// SPDX-License-Identifier: GPL-2.0-only
 
#ifndef NR_INTERFERENCE_H
#define NR_INTERFERENCE_H
 
#include "nr-chunk-processor.h"
#include "nr-interference-base.h"
 
#include <ns3/nstime.h>
#include <ns3/object.h>
#include <ns3/spectrum-signal-parameters.h>
#include <ns3/spectrum-value.h>
#include <ns3/traced-callback.h>
#include <ns3/vector.h>
 
namespace ns3
{
 
// Signal ID increment used in LteInterference
static constexpr uint32_t NR_LTE_SIGNALID_INCR = 0x10000000;
 
class NrCovMat;
class NrSinrMatrix;
class NrErrorModel;
class NrMimoChunkProcessor;
 
class NrInterference : public NrInterferenceBase
{
  public:
    NrInterference();
    ~NrInterference() override;
    static TypeId GetTypeId();
 
    void AddSignal(Ptr<const SpectrumValue> spd, Time duration) override;
 
    bool IsChannelBusyNow(double energyW);
 
    Time GetEnergyDuration(double energyW);
 
    void AppendEvent(Time startTime, Time endTime, double rxPowerW);
    void EraseEvents();
 
    // inherited from LteInterference
    void EndRx() override;
 
    virtual void AddSignalMimo(Ptr<const SpectrumSignalParameters> params, const Time& duration);
 
    virtual void StartRxMimo(Ptr<const SpectrumSignalParameters> params);
 
    virtual void DoSubtractSignalMimo(Ptr<const SpectrumSignalParameters> params,
                                      uint32_t signalId);
 
    virtual void AddMimoChunkProcessor(Ptr<NrMimoChunkProcessor> cp);
 
    bool IsChunkProcessorSet();
 
  private:
    NrCovMat CalcOutOfCellInterfCov() const;
 
    NrCovMat CalcCurrInterfCov(Ptr<const SpectrumSignalParameters> rxSignal,
                               const NrCovMat& outOfCellInterfCov) const;
 
    void AddInterference(NrCovMat& covMat, Ptr<const SpectrumSignalParameters> signal) const;
 
    NrSinrMatrix ComputeSinr(NrCovMat& outOfCellInterfCov,
                             Ptr<const SpectrumSignalParameters> rxSignal) const;
 
    std::vector<Ptr<const SpectrumSignalParameters>> m_allSignalsMimo;
 
    std::vector<Ptr<const SpectrumSignalParameters>> m_rxSignalsMimo;
 
    std::list<Ptr<NrMimoChunkProcessor>> m_mimoChunkProcessors;
 
    class NiChange
    {
      public:
        NiChange(Time time, double delta);
        Time GetTime() const;
        double GetDelta() const;
        bool operator<(const NiChange& o) const;
 
      private:
        Time m_time;
        double m_delta;
    };
 
    typedef std::vector<NiChange> NiChanges;
 
    NrInterference::NiChanges::iterator GetPosition(Time moment);
 
    // inherited from LteInterference
    void ConditionallyEvaluateChunk() override;
 
    void AddNiChangeEvent(NiChange change);
 
  protected:
    void DoDispose() override;
 
    TracedCallback<double> m_snrPerProcessedChunk;  
    TracedCallback<double> m_rssiPerProcessedChunk; 
 
    NiChanges m_niChanges; 
    double m_firstPower;   
};
 
} // namespace ns3
 
#endif /* NR_INTERFERENCE_H */