public:

private:

#include "ns3/wifi-mode.h"

#include "ns3/wifi-phy.h"

#include "ns3/wifi-utils.h"

#include "ns3/interference-helper.h"

 * \brief Wifi Error Rate Models check MIMO abstraction

 */

class WifiErrorRateModelsTestCaseMimo : public TestCase

{

public:

  WifiErrorRateModelsTestCaseMimo ();

  virtual ~WifiErrorRateModelsTestCaseMimo ();

private:

  virtual void DoRun (void);

};

WifiErrorRateModelsTestCaseMimo::WifiErrorRateModelsTestCaseMimo ()

  : TestCase ("WifiErrorRateModel test case MIMO abstraction")

{

}

WifiErrorRateModelsTestCaseMimo::~WifiErrorRateModelsTestCaseMimo ()

{

}

void

WifiErrorRateModelsTestCaseMimo::DoRun (void)

{

  InterferenceHelper interference;

  WifiMode mode = WifiPhy::GetHtMcs0 ();

  WifiTxVector txVector;

  txVector.SetMode (mode);

  txVector.SetTxPowerLevel (0);

  txVector.SetChannelWidth (20);

  txVector.SetNss (1);

  txVector.SetNTx (1);

  interference.SetNumberOfReceiveAntennas (1);

  Ptr<NistErrorRateModel> nist = CreateObject<NistErrorRateModel> ();

  interference.SetErrorRateModel (nist);

  // Set the SNR so as to obtain a chunk success ratio of between 0 and 1

  // 4 dB SNR at HtMcs0 and 2 ms duration yields a success probability of

  // 0.820266 with this OFDM error model

  double snr = DbToRatio (4);

  double baselineSnr = snr;

  Time baselineDuration = MilliSeconds (2);

  double chunkSuccess = interference.CalculateChunkSuccessRate (snr, baselineDuration, mode, txVector);

  NS_TEST_ASSERT_MSG_EQ_TOL (chunkSuccess, 0.820266, 0.000001, "Attempt to set baseline to known value failed");

  double baselineChunkSuccess = chunkSuccess; 

  // MIMO 1x2 spatial diversity

  // Increase number of receive antennas to 2; expect that required SNR drops

  // by factor of 3 dB to maintain the same success ratio

  interference.SetNumberOfReceiveAntennas (2);

  snr = baselineSnr / 2;  // -3 dB

  chunkSuccess = interference.CalculateChunkSuccessRate (snr, baselineDuration, mode, txVector);

  NS_TEST_ASSERT_MSG_EQ_TOL (chunkSuccess, baselineChunkSuccess, 0.000001, "Not equal within tolerance for 1x2 spatial diversity");

  // MIMO 2x1 spatial diversity

  // Set number of transmit antennas to 2, receive to 1; expect that 

  // required SNR drops by factor of 3 dB to maintain the same success ratio

  interference.SetNumberOfReceiveAntennas (1);

  txVector.SetNTx (2);

  snr = baselineSnr / 2;  // -3 dB

  chunkSuccess = interference.CalculateChunkSuccessRate (snr, baselineDuration, mode, txVector);

  NS_TEST_ASSERT_MSG_EQ_TOL (chunkSuccess, baselineChunkSuccess, 0.000001, "Not equal within tolerance for 2x1 spatial diversity");

  // MIMO 2x2 spatial diversity

  // Set number of transmit antennas to 2, receive to 2; expect that 

  // required SNR drops by factor of 6 dB to maintain the same success ratio

  interference.SetNumberOfReceiveAntennas (2);

  txVector.SetNTx (2);

  snr = baselineSnr / 4;  // -6 dB

  chunkSuccess = interference.CalculateChunkSuccessRate (snr, baselineDuration, mode, txVector);

  NS_TEST_ASSERT_MSG_EQ_TOL (chunkSuccess, baselineChunkSuccess, 0.000001, "Not equal within tolerance for 2x2 spatial diversity");

  // MIMO 2x2 with two spatial streams

  // Set number of transmit antennas to 2, receive to 2; set HtMcs8 

  // The data rate will double (HtMcs8) but for a given frame, spread across

  // two spatial streams, the duration will be cut in half.  The required SNR 

  // to maintain the same chunkSuccess should be the same as 1x1 at MCS0

  mode = WifiPhy::GetHtMcs8 ();

  txVector.SetMode (mode);

  interference.SetNumberOfReceiveAntennas (2);

  txVector.SetNTx (2);

  txVector.SetNss (2);

  snr = baselineSnr;

  chunkSuccess = interference.CalculateChunkSuccessRate (snr, baselineDuration / 2, mode, txVector);

  NS_TEST_ASSERT_MSG_EQ_TOL (chunkSuccess, baselineChunkSuccess, 0.000001, "Not equal within tolerance for 2 spatial streams");

}

/**

 * \ingroup wifi-test

 * \ingroup tests

 *

  AddTestCase (new WifiErrorRateModelsTestCaseMimo, TestCase::QUICK);