Mercurial Mercurial > ns-3.24 / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/wifi/model/interference-helper.cc
changeset 11628 243b71de25a0
parent 11570 1bf102a32c67
equal deleted inserted replaced
11627:01fcacb5eedf 11628:243b71de25a0 
   232 
   232 
   233 }
 
   233 }
 
   234 
   234 
   235 
   235 
   236 double
 
   236 double
 
   237 InterferenceHelper::CalculateSnr (double signal, double noiseInterference, WifiMode mode) const
 
   237 InterferenceHelper::CalculateSnr (double signal, double noiseInterference, uint32_t channelWidth) const
 
   238 {
 
   238 {
 
   239   //thermal noise at 290K in J/s = W
 
   239   //thermal noise at 290K in J/s = W
 
   240   static const double BOLTZMANN = 1.3803e-23;
 
   240   static const double BOLTZMANN = 1.3803e-23;
 
   241   //Nt is the power of thermal noise in W
 
   241   //Nt is the power of thermal noise in W
 
   242   double Nt = BOLTZMANN * 290.0 * mode.GetBandwidth ();
 
   242   double Nt = BOLTZMANN * 290.0 * channelWidth * 1000000;
 
   243   //receiver noise Floor (W) which accounts for thermal noise and non-idealities of the receiver
 
   243   //receiver noise Floor (W) which accounts for thermal noise and non-idealities of the receiver
 
   244   double noiseFloor = m_noiseFigure * Nt;
 
   244   double noiseFloor = m_noiseFigure * Nt;
 
   245   double noise = noiseFloor + noiseInterference;
 
   245   double noise = noiseFloor + noiseInterference;
 
   246   double snr = signal / noise; //linear scale
 
   246   double snr = signal / noise; //linear scale
 
   247   NS_LOG_DEBUG ("signal(W)= " << signal << ", noise(W)=" << noiseFloor << ", interference(W)=" << noiseInterference << ", snr(linear)=" << snr);
 
   247   NS_LOG_DEBUG ("bandwidth(MHz)=" << channelWidth << ", signal(W)= " << signal << ", noise(W)=" << noiseFloor << ", interference(W)=" << noiseInterference << ", snr(linear)=" << snr);
 
   248   return snr;
 
   248   return snr;
 
   249 }
 
   249 }
 
   250 
   250 
   251 double
 
   251 double
 
   252 InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event> event, NiChanges *ni) const
 
   252 InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event> event, NiChanges *ni) const
 
   265   ni->push_back (NiChange (event->GetEndTime (), 0));
 
   265   ni->push_back (NiChange (event->GetEndTime (), 0));
 
   266   return noiseInterference;
 
   266   return noiseInterference;
 
   267 }
 
   267 }
 
   268 
   268 
   269 double
 
   269 double
 
   270 InterferenceHelper::CalculateChunkSuccessRate (double snir, Time duration, WifiMode mode) const
 
   270 InterferenceHelper::CalculateChunkSuccessRate (double snir, Time duration, WifiMode mode, WifiTxVector txVector) const
 
   271 {
 
   271 {
 
   272   if (duration == NanoSeconds (0))
 
   272   if (duration == NanoSeconds (0))
 
   273     {
 
   273     {
 
   274       return 1.0;
 
   274       return 1.0;
 
   275     }
 
   275     }
 
   276   uint32_t rate = mode.GetPhyRate ();
 
   276   uint32_t rate = mode.GetPhyRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), 1);
 
   277   uint64_t nbits = (uint64_t)(rate * duration.GetSeconds ());
 
   277   uint64_t nbits = (uint64_t)(rate * duration.GetSeconds ());
 
   278   double csr = m_errorRateModel->GetChunkSuccessRate (mode, snir, (uint32_t)nbits);
 
   278   double csr = m_errorRateModel->GetChunkSuccessRate (mode, txVector, snir, (uint32_t)nbits);
 
   279   return csr;
 
   279   return csr;
 
   280 }
 
   280 }
 
   281 
   281 
   282 double
 
   282 double
 
   283 InterferenceHelper::CalculatePlcpPayloadPer (Ptr<const InterferenceHelper::Event> event, NiChanges *ni) const
 
   283 InterferenceHelper::CalculatePlcpPayloadPer (Ptr<const InterferenceHelper::Event> event, NiChanges *ni) const
 
   286   double psr = 1.0; /* Packet Success Rate */
 
   286   double psr = 1.0; /* Packet Success Rate */
 
   287   NiChanges::iterator j = ni->begin ();
 
   287   NiChanges::iterator j = ni->begin ();
 
   288   Time previous = (*j).GetTime ();
 
   288   Time previous = (*j).GetTime ();
 
   289   WifiMode payloadMode = event->GetPayloadMode ();
 
   289   WifiMode payloadMode = event->GetPayloadMode ();
 
   290   WifiPreamble preamble = event->GetPreambleType ();
 
   290   WifiPreamble preamble = event->GetPreambleType ();
 
   291   Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (payloadMode, preamble); //packet start time + preamble
 
   291   Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (event->GetTxVector (), preamble); //packet start time + preamble
 
   292   Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (payloadMode, preamble); //packet start time + preamble + L-SIG
 
   292   Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (event->GetTxVector (), preamble); //packet start time + preamble + L-SIG
 
   293   Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG
 
   293   Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble) + WifiPhy::GetPlcpVhtSigA1Duration (preamble) + WifiPhy::GetPlcpVhtSigA2Duration (preamble); //packet start time + preamble + L-SIG + HT-SIG or VHT-SIG-A (A1 + A2)
 
   294   Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble,event->GetTxVector ()); //packet start time + preamble + L-SIG + HT-SIG + HT Training
 
   294   Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble, event->GetTxVector ()) + WifiPhy::GetPlcpVhtSigBDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG or VHT-SIG-A (A1 + A2) + (V)HT Training + VHT-SIG-B
 
   295   double noiseInterferenceW = (*j).GetDelta ();
 
   295   double noiseInterferenceW = (*j).GetDelta ();
 
   296   double powerW = event->GetRxPowerW ();
 
   296   double powerW = event->GetRxPowerW ();
 
   297   j++;
 
   297   j++;
 
   298   while (ni->end () != j)
 
   298   while (ni->end () != j)
 
   299     {
 
   299     {
 
   303       //Case 1: Both previous and current point to the payload
 
   303       //Case 1: Both previous and current point to the payload
 
   304       if (previous >= plcpPayloadStart)
 
   304       if (previous >= plcpPayloadStart)
 
   305         {
 
   305         {
 
   306           psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   306           psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   307                                                           noiseInterferenceW,
 
   307                                                           noiseInterferenceW,
 
   308                                                           payloadMode),
 
   308                                                           event->GetTxVector ().GetChannelWidth ()),
 
   309                                             current - previous,
 
   309                                             current - previous,
 
   310                                             payloadMode);
 
   310                                             payloadMode, event->GetTxVector ());
 
   311 
   311 
   312           NS_LOG_DEBUG ("Both previous and current point to the payload: mode=" << payloadMode << ", psr=" << psr);
 
   312           NS_LOG_DEBUG ("Both previous and current point to the payload: mode=" << payloadMode << ", psr=" << psr);
 
   313         }
 
   313         }
 
   314       //Case 2: previous is before payload and current is in the payload
 
   314       //Case 2: previous is before payload and current is in the payload
 
   315       else if (current >= plcpPayloadStart)
 
   315       else if (current >= plcpPayloadStart)
 
   316         {
 
   316         {
 
   317           psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   317           psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   318                                                           noiseInterferenceW,
 
   318                                                           noiseInterferenceW,
 
   319                                                           payloadMode),
 
   319                                                           event->GetTxVector ().GetChannelWidth ()),
 
   320                                             current - plcpPayloadStart,
 
   320                                             current - plcpPayloadStart,
 
   321                                             payloadMode);
 
   321                                             payloadMode, event->GetTxVector ());
 
   322           NS_LOG_DEBUG ("previous is before payload and current is in the payload: mode=" << payloadMode << ", psr=" << psr);
 
   322           NS_LOG_DEBUG ("previous is before payload and current is in the payload: mode=" << payloadMode << ", psr=" << psr);
 
   323         }
 
   323         }
 
   324 
   324 
   325       noiseInterferenceW += (*j).GetDelta ();
 
   325       noiseInterferenceW += (*j).GetDelta ();
 
   326       previous = (*j).GetTime ();
 
   326       previous = (*j).GetTime ();
 
   342   WifiPreamble preamble = event->GetPreambleType ();
 
   342   WifiPreamble preamble = event->GetPreambleType ();
 
   343   WifiMode htHeaderMode;
 
   343   WifiMode htHeaderMode;
 
   344   if (preamble == WIFI_PREAMBLE_HT_MF)
 
   344   if (preamble == WIFI_PREAMBLE_HT_MF)
 
   345     {
 
   345     {
 
   346       //mode for PLCP header fields sent with HT modulation
 
   346       //mode for PLCP header fields sent with HT modulation
 
   347       htHeaderMode = WifiPhy::GetHTPlcpHeaderMode (payloadMode);
 
   347       htHeaderMode = WifiPhy::GetHtPlcpHeaderMode (payloadMode);
 
   348     }
 
   348     }
 
   349   WifiMode headerMode = WifiPhy::GetPlcpHeaderMode (payloadMode, preamble);
 
   349   else if (preamble == WIFI_PREAMBLE_VHT)
 
   350   Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (payloadMode, preamble); //packet start time + preamble
 
   350     {
 
   351   Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (payloadMode, preamble); //packet start time + preamble + L-SIG
 
   351       //mode for PLCP header fields sent with VHT modulation
 
   352   Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG
 
   352       htHeaderMode = WifiPhy::GetVhtPlcpHeaderMode (payloadMode);
 
   353   Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble, event->GetTxVector ()); //packet start time + preamble + L-SIG + HT-SIG + HT Training
 
   353     }
 
       
   354   WifiMode headerMode = WifiPhy::GetPlcpHeaderMode (payloadMode, preamble, event->GetTxVector ());
 
       
   355   Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (event->GetTxVector (), preamble); //packet start time + preamble
 
       
   356   Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (event->GetTxVector (), preamble); //packet start time + preamble + L-SIG
 
       
   357   Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble) + WifiPhy::GetPlcpVhtSigA1Duration (preamble) + WifiPhy::GetPlcpVhtSigA2Duration (preamble); //packet start time + preamble + L-SIG + HT-SIG or VHT-SIG-A (A1 + A2)
 
       
   358   Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble, event->GetTxVector ()) + WifiPhy::GetPlcpVhtSigBDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG or VHT-SIG-A (A1 + A2) + (V)HT Training + VHT-SIG-B
 
   354   double noiseInterferenceW = (*j).GetDelta ();
 
   359   double noiseInterferenceW = (*j).GetDelta ();
 
   355   double powerW = event->GetRxPowerW ();
 
   360   double powerW = event->GetRxPowerW ();
 
   356   j++;
 
   361   j++;
 
   357   while (ni->end () != j)
 
   362   while (ni->end () != j)
 
   358     {
 
   363     {
 
   363       if (previous >= plcpPayloadStart)
 
   368       if (previous >= plcpPayloadStart)
 
   364         {
 
   369         {
 
   365           psr *= 1;
 
   370           psr *= 1;
 
   366           NS_LOG_DEBUG ("Case 1 - previous and current after playload start: nothing to do");
 
   371           NS_LOG_DEBUG ("Case 1 - previous and current after playload start: nothing to do");
 
   367         }
 
   372         }
 
   368       //Case 2: previous is in HT-SIG or in HT training: Non HT will not enter here since it didn't enter in the last two and they are all the same for non HT
 
   373       //Case 2: previous is in (V)HT training or in VHT-SIG-B: Non (V)HT will not enter here since it didn't enter in the last two and they are all the same for non (V)HT
 
   369       else if (previous >= plcpHsigHeaderStart)
 
   374       else if (previous >= plcpHtTrainingSymbolsStart)
 
   370         {
 
   375         {
 
   371           NS_ASSERT ((preamble != WIFI_PREAMBLE_LONG) && (preamble != WIFI_PREAMBLE_SHORT));
 
   376           NS_ASSERT ((preamble != WIFI_PREAMBLE_LONG) && (preamble != WIFI_PREAMBLE_SHORT));
 
   372           //Case 2a: current after payload start
 
   377           //Case 2a: current after payload start
 
   373           if (current >= plcpPayloadStart)
 
   378           if (current >= plcpPayloadStart)
 
   374             {
 
   379             {
 
   375               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   380               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   376                                                               noiseInterferenceW,
 
   381                                                               noiseInterferenceW,
 
   377                                                               htHeaderMode),
 
   382                                                               event->GetTxVector ().GetChannelWidth ()),
 
   378                                                 plcpPayloadStart - previous,
 
   383                                                 plcpPayloadStart - previous,
 
   379                                                 htHeaderMode);
 
   384                                                 htHeaderMode, event->GetTxVector ());
 
   380 
   385 
   381               NS_LOG_DEBUG ("Case 2a - previous is in HT-SIG or in HT training and current after payload start: mode=" << htHeaderMode << ", psr=" << psr);
 
   386               NS_LOG_DEBUG ("Case 2a - previous is in (V)HT training or in VHT-SIG-B and current after payload start: mode=" << htHeaderMode << ", psr=" << psr);
 
   382             }
 
   387             }
 
   383           //Case 2b: current is in HT-SIG or in HT training
 
   388           //Case 2b: current is in (V)HT training or in VHT-SIG-B
 
   384           else
 
   389           else
 
   385             {
 
   390             {
 
   386               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   391               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   387                                                               noiseInterferenceW,
 
   392                                                               noiseInterferenceW,
 
   388                                                               htHeaderMode),
 
   393                                                               event->GetTxVector ().GetChannelWidth ()),
 
   389                                                 current - previous,
 
   394                                                 current - previous,
 
   390                                                 htHeaderMode);
 
   395                                                 htHeaderMode, event->GetTxVector ());
 
   391 
   396 
   392               NS_LOG_DEBUG ("Case 2b - previous is in HT-SIG or in HT training and current is in HT-SIG or in HT training: mode=" << htHeaderMode << ", psr=" << psr);
 
   397               NS_LOG_DEBUG ("Case 2b - previous is in (V)HT training or in VHT-SIG-B and current is in (V)HT training or in VHT-SIG-B: mode=" << htHeaderMode << ", psr=" << psr);
 
   393             }
 
   398             }
 
   394         }
 
   399         }
 
   395       //Case 3: previous in L-SIG: GF will not reach here because it will execute the previous if and exit
 
   400       //Case 3: previous is in HT-SIG or VHT-SIG-A: Non (V)HT will not enter here since it didn't enter in the last two and they are all the same for non (V)HT
 
   396       else if (previous >= plcpHeaderStart)
 
   401       else if (previous >= plcpHsigHeaderStart)
 
   397         {
 
   402         {
 
   398           NS_ASSERT (preamble != WIFI_PREAMBLE_HT_GF);
 
   403           NS_ASSERT ((preamble != WIFI_PREAMBLE_LONG) && (preamble != WIFI_PREAMBLE_SHORT));
 
   399           //Case 3a: current after payload start
 
   404           //Case 3a: current after payload start
 
   400           if (current >= plcpPayloadStart)
 
   405           if (current >= plcpPayloadStart)
 
   401             {
 
   406             {
 
   402               //Case 3ai: Non HT format (No HT-SIG or Training Symbols)
 
       
   403               if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT)
 
       
   404                 {
 
       
   405                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   406                                                                   noiseInterferenceW,
 
       
   407                                                                   headerMode),
 
       
   408                                                     plcpPayloadStart - previous,
 
       
   409                                                     headerMode);
 
       
   410 
       
   411                   NS_LOG_DEBUG ("Case 3ai - previous in L-SIG and current after payload start: mode=" << headerMode << ", psr=" << psr);
 
       
   412                 }
 
       
   413               //Case 3aii: HT mixed format
 
       
   414               else
 
       
   415                 {
 
       
   416                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   417                                                                   noiseInterferenceW,
 
       
   418                                                                   htHeaderMode),
 
       
   419                                                     plcpPayloadStart - plcpHsigHeaderStart,
 
       
   420                                                     htHeaderMode);
 
       
   421 
       
   422                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   423                                                                   noiseInterferenceW,
 
       
   424                                                                   headerMode),
 
       
   425                                                     plcpHsigHeaderStart - previous,
 
       
   426                                                     headerMode);
 
       
   427 
       
   428                   NS_LOG_DEBUG ("Case 3aii - previous in L-SIG and current after payload start: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
 
       
   429                 }
 
       
   430             }
 
       
   431           //Case 3b: current in HT-SIG or in HT training symbol. Non HT will not come here since it went in previous if or if the previous if is not true this will be not true
 
       
   432           else if (current >= plcpHsigHeaderStart)
 
       
   433             {
 
       
   434               NS_ASSERT ((preamble != WIFI_PREAMBLE_LONG) && (preamble != WIFI_PREAMBLE_SHORT));
 
       
   435 
       
   436               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   407               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   437                                                               noiseInterferenceW,
 
   408                                                               noiseInterferenceW,
 
   438                                                               htHeaderMode),
 
   409                                                               event->GetTxVector ().GetChannelWidth ()),
 
   439                                                 current - plcpHsigHeaderStart,
 
   410                                                 plcpPayloadStart - plcpHtTrainingSymbolsStart,
 
   440                                                 htHeaderMode);
 
   411                                                 htHeaderMode, event->GetTxVector ());
 
       
   412 
       
   413               //Case 3ai: VHT format
 
       
   414               if (preamble == WIFI_PREAMBLE_VHT)
 
       
   415                 {
 
       
   416                   //VHT-SIG-A is sent using legacy OFDM modulation
 
       
   417                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   418                                                                   noiseInterferenceW,
 
       
   419                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   420                                                     plcpHtTrainingSymbolsStart - previous,
 
       
   421                                                     headerMode, event->GetTxVector ());
 
       
   422 
       
   423                   NS_LOG_DEBUG ("Case 3ai - previous is in VHT-SIG-A and current after payload start: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
 
       
   424                 }
 
       
   425               //Case 3aii: HT mixed format of HT greenfield
 
       
   426               else
 
       
   427                 {
 
       
   428                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   429                                                                   noiseInterferenceW,
 
       
   430                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   431                                                     plcpHtTrainingSymbolsStart - previous,
 
       
   432                                                     htHeaderMode, event->GetTxVector ());
 
       
   433 
       
   434                   NS_LOG_DEBUG ("Case 3aii - previous is in HT-SIG and current after payload start: mode=" << htHeaderMode << ", psr=" << psr);
 
       
   435                 }
 
       
   436             }
 
       
   437           //Case 3b: current is in (V)HT training or in VHT-SIG-B
 
       
   438           else if (current >= plcpHtTrainingSymbolsStart)
 
       
   439             {
 
   441               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   440               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   442                                                               noiseInterferenceW,
 
   441                                                               noiseInterferenceW,
 
   443                                                               headerMode),
 
   442                                                               event->GetTxVector ().GetChannelWidth ()),
 
   444                                                 plcpHsigHeaderStart - previous,
 
   443                                                 current - plcpHtTrainingSymbolsStart,
 
   445                                                 headerMode);
 
   444                                                 htHeaderMode, event->GetTxVector ());
 
   446 
   445 
   447               NS_LOG_DEBUG ("Case 3b - previous in L-SIG and current in HT-SIG or in HT training symbol: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
 
   446               //Case 3bi: VHT format
 
   448             }
 
   447               if (preamble == WIFI_PREAMBLE_VHT)
 
   449           //Case 3c: current with previous in L-SIG
 
   448                 {
 
       
   449                   //VHT-SIG-A is sent using legacy OFDM modulation
 
       
   450                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   451                                                                   noiseInterferenceW,
 
       
   452                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   453                                                     plcpHtTrainingSymbolsStart - previous,
 
       
   454                                                     headerMode, event->GetTxVector ());
 
       
   455 
       
   456                   NS_LOG_DEBUG ("Case 3bi - previous is in VHT-SIG-A and current is in VHT training or in VHT-SIG-B: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
 
       
   457                 }
 
       
   458               //Case 3bii: HT mixed format of HT greenfield
 
       
   459               else
 
       
   460                 {
 
       
   461                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   462                                                                   noiseInterferenceW,
 
       
   463                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   464                                                     plcpHtTrainingSymbolsStart - previous,
 
       
   465                                                     htHeaderMode, event->GetTxVector ());
 
       
   466 
       
   467                   NS_LOG_DEBUG ("Case 3bii - previous is in HT-SIG and current is in HT training: mode=" << htHeaderMode << ", psr=" << psr);
 
       
   468                 }
 
       
   469             }
 
       
   470           //Case 3c: current with previous in HT-SIG or VHT-SIG-A
 
       
   471           else
 
       
   472             {
 
       
   473               //Case 3bi: VHT format
 
       
   474               if (preamble == WIFI_PREAMBLE_VHT)
 
       
   475                 {
 
       
   476                   //VHT-SIG-A is sent using legacy OFDM modulation
 
       
   477                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   478                                                                   noiseInterferenceW,
 
       
   479                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   480                                                     current - previous,
 
       
   481                                                     headerMode, event->GetTxVector ());
 
       
   482 
       
   483                   NS_LOG_DEBUG ("Case 3ci - previous with current in VHT-SIG-A: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
 
       
   484                 }
 
       
   485               //Case 3bii: HT mixed format of HT greenfield
 
       
   486               else
 
       
   487                 {
 
       
   488                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   489                                                                   noiseInterferenceW,
 
       
   490                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   491                                                     current - previous,
 
       
   492                                                     htHeaderMode, event->GetTxVector ());
 
       
   493 
       
   494                   NS_LOG_DEBUG ("Case 3cii - previous with current in HT-SIG: mode=" << htHeaderMode << ", psr=" << psr);
 
       
   495                 }
 
       
   496             }
 
       
   497         }
 
       
   498       //Case 4: previous in L-SIG: HT GF will not reach here because it will execute the previous if and exit
 
       
   499       else if (previous >= plcpHeaderStart)
 
       
   500         {
 
       
   501           NS_ASSERT (preamble != WIFI_PREAMBLE_HT_GF);
 
       
   502           //Case 4a: current after payload start
 
       
   503           if (current >= plcpPayloadStart)
 
       
   504             {
 
       
   505               //Case 4ai: Non (V)HT format
 
       
   506               if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT)
 
       
   507                 {
 
       
   508                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   509                                                                   noiseInterferenceW,
 
       
   510                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   511                                                     plcpPayloadStart - previous,
 
       
   512                                                     headerMode, event->GetTxVector ());
 
       
   513 
       
   514                   NS_LOG_DEBUG ("Case 4ai - previous in L-SIG and current after payload start: mode=" << headerMode << ", psr=" << psr);
 
       
   515                 }
 
       
   516               //Case 4aii: VHT format
 
       
   517               else if (preamble == WIFI_PREAMBLE_VHT)
 
       
   518                 {
 
       
   519                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   520                                                                   noiseInterferenceW,
 
       
   521                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   522                                                     plcpPayloadStart - plcpHtTrainingSymbolsStart,
 
       
   523                                                     htHeaderMode, event->GetTxVector ());
 
       
   524 
       
   525                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   526                                                                   noiseInterferenceW,
 
       
   527                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   528                                                     plcpHtTrainingSymbolsStart - previous,
 
       
   529                                                     headerMode, event->GetTxVector ());
 
       
   530 
       
   531                   NS_LOG_DEBUG ("Case 4aii - previous is in L-SIG and current after payload start: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
 
       
   532                 }
 
       
   533               //Case 4aiii: HT mixed format
 
       
   534               else
 
       
   535                 {
 
       
   536                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   537                                                                   noiseInterferenceW,
 
       
   538                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   539                                                     plcpPayloadStart - plcpHsigHeaderStart,
 
       
   540                                                     htHeaderMode, event->GetTxVector ());
 
       
   541 
       
   542                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   543                                                                   noiseInterferenceW,
 
       
   544                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   545                                                     plcpHsigHeaderStart - previous,
 
       
   546                                                     headerMode, event->GetTxVector ());
 
       
   547 
       
   548                   NS_LOG_DEBUG ("Case 4aiii - previous in L-SIG and current after payload start: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
 
       
   549                 }
 
       
   550             }
 
       
   551           //Case 4b: current is in (V)HT training or in VHT-SIG-B. Non (V)HT will not come here since it went in previous if or if the previous if is not true this will be not true
 
       
   552           else if (current >= plcpHtTrainingSymbolsStart)
 
       
   553             {
 
       
   554               NS_ASSERT ((preamble != WIFI_PREAMBLE_LONG) && (preamble != WIFI_PREAMBLE_SHORT));
 
       
   555 
       
   556               //Case 4bi: VHT format
 
       
   557               if (preamble == WIFI_PREAMBLE_VHT)
 
       
   558                 {
 
       
   559                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   560                                                                   noiseInterferenceW,
 
       
   561                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   562                                                     current - plcpHtTrainingSymbolsStart,
 
       
   563                                                     htHeaderMode, event->GetTxVector ());
 
       
   564 
       
   565                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   566                                                                   noiseInterferenceW,
 
       
   567                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   568                                                     plcpHtTrainingSymbolsStart - previous,
 
       
   569                                                     headerMode, event->GetTxVector ());
 
       
   570 
       
   571                   NS_LOG_DEBUG ("Case 4bi - previous is in L-SIG and current in VHT training or in VHT-SIG-B: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
 
       
   572                 }
 
       
   573               //Case 4bii: HT mixed format
 
       
   574               else
 
       
   575                 {
 
       
   576                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   577                                                                   noiseInterferenceW,
 
       
   578                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   579                                                     current - plcpHsigHeaderStart,
 
       
   580                                                     htHeaderMode, event->GetTxVector ());
 
       
   581 
       
   582                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   583                                                                   noiseInterferenceW,
 
       
   584                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   585                                                     plcpHsigHeaderStart - previous,
 
       
   586                                                     headerMode, event->GetTxVector ());
 
       
   587 
       
   588                   NS_LOG_DEBUG ("Case 4bii - previous in L-SIG and current in HT training: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
 
       
   589                 }
 
       
   590             }
 
       
   591           //Case 4c: current in HT-SIG or in VHT-SIG-A. Non (V)HT will not come here since it went in previous if or if the previous if is not true this will be not true
 
       
   592           else if (current >= plcpHsigHeaderStart)
 
       
   593             {
 
       
   594               NS_ASSERT ((preamble != WIFI_PREAMBLE_LONG) && (preamble != WIFI_PREAMBLE_SHORT));
 
       
   595 
       
   596               //Case 4ci: VHT format
 
       
   597               if (preamble == WIFI_PREAMBLE_VHT)
 
       
   598                 {
 
       
   599                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   600                                                                   noiseInterferenceW,
 
       
   601                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   602                                                     current - previous,
 
       
   603                                                     headerMode, event->GetTxVector ());
 
       
   604 
       
   605                   NS_LOG_DEBUG ("Case 4ci - previous is in L-SIG and current in VHT-SIG-A: mode=" << headerMode << ", psr=" << psr);
 
       
   606                 }
 
       
   607               //Case 4cii: HT mixed format
 
       
   608               else
 
       
   609                 {
 
       
   610                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   611                                                                   noiseInterferenceW,
 
       
   612                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   613                                                     current - plcpHsigHeaderStart,
 
       
   614                                                     htHeaderMode, event->GetTxVector ());
 
       
   615 
       
   616                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   617                                                                   noiseInterferenceW,
 
       
   618                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   619                                                     plcpHsigHeaderStart - previous,
 
       
   620                                                     headerMode, event->GetTxVector ());
 
       
   621 
       
   622                   NS_LOG_DEBUG ("Case 4cii - previous in L-SIG and current in HT-SIG: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
 
       
   623                 }
 
       
   624             }
 
       
   625           //Case 4d: current with previous in L-SIG
 
   450           else
 
   626           else
 
   451             {
 
   627             {
 
   452               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   628               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   453                                                               noiseInterferenceW,
 
   629                                                               noiseInterferenceW,
 
   454                                                               headerMode),
 
   630                                                               event->GetTxVector ().GetChannelWidth ()),
 
   455                                                 current - previous,
 
   631                                                 current - previous,
 
   456                                                 headerMode);
 
   632                                                 headerMode, event->GetTxVector ());
 
   457 
   633 
   458               NS_LOG_DEBUG ("Case 3c - current with previous in L-SIG: mode=" << headerMode << ", psr=" << psr);
 
   634               NS_LOG_DEBUG ("Case 3c - current with previous in L-SIG: mode=" << headerMode << ", psr=" << psr);
 
   459             }
 
   635             }
 
   460         }
 
   636         }
 
   461       //Case 4: previous is in the preamble works for all cases
 
   637       //Case 5: previous is in the preamble works for all cases
 
   462       else
 
   638       else
 
   463         {
 
   639         {
 
       
   640           //Case 5a: current after payload start
 
   464           if (current >= plcpPayloadStart)
 
   641           if (current >= plcpPayloadStart)
 
   465             {
 
   642             {
 
   466               //Non HT format (No HT-SIG or Training Symbols)
 
   643               //Case 5ai: Non HT format (No HT-SIG or Training Symbols)
 
   467               if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT)
 
   644               if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT)
 
   468                 {
 
   645                 {
 
   469                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   646                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   470                                                                   noiseInterferenceW,
 
   647                                                                   noiseInterferenceW,
 
   471                                                                   headerMode),
 
   648                                                                   event->GetTxVector ().GetChannelWidth ()),
 
   472                                                     plcpPayloadStart - plcpHeaderStart,
 
   649                                                     plcpPayloadStart - plcpHeaderStart,
 
   473                                                     headerMode);
 
   650                                                     headerMode, event->GetTxVector ());
 
   474 
   651 
   475                   NS_LOG_DEBUG ("Case 4a - previous is in the preamble: mode=" << headerMode << ", psr=" << psr);
 
   652                   NS_LOG_DEBUG ("Case 5a - previous is in the preamble and current is after payload start: mode=" << headerMode << ", psr=" << psr);
 
   476                 }
 
   653                 }
 
   477               //HT format
 
   654               //Case 5aii: VHT format
 
       
   655               else if (preamble == WIFI_PREAMBLE_VHT)
 
       
   656                 {
 
       
   657                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   658                                                                   noiseInterferenceW,
 
       
   659                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   660                                                     plcpPayloadStart - plcpHtTrainingSymbolsStart,
 
       
   661                                                     htHeaderMode, event->GetTxVector ());
 
       
   662 
       
   663                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   664                                                                   noiseInterferenceW,
 
       
   665                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   666                                                     plcpHtTrainingSymbolsStart - plcpHeaderStart,
 
       
   667                                                     headerMode, event->GetTxVector ());
 
       
   668 
       
   669                   NS_LOG_DEBUG ("Case 5aii - previous is in the preamble and current is after payload start: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
 
       
   670                 }
 
       
   671 
       
   672               //Case 5aiii: HT format
 
   478               else
 
   673               else
 
   479                 {
 
   674                 {
 
   480                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   675                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   481                                                                   noiseInterferenceW,
 
   676                                                                   noiseInterferenceW,
 
   482                                                                   htHeaderMode),
 
   677                                                                   event->GetTxVector ().GetChannelWidth ()),
 
   483                                                     plcpPayloadStart - plcpHsigHeaderStart,
 
   678                                                     plcpPayloadStart - plcpHsigHeaderStart,
 
   484                                                     htHeaderMode);
 
   679                                                     htHeaderMode, event->GetTxVector ());
 
   485 
   680 
   486                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   681                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   487                                                                   noiseInterferenceW,
 
   682                                                                   noiseInterferenceW,
 
   488                                                                   headerMode),
 
   683                                                                   event->GetTxVector ().GetChannelWidth ()),
 
   489                                                     plcpHsigHeaderStart - plcpHeaderStart, //HT GF: plcpHsigHeaderStart - plcpHeaderStart = 0
 
   684                                                     plcpHsigHeaderStart - plcpHeaderStart, //HT GF: plcpHsigHeaderStart - plcpHeaderStart = 0
 
   490                                                     headerMode);
 
   685                                                     headerMode, event->GetTxVector ());
 
   491 
   686 
   492                   NS_LOG_DEBUG ("Case 4a - previous is in the preamble: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
 
   687                   NS_LOG_DEBUG ("Case 4a - previous is in the preamble and current is after payload start: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
 
   493                 }
 
   688                 }
 
   494             }
 
   689             }
 
   495           //non HT will not come here
 
   690           //Case 5b: current is in (V)HT training or in VHT-SIG-B. Non (V)HT will not come here since it went in previous if or if the previous if is not true this will be not true
 
       
   691           else if (current >= plcpHtTrainingSymbolsStart)
 
       
   692             {
 
       
   693               NS_ASSERT ((preamble != WIFI_PREAMBLE_LONG) && (preamble != WIFI_PREAMBLE_SHORT));
 
       
   694 
       
   695               //Case 5bi: VHT format
 
       
   696               if (preamble == WIFI_PREAMBLE_VHT)
 
       
   697                 {
 
       
   698                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   699                                                                   noiseInterferenceW,
 
       
   700                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   701                                                     current - plcpHtTrainingSymbolsStart,
 
       
   702                                                     htHeaderMode, event->GetTxVector ());
 
       
   703 
       
   704                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   705                                                                   noiseInterferenceW,
 
       
   706                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   707                                                     plcpHtTrainingSymbolsStart - plcpHeaderStart,
 
       
   708                                                     headerMode, event->GetTxVector ());
 
       
   709 
       
   710                   NS_LOG_DEBUG ("Case 5bi - previous is in the preamble and current in VHT training or in VHT-SIG-B: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
 
       
   711                 }
 
       
   712               //Case 45ii: HT mixed format
 
       
   713               else
 
       
   714                 {
 
       
   715                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   716                                                                   noiseInterferenceW,
 
       
   717                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   718                                                     current - plcpHsigHeaderStart,
 
       
   719                                                     htHeaderMode, event->GetTxVector ());
 
       
   720 
       
   721                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   722                                                                   noiseInterferenceW,
 
       
   723                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   724                                                     plcpHsigHeaderStart - plcpHeaderStart,
 
       
   725                                                     headerMode, event->GetTxVector ());
 
       
   726 
       
   727                   NS_LOG_DEBUG ("Case 5bii - previous is in the preamble and current in HT training: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
 
       
   728                 }
 
       
   729             }
 
       
   730           //Case 5c: current in HT-SIG or in VHT-SIG-A. Non (V)HT will not come here since it went in previous if or if the previous if is not true this will be not true
 
   496           else if (current >= plcpHsigHeaderStart)
 
   731           else if (current >= plcpHsigHeaderStart)
 
   497             {
 
   732             {
 
   498               NS_ASSERT ((preamble != WIFI_PREAMBLE_LONG) && (preamble != WIFI_PREAMBLE_SHORT));
 
   733               NS_ASSERT ((preamble != WIFI_PREAMBLE_LONG) && (preamble != WIFI_PREAMBLE_SHORT));
 
       
   734 
       
   735               //Case 5ci: VHT format
 
       
   736               if (preamble == WIFI_PREAMBLE_VHT)
 
       
   737                 {
 
       
   738                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   739                                                                   noiseInterferenceW,
 
       
   740                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   741                                                     current - plcpHeaderStart,
 
       
   742                                                     headerMode, event->GetTxVector ());
 
       
   743 
       
   744                   NS_LOG_DEBUG ("Case 5ci - previous is in preamble and current in VHT-SIG-A: mode=" << headerMode << ", psr=" << psr);
 
       
   745                 }
 
       
   746               //Case 5cii: HT mixed format
 
       
   747               else
 
       
   748                 {
 
       
   749                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   750                                                                   noiseInterferenceW,
 
       
   751                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   752                                                     current - plcpHsigHeaderStart,
 
       
   753                                                     htHeaderMode, event->GetTxVector ());
 
       
   754 
       
   755                   psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   756                                                                   noiseInterferenceW,
 
       
   757                                                                   event->GetTxVector ().GetChannelWidth ()),
 
       
   758                                                     plcpHsigHeaderStart - plcpHeaderStart, //HT GF: plcpHsigHeaderStart - plcpHeaderStart = 0
 
       
   759                                                     headerMode, event->GetTxVector ());
 
       
   760 
       
   761                   NS_LOG_DEBUG ("Case 5cii - previous in preamble and current in HT-SIG: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
 
       
   762                 }
 
       
   763             }
 
       
   764           //Case 5d: current is in L-SIG. HT GF will not come here
 
       
   765           else if (current >= plcpHeaderStart)
 
       
   766             {
 
       
   767               NS_ASSERT (preamble != WIFI_PREAMBLE_HT_GF);
 
   499 
   768 
   500               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   769               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
   501                                                               noiseInterferenceW,
 
   770                                                               noiseInterferenceW,
 
   502                                                               htHeaderMode),
 
   771                                                               event->GetTxVector ().GetChannelWidth ()),
 
   503                                                 current - plcpHsigHeaderStart,
 
       
   504                                                 htHeaderMode);
 
       
   505 
       
   506               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   507                                                               noiseInterferenceW,
 
       
   508                                                               headerMode),
 
       
   509                                                 plcpHsigHeaderStart - plcpHeaderStart, //HT GF: plcpHsigHeaderStart - plcpHeaderStart = 0
 
       
   510                                                 headerMode);
 
       
   511 
       
   512               NS_LOG_DEBUG ("Case 4b - previous is in the preamble: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
 
       
   513             }
 
       
   514           //GF will not come here
 
       
   515           else if (current >= plcpHeaderStart)
 
       
   516             {
 
       
   517               NS_ASSERT (preamble != WIFI_PREAMBLE_HT_GF);
 
       
   518 
       
   519               psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
 
       
   520                                                               noiseInterferenceW,
 
       
   521                                                               headerMode),
 
       
   522                                                 current - plcpHeaderStart,
 
   772                                                 current - plcpHeaderStart,
 
   523                                                 headerMode);
 
   773                                                 headerMode, event->GetTxVector ());
 
   524 
   774 
   525               NS_LOG_DEBUG ("Case 4c - previous is in the preamble: mode=" << headerMode << ", psr=" << psr);
 
   775               NS_LOG_DEBUG ("Case 5d - previous is in the preamble and current is in L-SIG: mode=" << headerMode << ", psr=" << psr);
 
   526             }
 
   776             }
 
   527         }
 
   777         }
 
   528 
   778 
   529       noiseInterferenceW += (*j).GetDelta ();
 
   779       noiseInterferenceW += (*j).GetDelta ();
 
   530       previous = (*j).GetTime ();
 
   780       previous = (*j).GetTime ();
 
   540 {
 
   790 {
 
   541   NiChanges ni;
 
   791   NiChanges ni;
 
   542   double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni);
 
   792   double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni);
 
   543   double snr = CalculateSnr (event->GetRxPowerW (),
 
   793   double snr = CalculateSnr (event->GetRxPowerW (),
 
   544                              noiseInterferenceW,
 
   794                              noiseInterferenceW,
 
   545                              event->GetPayloadMode ());
 
   795                              event->GetTxVector ().GetChannelWidth ());
 
   546 
   796 
   547   /* calculate the SNIR at the start of the packet and accumulate
 
   797   /* calculate the SNIR at the start of the packet and accumulate
 
   548    * all SNIR changes in the snir vector.
 
   798    * all SNIR changes in the snir vector.
 
   549    */
 
   799    */
 
   550   double per = CalculatePlcpPayloadPer (event, &ni);
 
   800   double per = CalculatePlcpPayloadPer (event, &ni);
 
   560 {
 
   810 {
 
   561   NiChanges ni;
 
   811   NiChanges ni;
 
   562   double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni);
 
   812   double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni);
 
   563   double snr = CalculateSnr (event->GetRxPowerW (),
 
   813   double snr = CalculateSnr (event->GetRxPowerW (),
 
   564                              noiseInterferenceW,
 
   814                              noiseInterferenceW,
 
   565                              WifiPhy::GetPlcpHeaderMode (event->GetPayloadMode (), event->GetPreambleType ()));
 
   815                              event->GetTxVector ().GetChannelWidth ());
 
   566 
   816 
   567   /* calculate the SNIR at the start of the plcp header and accumulate
 
   817   /* calculate the SNIR at the start of the plcp header and accumulate
 
   568    * all SNIR changes in the snir vector.
 
   818    * all SNIR changes in the snir vector.
 
   569    */
 
   819    */
 
   570   double per = CalculatePlcpHeaderPer (event, &ni);
 
   820   double per = CalculatePlcpHeaderPer (event, &ni);
ns-3.24