.AddTraceSource ("TxSigParams",

                     "This trace is fired whenever a signal is transmitted. "

                     "The sole parameter is a pointer to a copy of the "

                     "SpectrumSignalParameters provided by the transmitter.",

                     MakeTraceSourceAccessor (&MultiModelSpectrumChannel::m_txSigParamsTrace),

                     "ns3::MultiModelSpectrumChannel::SignalParametersTracedCallback")

  /**

   * TracedCallback signature for Ptr<const SpectrumSignalParameters>.

   *

   * \param [in] params SpectrumSignalParameters instance.

   */

  typedef void (* SignalParametersTracedCallback) (Ptr<SpectrumSignalParameters> params);

  /**

   * Traced callback for SpectrumSignalParameters in StartTx requests

   */

  TracedCallback<Ptr<SpectrumSignalParameters> > m_txSigParamsTrace;

    default:

      NS_FATAL_ERROR ("Channel width should be correctly set.");

      return 0;

uint32_t

SpectrumWifiPhy::GetCenterFrequencyForChannelWidth (WifiTxVector txVector) const

{

  NS_LOG_FUNCTION (txVector);

  uint32_t centerFrequencyForSupportedWidth = GetFrequency ();

  uint32_t supportedWidth = static_cast<uint32_t> (GetChannelWidth ());

  uint32_t currentWidth = static_cast<uint32_t> (txVector.GetChannelWidth ());

  if (currentWidth != supportedWidth)

    {

      uint32_t startingFrequency = centerFrequencyForSupportedWidth - (supportedWidth / 2);

      return startingFrequency + (currentWidth / 2); // primary channel is in the lower part (for the time being)

    }

  return centerFrequencyForSupportedWidth;

}

  /**

   * Get the center frequency of the channel corresponding the current TxVector rather than

   * that of the supported channel width.

   * Consider that this "primary channel" is on the lower part for the time being.

   *

   * \param txVector the TXVECTOR that has the channel width that is to be used

   * \return the center frequency corresponding to the channel width to be used

   */

  uint32_t GetCenterFrequencyForChannelWidth (WifiTxVector txVector) const;

WifiRemoteStationManager::AdjustChannelWidthToMode (WifiTxVector initialTxVector) const

{

  NS_LOG_FUNCTION (this << initialTxVector);

  WifiModulationClass modulationClass = initialTxVector.GetMode ().GetModulationClass ();

  uint8_t defaultChannelWidth = initialTxVector.GetChannelWidth ();

  if (defaultChannelWidth > 20 &&

      (modulationClass == WifiModulationClass::WIFI_MOD_CLASS_OFDM || // all non-HT OFDM control and management frames

       modulationClass == WifiModulationClass::WIFI_MOD_CLASS_ERP_OFDM)) // special case of beacons at 2.4 GHz

    {

      WifiTxVector updatedTxVector = initialTxVector;

      updatedTxVector.SetChannelWidth (20);

      NS_LOG_LOGIC ("Channel width in TXVECTOR has been updated to 20 MHz channel");

      return updatedTxVector;

    }

  return initialTxVector;

}

WifiTxVector

  /**

   * Adjust the channel width to the selected mode (instead of letting the PHY's

   * default channel width). This is especially useful when using non-HT modes

   * with HT/VHT/HE capable stations (with default width above 20 MHz).

   *

   * \param initialTxVector TXVECTOR using the PHY's default channel width

   * \return TXVECTOR with channel width adapted to the selected mode

   */

  WifiTxVector AdjustChannelWidthToMode (WifiTxVector initialTxVector) const;

#include "ns3/spectrum-wifi-helper.h"

#include "ns3/spectrum-value.h"

#include "ns3/multi-model-spectrum-channel.h"

#include "ns3/udp-client-server-helper.h"

#include "ns3/wifi-spectrum-signal-parameters.h"

#include "ns3/wifi-phy-tag.h"

#include "ns3/internet-stack-helper.h"

#include "ns3/ipv4-address-helper.h"

#include <tuple>

#include <vector>

//-----------------------------------------------------------------------------

/**

 * Make sure that the correct channel width and center frequency have been set

 * for OFDM basic rate transmissions and BSS channel widths larger than 20 MHz.

 *

 * The scenario considers a UDP transmission between a 40 MHz 802.11ac station and a

 * 40 MHz 802.11ac access point. All transmission parameters are checked so as

 * to ensure that only 2 {starting frequency, channelWidth, Number of subbands

 * in SpectrumModel, modulation type} tuples are used.

 *

 * See \bugid{2483}

 */

class Bug2483TestCase : public TestCase

{

public:

  Bug2483TestCase ();

  virtual ~Bug2483TestCase ();

  virtual void DoRun (void);

private:

  /**

   * A tuple of {starting frequency, channelWidth, Number of subbands in SpectrumModel, modulation type}

   */

  typedef std::tuple<double, uint8_t, uint32_t, WifiModulationClass> FreqWidthSubbandModulationTuple;

  std::vector<FreqWidthSubbandModulationTuple> m_distinctTuples; ///< vector of distinct {starting frequency, channelWidth, Number of subbands in SpectrumModel, modulation type} tuples

  /**

   * Stores the distinct {starting frequency, channelWidth, Number of subbands in SpectrumModel, modulation type} tuples

   * that have been used during the testcase run.

   * \param txParams spectrum signal parameters set by transmitter

   */

  void StoreDistinctTuple (std::string context, Ptr<SpectrumSignalParameters> txParams);

};

Bug2483TestCase::Bug2483TestCase ()

  : TestCase ("Test case for Bug 2483")

{

}

Bug2483TestCase::~Bug2483TestCase ()

{

}

void

Bug2483TestCase::StoreDistinctTuple (std::string context,  Ptr<SpectrumSignalParameters> txParams)

{

  // Extract starting frequency and number of subbands

  Ptr<const SpectrumModel> c = txParams->psd->GetSpectrumModel ();

  uint32_t numBands = c->GetNumBands ();

  double startingFreq = c->Begin ()->fl;

  // Get channel bandwidth and modulation class

  Ptr<const WifiSpectrumSignalParameters> wifiTxParams = DynamicCast<WifiSpectrumSignalParameters> (txParams);

  Ptr<Packet> packet = wifiTxParams->packet->Copy ();

  WifiPhyTag tag;

  if (!packet->RemovePacketTag (tag))

    {

      NS_FATAL_ERROR ("Received Wi-Fi Signal with no WifiPhyTag");

      return;

    }

  WifiTxVector txVector = tag.GetWifiTxVector ();

  uint8_t channelWidth = txVector.GetChannelWidth ();

  WifiModulationClass modulationClass = txVector.GetMode ().GetModulationClass ();

  // Build a tuple and check if seen before (if so store it)

  FreqWidthSubbandModulationTuple tupleForCurrentTx = std::make_tuple (startingFreq, channelWidth,

                                                                       numBands, modulationClass);

  bool found = false;

  for (std::vector<FreqWidthSubbandModulationTuple>::const_iterator it = m_distinctTuples.begin (); it != m_distinctTuples.end (); it++)

    {

      if (*it == tupleForCurrentTx)

        {

          found = true;

        }

    }

  if (!found)

    {

      m_distinctTuples.push_back (tupleForCurrentTx);

    }

}

void

Bug2483TestCase::DoRun (void)

{

  Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("500")); // so as to force RTS/CTS for data frames

  Config::SetDefault ("ns3::WifiPhy::CcaMode1Threshold", DoubleValue (-62.0));

  NodeContainer wifiStaNode;

  wifiStaNode.Create (1);

  NodeContainer wifiApNode;

  wifiApNode.Create (1);

  SpectrumWifiPhyHelper spectrumPhy = SpectrumWifiPhyHelper::Default ();

  Ptr<MultiModelSpectrumChannel> spectrumChannel = CreateObject<MultiModelSpectrumChannel> ();

  Ptr<FriisPropagationLossModel> lossModel = CreateObject<FriisPropagationLossModel> ();

  lossModel->SetFrequency (5.180e9);

  spectrumChannel->AddPropagationLossModel (lossModel);

  Ptr<ConstantSpeedPropagationDelayModel> delayModel

  = CreateObject<ConstantSpeedPropagationDelayModel> ();

  spectrumChannel->SetPropagationDelayModel (delayModel);

  spectrumPhy.SetChannel (spectrumChannel);

  spectrumPhy.SetErrorRateModel ("ns3::NistErrorRateModel");

  spectrumPhy.Set ("Frequency", UintegerValue (5180));

  spectrumPhy.Set ("ChannelWidth", UintegerValue (40)); // at least 40 MHz expected here

  spectrumPhy.Set ("TxPowerStart", DoubleValue (10));

  spectrumPhy.Set ("TxPowerEnd", DoubleValue (10));

  WifiHelper wifi;

  wifi.SetStandard (WIFI_PHY_STANDARD_80211ac);

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",

                                "DataMode", StringValue ("VhtMcs8"),

                                "ControlMode", StringValue ("VhtMcs8"));

  WifiMacHelper mac;

  Ssid ssid = Ssid ("ns-3-ssid");

  mac.SetType ("ns3::StaWifiMac",

               "Ssid", SsidValue (ssid),

               "ActiveProbing", BooleanValue (false));

  NetDeviceContainer staDevice;

  staDevice = wifi.Install (spectrumPhy, mac, wifiStaNode);

  mac.SetType ("ns3::ApWifiMac",

               "Ssid", SsidValue (ssid),

               "BeaconGeneration", BooleanValue (true));

  NetDeviceContainer apDevice;

  apDevice = wifi.Install (spectrumPhy, mac, wifiApNode);

  MobilityHelper mobility;

  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

  positionAlloc->Add (Vector (0.0, 0.0, 0.0));

  positionAlloc->Add (Vector (1.0, 0.0, 0.0)); // put close enough in order to use MCS

  mobility.SetPositionAllocator (positionAlloc);

  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

  mobility.Install (wifiApNode);

  mobility.Install (wifiStaNode);

  InternetStackHelper stack;

  stack.Install (wifiApNode);

  stack.Install (wifiStaNode);

  Ipv4AddressHelper address;

  address.SetBase ("192.168.1.0", "255.255.255.0");

  Ipv4InterfaceContainer staNodeInterface;

  Ipv4InterfaceContainer apNodeInterface;

  staNodeInterface = address.Assign (staDevice);

  apNodeInterface = address.Assign (apDevice);

  ApplicationContainer serverApp;

  uint16_t port = 9;

  UdpServerHelper server (port);

  serverApp = server.Install (wifiStaNode.Get (0));

  serverApp.Start (Seconds (0.0));

  serverApp.Stop (Seconds (1.0));

  UdpClientHelper client (staNodeInterface.GetAddress (0), port);

  client.SetAttribute ("MaxPackets", UintegerValue (10)); // so as to have a short run

  client.SetAttribute ("Interval", TimeValue (Time ("0.00001")));

  client.SetAttribute ("PacketSize", UintegerValue (1000));

  ApplicationContainer clientApp = client.Install (wifiApNode.Get (0));

  clientApp.Start (Seconds (0.5));

  clientApp.Stop (Seconds (1.0));

  Config::Connect ("/ChannelList/*/$ns3::MultiModelSpectrumChannel/TxSigParams", MakeCallback (&Bug2483TestCase::StoreDistinctTuple, this));

  Simulator::Stop (Seconds (1.1));

  Simulator::Run ();

  Simulator::Destroy ();

  // {starting frequency, channelWidth, Number of subbands in SpectrumModel, modulation type} tuples

  uint8_t numberTuples = m_distinctTuples.size ();

  NS_TEST_ASSERT_MSG_EQ (numberTuples, 2, "Only two distinct tuples expected");

  // Note that the first tuple should the one initiated by the beacon

  NS_TEST_ASSERT_MSG_EQ (std::get<0> (m_distinctTuples[0]), std::get<0> (m_distinctTuples[1]), "Both tuples should have same starting frequency");

  NS_TEST_ASSERT_MSG_EQ (2 * std::get<1> (m_distinctTuples[0]), std::get<1> (m_distinctTuples[1]), "Second tuple's channel width should be double that of first");

  NS_TEST_ASSERT_MSG_EQ (std::get<2> (m_distinctTuples[0]), 129, "First tuple should have 129 subbands (64+DC, 20MHz+DC, inband and 32*2 out-of-band, 10MHz on each side)");

  NS_TEST_ASSERT_MSG_EQ (std::get<2> (m_distinctTuples[1]), 193, "Second tuple should have 193 subbands (128+DC, 40MHz+DC, inband and 32*2 out-of-band, 10MHz on each side)");

  NS_TEST_ASSERT_MSG_EQ (std::get<3> (m_distinctTuples[0]), WifiModulationClass::WIFI_MOD_CLASS_OFDM, "First tuple should be OFDM");

  NS_TEST_ASSERT_MSG_EQ (std::get<3> (m_distinctTuples[1]), WifiModulationClass::WIFI_MOD_CLASS_VHT, "Second tuple should be VHT_OFDM");

}

  AddTestCase (new Bug2483TestCase, TestCase::QUICK); //Bug 2483