satellite-signal-parameters.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013 Magister Solutions Ltd.
 * Copyright (c) 2018 CNES
 *
 * 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: Jani Puttonen <jani.puttonen@magister.fi>
 * Author: Mathias Ettinger <mettinger@toulouse.viveris.fr>
 */
 
#ifndef SATELLITE_SIGNAL_PARAMETERS_H
#define SATELLITE_SIGNAL_PARAMETERS_H
 
#include "satellite-enums.h"
#include "satellite-utils.h"
 
#include "ns3/nstime.h"
#include "ns3/object.h"
#include "ns3/packet.h"
#include "ns3/ptr.h"
 
#include <stdint.h>
#include <utility>
#include <vector>
 
namespace ns3
{
 
class SatPhyTx;
 
class SatInterferenceParameters : public Object
{
  public:
    static TypeId GetTypeId(void);
 
    ~SatInterferenceParameters();

    double m_rxPowerInSatellite_W;

    double m_rxNoisePowerInSatellite_W;

    double m_rxAciIfPowerInSatellite_W;

    double m_rxExtNoisePowerInSatellite_W;

    double m_sinr;

    double m_additionalInterference;

    double m_ifPower_W;

    double m_ifPowerInSatellite_W;

    std::vector<std::pair<double, double>> m_ifPowerPerFragment_W;

    std::vector<std::pair<double, double>> m_ifPowerInSatellitePerFragment_W;
 
    bool m_sinrComputed;
};

class SatSignalParameters : public Object
{
  public:
    typedef struct
    {
        SatEnums::PacketType_t packetType;
        SatEnums::SatModcod_t modCod;
        uint8_t sliceId;
        uint32_t fecBlockSizeInBytes;
        SatEnums::SatBbFrameType_t frameType;
        uint32_t waveformId;
        uint32_t crdsaUniquePacketId;
    } txInfo_s;

    typedef std::vector<Ptr<Packet>> PacketsInBurst_t;

    SatSignalParameters();
    ~SatSignalParameters();

    SatSignalParameters(const SatSignalParameters& p);
 
    Ptr<SatSignalParameters> Copy();

    static TypeId GetTypeId(void);

 
    PacketsInBurst_t m_packetsInBurst;

    uint32_t m_satId;

    uint32_t m_beamId;

    uint32_t m_carrierId;

    double m_carrierFreq_hz;

    Time m_duration;

    double m_txPower_W;

    double m_rxPower_W;

    Ptr<SatPhyTx> m_phyTx;

    SatEnums::ChannelType_t m_channelType;

    txInfo_s m_txInfo;

    inline void SetInterferencePower(std::vector<std::pair<double, double>> ifPowerPerFragment)
    {
        m_ifParams->m_ifPowerPerFragment_W = ifPowerPerFragment;
        m_ifParams->m_ifPower_W = SatUtils::ScalarProduct(ifPowerPerFragment);
    }

    inline double GetInterferencePower()
    {
        return m_ifParams->m_ifPower_W;
    }

    inline std::vector<std::pair<double, double>> GetInterferencePowerPerFragment()
    {
        return m_ifParams->m_ifPowerPerFragment_W;
    }

    inline void SetInterferencePowerInSatellite(
        std::vector<std::pair<double, double>> ifPowerPerFragment)
    {
        m_ifParams->m_ifPowerInSatellitePerFragment_W = ifPowerPerFragment;
        m_ifParams->m_ifPowerInSatellite_W = SatUtils::ScalarProduct(ifPowerPerFragment);
    }

    inline double GetInterferencePowerInSatellite()
    {
        return m_ifParams->m_ifPowerInSatellite_W;
    }

    inline std::vector<std::pair<double, double>> GetInterferencePowerInSatellitePerFragment()
    {
        return m_ifParams->m_ifPowerInSatellitePerFragment_W;
    }

    void SetRxPowersInSatellite(double rxPowerW,
                                double rxNoisePowerW,
                                double rxAciIfPowerW,
                                double rxExtNoisePowerW);
 
    inline double GetRxPowerInSatellite()
    {
        return m_ifParams->m_rxPowerInSatellite_W;
    }
 
    inline double GetRxNoisePowerInSatellite()
    {
        return m_ifParams->m_rxNoisePowerInSatellite_W;
    }
 
    inline double GetRxAciIfPowerInSatellite()
    {
        return m_ifParams->m_rxAciIfPowerInSatellite_W;
    }
 
    inline double GetRxExtNoisePowerInSatellite()
    {
        return m_ifParams->m_rxExtNoisePowerInSatellite_W;
    }

    void SetSinr(double sinr, double additionalInterference);
 
    inline double GetSinr()
    {
        return m_ifParams->m_sinr;
    }
 
    inline double GetAdditionalInterference()
    {
        return m_ifParams->m_additionalInterference;
    }
 
    inline bool HasSinrComputed()
    {
        return m_ifParams->m_sinrComputed;
    }
 
  private:
    Ptr<SatInterferenceParameters> m_ifParams;
};
 
} // namespace ns3
 
#endif /* SATELLITE_SIGNAL_PARAMETERS_H */