Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (payloadMode, preamble); //packet start time+ preamble

  Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (payloadMode, preamble); //packet start time + preamble

  Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (payloadMode, preamble);//packet start time+ preamble+L SIG

  Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (payloadMode, preamble); //packet start time+ preamble + L-SIG

  Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble);//packet start time+ preamble+L SIG+HT SIG

  Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble); //packet start time+ preamble + L-SIG + HT-SIG

  Time plcpPayloadStart =plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble,event->GetTxVector()); //packet start time+ preamble+L SIG+HT SIG+Training

  Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble, event->GetTxVector()); //packet start time + preamble + L-SIG + HT-SIG + Training

    j++;

  j++;

      //Case 1: Both prev and curr point to the payload

      //Case 1: Both previous and curr point to the payload

      else if (previous >= plcpHtTrainingSymbolsStart)

      else

  WifiMode MfHeaderMode ;

  WifiMode htHeaderMode ;

      MfHeaderMode = WifiPhy::GetMFPlcpHeaderMode (payloadMode, preamble); //return L-SIG mode

      //mode for HT modulation

      htHeaderMode = WifiPhy::GetHTPlcpHeaderMode (payloadMode, preamble);

  Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (payloadMode, preamble); // packet start time + preamble

  Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (payloadMode, preamble); //packet start time + preamble

  Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (payloadMode, preamble); // packet start time + preamble+L SIG

  Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (payloadMode, preamble); //packet start time + preamble + L-SIG

  Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble); // packet start time + preamble + L SIG + HT SIG

  Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG

  Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble, event->GetTxVector()); // packet start time + preamble + L SIG + HT SIG + Training

  Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble, event->GetTxVector()); //packet start time + preamble + L-SIG + HT-SIG + Training

    j++;

  j++;

      //Case 1: previous is in HT-SIG: Non HT will not enter here since it didn't enter in the last two and they are all the same for non HT

      //Case 1: previous and current after playload start: nothing to do

      if (previous >= plcpHsigHeaderStart)

      if (previous >= plcpPayloadStart)

          //Case 1a: cuurent after payload start

          j++;

          continue;

        }

      //Case 2: previous is in HT-SIG: non HT will not enter here since it didn't enter in the last two and they are all the same for non HT

      else if (previous >= plcpHsigHeaderStart)

        {

          NS_ASSERT ((preamble != WIFI_PREAMBLE_LONG) && (preamble != WIFI_PREAMBLE_SHORT));

          //Case 2a: current after payload start

                                                                headerMode),

                                                                htHeaderMode),

                                                  plcpPayloadStart - previous,

                                                  htHeaderMode);

            }

          //Case 2b: current is with previous in HT-SIG or current is after HT training symbols start

          else

            {

                psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                                noiseInterferenceW,

                                                                htHeaderMode),

                                                  headerMode);

                                                  htHeaderMode);

      // Case 2: previous in L-SIG: GF will not reach here because it will execute the previous if and exit

      //Case 3: previous in L-SIG: GF will not reach here because it will execute the previous if and exit

          // Case 2a: current after payload start

          NS_ASSERT (preamble != WIFI_PREAMBLE_HT_GF);

          //Case 3a: current after payload start

              // Case 2ai: Non HT format (No HT-SIG or Training Symbols)

              //Case 3ai: Non HT format (No HT-SIG or Training Symbols)

              if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) //plcpHtTrainingSymbolsStart==plcpHeaderStart)

              if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT)

                                                              noiseInterferenceW,

                                                                    noiseInterferenceW,

                                                              headerMode),

                                                                    htHeaderMode),

                                                      plcpHtTrainingSymbolsStart - plcpHsigHeaderStart,

                                                      plcpPayloadStart - plcpHsigHeaderStart,

                                                      headerMode);

                                                      htHeaderMode);

                                                                    MfHeaderMode),

                                                                    headerMode),

                                                      MfHeaderMode);

                                                      headerMode);

          // Case 2b: current in HT training symbol. non HT will not come here since it went in previous if or if the previous ifis not true this will be not true

          //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

          else if (current >= plcpHtTrainingSymbolsStart)

             {

                psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                              noiseInterferenceW,

                                                              headerMode),

                                                  plcpHtTrainingSymbolsStart - plcpHsigHeaderStart,

                                                  headerMode);

                psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                                noiseInterferenceW,

                                                                MfHeaderMode),

                                                   plcpHsigHeaderStart - previous,

                                                   MfHeaderMode);

              }

          // Case 2c: current in H sig. non HT will not come here since it went in previous if or if the previous ifis not true this will be not true

                                                  current - plcpHsigHeaderStart,

                                                  current - previous,

                 psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

            }

                                                                 noiseInterferenceW,

        }

                                                                 MfHeaderMode),

      //Case 4: previous is in the preamble works for all cases

                                                   plcpHsigHeaderStart - previous,

      else

                                                   MfHeaderMode);

        {

          if (current >= plcpPayloadStart)

             }

         // Case 2d: Current with prev in L SIG

         else 

              // Case 4di: Non HT format (No HT-SIG or Training Symbols)

              //Non HT format (No HT-SIG or Training Symbols)

              if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) //plcpHtTrainingSymbolsStart==plcpHeaderStart)

              if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT)

                                                      current - previous,

                                                      plcpPayloadStart - plcpHeaderStart,

                {

              //HT format

                    psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

              {

                                                               noiseInterferenceW,

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                               MfHeaderMode),

                                                                  noiseInterferenceW,

                                                      current - previous,

                                                                  htHeaderMode),

                                                      MfHeaderMode);

                                                    plcpPayloadStart - plcpHsigHeaderStart,

                }

                                                    htHeaderMode);

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

                                                                  noiseInterferenceW,

                                                                  headerMode),

                                                    plcpHsigHeaderStart - plcpHeaderStart, //HT GF: plcpHsigHeaderStart - plcpHeaderStart = 0

                                                    headerMode);

              }

        }

          //non HT will not come here

      // Case 3: previous is in the preamble works for all cases

          else if (current >= plcpHsigHeaderStart)

      else

             {

        {

                 NS_ASSERT ((preamble != WIFI_PREAMBLE_LONG) && (preamble != WIFI_PREAMBLE_SHORT));

          if (current >= plcpPayloadStart)

            {

                 psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,

              // Non HT format (No HT-SIG or Training Symbols)

                                                                 noiseInterferenceW,

              if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT)

                                                                 htHeaderMode),

                                                   current - plcpHsigHeaderStart,

                                                   htHeaderMode);

                                                   plcpPayloadStart - plcpHeaderStart,

                                                   plcpHsigHeaderStart - plcpHeaderStart, //HT GF: plcpHsigHeaderStart - plcpHeaderStart = 0

              else

             }

              // Greenfield or Mixed format

          //GF will not come here

          else if (current >= plcpHeaderStart)

            {

                NS_ASSERT(preamble != WIFI_PREAMBLE_HT_GF);

                                                  plcpHtTrainingSymbolsStart - plcpHsigHeaderStart,

                                                  current - plcpHeaderStart,

WifiPhy::GetMFPlcpHeaderMode (WifiMode payloadMode, WifiPreamble preamble)

WifiPhy::GetHTPlcpHeaderMode (WifiMode payloadMode, WifiPreamble preamble)

       case 20000000:

         case 20000000:

          return WifiPhy::GetOfdmRate6_5MbpsBW20MHz ();

        case 40000000:

           return WifiPhy::GetOfdmRate13_5MbpsBW40MHz ();

        default:

      }

         case 40000000:

            return WifiPhy::GetOfdmRate13_5MbpsBW40MHz ();

         default:

            return WifiPhy::GetOfdmRate6_5MbpsBW20MHz ();

       }

               // HT-SIG

               //HT-SIG

               // no HT-SIG for non HT

               //no HT-SIG for non HT

    //Added by Ghada to support 11n

    case WIFI_MOD_CLASS_HT:

      {  //return the HT-SIG

         // IEEE Std 802.11n, 20.3.23

         switch (preamble)

           {

            case WIFI_PREAMBLE_HT_MF:

                switch (payloadMode.GetBandwidth ())

                  {

                   case 20000000:

                      return WifiPhy::GetOfdmRate13MbpsBW20MHz ();

                   case 40000000:

                      return WifiPhy::GetOfdmRate27MbpsBW40MHz ();

                   default:

                      return WifiPhy::GetOfdmRate13MbpsBW20MHz ();

                  }

            case WIFI_PREAMBLE_HT_GF:

                  switch (payloadMode.GetBandwidth ())

                  {

                   case 20000000:

                      return WifiPhy::GetOfdmRate13MbpsBW20MHz ();

                   case 40000000:

                      return WifiPhy::GetOfdmRate27MbpsBW40MHz ();

                   default:

                      return WifiPhy::GetOfdmRate13MbpsBW20MHz ();

                  }

             default:

                return WifiPhy::GetOfdmRate6Mbps ();

          }

      }

   * \return the WifiMode used for the transmission of the HT-SIG in Mixed Format and greenfield format PLCP header 

   * \return the WifiMode used for the transmission of the HT-SIG and HT training in Mixed Format and greenfield format PLCP header

  static WifiMode GetMFPlcpHeaderMode (WifiMode payloadMode, WifiPreamble preamble);

  static WifiMode GetHTPlcpHeaderMode (WifiMode payloadMode, WifiPreamble preamble);

  /** 

  /**