00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "yans-error-rate-model.h"
00021 #include "wifi-phy.h"
00022 #include "ns3/log.h"
00023
00024 NS_LOG_COMPONENT_DEFINE ("YansErrorRateModel");
00025
00026 namespace ns3 {
00027
00028 NS_OBJECT_ENSURE_REGISTERED (YansErrorRateModel);
00029
00030 TypeId
00031 YansErrorRateModel::GetTypeId (void)
00032 {
00033 static TypeId tid = TypeId ("ns3::YansErrorRateModel")
00034 .SetParent<ErrorRateModel> ()
00035 .AddConstructor<YansErrorRateModel> ()
00036 ;
00037 return tid;
00038 }
00039
00040 YansErrorRateModel::YansErrorRateModel ()
00041 {}
00042
00043 double
00044 YansErrorRateModel::Log2 (double val) const
00045 {
00046 return log(val) / log(2.0);
00047 }
00048 double
00049 YansErrorRateModel::GetBpskBer (double snr, uint32_t signalSpread, uint32_t phyRate) const
00050 {
00051 double EbNo = snr * signalSpread / phyRate;
00052 double z = sqrt(EbNo);
00053 double ber = 0.5 * erfc(z);
00054 NS_LOG_INFO ("bpsk snr="<<snr<<" ber="<<ber);
00055 return ber;
00056 }
00057 double
00058 YansErrorRateModel::GetQamBer (double snr, unsigned int m, uint32_t signalSpread, uint32_t phyRate) const
00059 {
00060 double EbNo = snr * signalSpread / phyRate;
00061 double z = sqrt ((1.5 * Log2 (m) * EbNo) / (m - 1.0));
00062 double z1 = ((1.0 - 1.0 / sqrt (m)) * erfc (z)) ;
00063 double z2 = 1 - pow ((1-z1), 2.0);
00064 double ber = z2 / Log2 (m);
00065 NS_LOG_INFO ("Qam m="<<m<<" rate=" << phyRate << " snr="<<snr<<" ber="<<ber);
00066 return ber;
00067 }
00068 uint32_t
00069 YansErrorRateModel::Factorial (uint32_t k) const
00070 {
00071 uint32_t fact = 1;
00072 while (k > 0)
00073 {
00074 fact *= k;
00075 k--;
00076 }
00077 return fact;
00078 }
00079 double
00080 YansErrorRateModel::Binomial (uint32_t k, double p, uint32_t n) const
00081 {
00082 double retval = Factorial (n) / (Factorial (k) * Factorial (n-k)) * pow (p, k) * pow (1-p, n-k);
00083 return retval;
00084 }
00085 double
00086 YansErrorRateModel::CalculatePdOdd (double ber, unsigned int d) const
00087 {
00088 NS_ASSERT ((d % 2) == 1);
00089 unsigned int dstart = (d + 1) / 2;
00090 unsigned int dend = d;
00091 double pd = 0;
00092
00093 for (unsigned int i = dstart; i < dend; i++)
00094 {
00095 pd += Binomial (i, ber, d);
00096 }
00097 return pd;
00098 }
00099 double
00100 YansErrorRateModel::CalculatePdEven (double ber, unsigned int d) const
00101 {
00102 NS_ASSERT ((d % 2) == 0);
00103 unsigned int dstart = d / 2 + 1;
00104 unsigned int dend = d;
00105 double pd = 0;
00106
00107 for (unsigned int i = dstart; i < dend; i++)
00108 {
00109 pd += Binomial (i, ber, d);
00110 }
00111 pd += 0.5 * Binomial (d / 2, ber, d);
00112
00113 return pd;
00114 }
00115
00116 double
00117 YansErrorRateModel::CalculatePd (double ber, unsigned int d) const
00118 {
00119 double pd;
00120 if ((d % 2) == 0)
00121 {
00122 pd = CalculatePdEven (ber, d);
00123 }
00124 else
00125 {
00126 pd = CalculatePdOdd (ber, d);
00127 }
00128 return pd;
00129 }
00130
00131 double
00132 YansErrorRateModel::GetFecBpskBer (double snr, double nbits,
00133 uint32_t signalSpread, uint32_t phyRate,
00134 uint32_t dFree, uint32_t adFree) const
00135 {
00136 double ber = GetBpskBer (snr, signalSpread, phyRate);
00137 if (ber == 0.0)
00138 {
00139 return 1.0;
00140 }
00141 double pd = CalculatePd (ber, dFree);
00142 double pmu = adFree * pd;
00143 pmu = std::min (pmu, 1.0);
00144 double pms = pow (1 - pmu, nbits);
00145 return pms;
00146 }
00147
00148 double
00149 YansErrorRateModel::GetFecQamBer (double snr, uint32_t nbits,
00150 uint32_t signalSpread,
00151 uint32_t phyRate,
00152 uint32_t m, uint32_t dFree,
00153 uint32_t adFree, uint32_t adFreePlusOne) const
00154 {
00155 double ber = GetQamBer (snr, m, signalSpread, phyRate);
00156 if (ber == 0.0)
00157 {
00158 return 1.0;
00159 }
00160
00161 double pd = CalculatePd (ber, dFree);
00162 double pmu = adFree * pd;
00163
00164 pd = CalculatePd (ber, dFree + 1);
00165 pmu += adFreePlusOne * pd;
00166 pmu = std::min (pmu, 1.0);
00167 double pms = pow (1 - pmu, nbits);
00168 return pms;
00169 }
00170
00171 double
00172 YansErrorRateModel::GetChunkSuccessRate (WifiMode mode, double snr, uint32_t nbits) const
00173 {
00174 if (mode == WifiPhy::Get6mba ())
00175 {
00176 return GetFecBpskBer (snr,
00177 nbits,
00178 mode.GetBandwidth (),
00179 mode.GetPhyRate (),
00180 10,
00181 11
00182 );
00183 }
00184 else if (mode == WifiPhy::Get9mba ())
00185 {
00186 return GetFecBpskBer (snr,
00187 nbits,
00188 mode.GetBandwidth (),
00189 mode.GetPhyRate (),
00190 5,
00191 8
00192 );
00193 }
00194 else if (mode == WifiPhy::Get12mba ())
00195 {
00196 return GetFecQamBer (snr,
00197 nbits,
00198 mode.GetBandwidth (),
00199 mode.GetPhyRate (),
00200 4,
00201 10,
00202 11,
00203 0
00204 );
00205 }
00206 else if (mode == WifiPhy::Get18mba ())
00207 {
00208 return GetFecQamBer (snr,
00209 nbits,
00210 mode.GetBandwidth (),
00211 mode.GetPhyRate (),
00212 4,
00213 5,
00214 8,
00215 31
00216 );
00217 }
00218 else if (mode == WifiPhy::Get24mba ())
00219 {
00220 return GetFecQamBer (snr,
00221 nbits,
00222 mode.GetBandwidth (),
00223 mode.GetPhyRate (),
00224 16,
00225 10,
00226 11,
00227 0
00228 );
00229 }
00230 else if (mode == WifiPhy::Get36mba ())
00231 {
00232 return GetFecQamBer (snr,
00233 nbits,
00234 mode.GetBandwidth (),
00235 mode.GetPhyRate (),
00236 16,
00237 5,
00238 8,
00239 31
00240 );
00241 }
00242 else if (mode == WifiPhy::Get48mba ())
00243 {
00244 return GetFecQamBer (snr,
00245 nbits,
00246 mode.GetBandwidth (),
00247 mode.GetPhyRate (),
00248 64,
00249 6,
00250 1,
00251 16
00252 );
00253 }
00254 else if (mode == WifiPhy::Get54mba ())
00255 {
00256 return GetFecQamBer (snr,
00257 nbits,
00258 mode.GetBandwidth (),
00259 mode.GetPhyRate (),
00260 64,
00261 5,
00262 8,
00263 31
00264 );
00265 }
00266 return 0;
00267 }
00268
00269 }