A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
snr-to-block-error-rate-manager.cc
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2007,2008, 2009 INRIA, UDcast
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Mohamed Amine Ismail <amine.ismail@sophia.inria.fr>
19  * <amine.ismail@udcast.com>
20  */
21 
22 #include <cstring>
23 #include "ns3/snr-to-block-error-rate-manager.h"
24 #include "ns3/snr-to-block-error-rate-record.h"
25 #include "default-traces.h"
26 #include "ns3/log.h"
27 #include <fstream>
28 
29 NS_LOG_COMPONENT_DEFINE ("SNRToBlockErrorRateManager");
30 
31 namespace ns3 {
32 
33 SNRToBlockErrorRateManager::SNRToBlockErrorRateManager (void)
34 {
35 
36  for (int i = 0; i < 7; i++)
37  {
38  m_recordModulation[i] = new std::vector<SNRToBlockErrorRateRecord*> ();
39  }
40  m_activateLoss = false;
41  std::strcpy (m_traceFilePath,"DefaultTraces");
42 }
43 
44 SNRToBlockErrorRateManager::~SNRToBlockErrorRateManager (void)
45 {
46  ClearRecords ();
47  for (int i = 0; i < 7; i++)
48  {
49  delete m_recordModulation[i];
50  }
51 }
52 
53 void
54 SNRToBlockErrorRateManager::ClearRecords (void)
55 {
56  for (int i = 0; i < 7; i++)
57  {
58 
59  for (std::vector<SNRToBlockErrorRateRecord*>::iterator iter = m_recordModulation[i]->begin (); iter
60  != m_recordModulation[i]->end (); ++iter)
61  {
62  if (*iter)
63  {
64  delete (*iter);
65  (*iter) = 0;
66  }
67  }
68  m_recordModulation[i]->clear ();
69  }
70 }
71 
72 void
73 SNRToBlockErrorRateManager::ActivateLoss (bool loss)
74 {
75  m_activateLoss = loss;
76 }
77 
78 void
79 SNRToBlockErrorRateManager::LoadTraces (void)
80 {
81  std::ifstream m_ifTraceFile;
82  ClearRecords ();
83  double snrValue, bitErrorRate, burstErrorRate, sigma2, I1, I2;
84 
85  for (int i = 0; i < 7; i++)
86  {
87  char traceFile[1024];
88  sprintf (traceFile, "%s/modulation%d.txt", m_traceFilePath, i);
89 
90  m_ifTraceFile.open (traceFile, std::ifstream::in);
91  if (m_ifTraceFile.good () == false)
92  {
93  NS_LOG_INFO ("Unable to load " << traceFile << "!! Loading default traces...");
94  LoadDefaultTraces ();
95  return;
96  }
97  while (m_ifTraceFile.good ())
98  {
99  m_ifTraceFile >> snrValue >> bitErrorRate >> burstErrorRate >> sigma2 >> I1 >> I2;
100  SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
101  bitErrorRate,
102  burstErrorRate,
103  sigma2,
104  I1,
105  I2);
106  m_recordModulation[i]->push_back (record);
107 
108  }
109  m_ifTraceFile.close ();
110  }
111  m_activateLoss = true;
112 }
113 
114 void
115 SNRToBlockErrorRateManager::LoadDefaultTraces (void)
116 {
117  double snrValue, bitErrorRate, burstErrorRate, sigma2, I1, I2;
118  ClearRecords ();
119  for (unsigned int j = 0; j < sizeof(modulation0[0]) / sizeof(double); j++)
120  {
121  snrValue = modulation0[0][j];
122  bitErrorRate = modulation0[1][j];
123  burstErrorRate = modulation0[2][j];
124  sigma2 = modulation0[3][j];
125  I1 = modulation0[4][j];
126  I2 = modulation0[5][j];
127  SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
128  bitErrorRate,
129  burstErrorRate,
130  sigma2,
131  I1,
132  I2);
133  m_recordModulation[0]->push_back (record);
134  }
135  for (unsigned int j = 0; j < sizeof(modulation1[0]) / sizeof(double); j++)
136  {
137  snrValue = modulation1[0][j];
138  bitErrorRate = modulation1[1][j];
139  burstErrorRate = modulation1[2][j];
140  sigma2 = modulation1[3][j];
141  I1 = modulation1[4][j];
142  I2 = modulation1[5][j];
143  SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
144  bitErrorRate,
145  burstErrorRate,
146  sigma2,
147  I1,
148  I2);
149  m_recordModulation[1]->push_back (record);
150  }
151  for (unsigned int j = 0; j < sizeof(modulation2[0]) / sizeof(double); j++)
152  {
153  snrValue = modulation2[0][j];
154  bitErrorRate = modulation2[1][j];
155  burstErrorRate = modulation2[2][j];
156  sigma2 = modulation2[3][j];
157  I1 = modulation2[4][j];
158  I2 = modulation2[5][j];
159  SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
160  bitErrorRate,
161  burstErrorRate,
162  sigma2,
163  I1,
164  I2);
165  m_recordModulation[2]->push_back (record);
166  }
167  for (unsigned int j = 0; j < sizeof(modulation3[0]) / sizeof(double); j++)
168  {
169  snrValue = modulation3[0][j];
170  bitErrorRate = modulation3[1][j];
171  burstErrorRate = modulation3[2][j];
172  sigma2 = modulation3[3][j];
173  I1 = modulation3[4][j];
174  I2 = modulation3[5][j];
175  SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
176  bitErrorRate,
177  burstErrorRate,
178  sigma2,
179  I1,
180  I2);
181  m_recordModulation[3]->push_back (record);
182  }
183  for (unsigned int j = 0; j < sizeof(modulation4[0]) / sizeof(double); j++)
184  {
185  snrValue = modulation4[0][j];
186  bitErrorRate = modulation4[1][j];
187  burstErrorRate = modulation4[2][j];
188  sigma2 = modulation4[3][j];
189  I1 = modulation4[4][j];
190  I2 = modulation4[5][j];
191  SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
192  bitErrorRate,
193  burstErrorRate,
194  sigma2,
195  I1,
196  I2);
197  m_recordModulation[4]->push_back (record);
198  }
199  for (unsigned int j = 0; j < sizeof(modulation5[0]) / sizeof(double); j++)
200  {
201  snrValue = modulation5[0][j];
202  bitErrorRate = modulation5[1][j];
203  burstErrorRate = modulation5[2][j];
204  sigma2 = modulation5[3][j];
205  I1 = modulation5[4][j];
206  I2 = modulation5[5][j];
207  SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
208  bitErrorRate,
209  burstErrorRate,
210  sigma2,
211  I1,
212  I2);
213  m_recordModulation[5]->push_back (record);
214  }
215  for (unsigned int j = 0; j < sizeof(modulation6[0]) / sizeof(double); j++)
216  {
217  snrValue = modulation6[0][j];
218  bitErrorRate = modulation6[1][j];
219  burstErrorRate = modulation6[2][j];
220  sigma2 = modulation6[3][j];
221  I1 = modulation6[4][j];
222  I2 = modulation6[5][j];
223  SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
224  bitErrorRate,
225  burstErrorRate,
226  sigma2,
227  I1,
228  I2);
229  m_recordModulation[6]->push_back (record);
230  }
231  m_activateLoss = true;
232 }
233 
234 void
235 SNRToBlockErrorRateManager::ReLoadTraces (void)
236 {
237  double snrValue, bitErrorRate, burstErrorRate, sigma2, I1, I2;
238 
239  ClearRecords ();
240 
241  std::ifstream m_ifTraceFile;
242 
243  for (int i = 0; i < 7; i++)
244  {
245  char traceFile[1024];
246  sprintf (traceFile, "%s/Modulation%d.txt", m_traceFilePath, i);
247 
248  m_ifTraceFile.open (traceFile, std::ifstream::in);
249  if (m_ifTraceFile.good () == false)
250  {
251  NS_LOG_INFO ("Unable to load " << traceFile << "!!Loading default traces...");
252  LoadDefaultTraces ();
253  return;
254  }
255  while (m_ifTraceFile.good ())
256  {
257  m_ifTraceFile >> snrValue >> bitErrorRate >> burstErrorRate >> sigma2 >> I1 >> I2;
258  SNRToBlockErrorRateRecord *record = new SNRToBlockErrorRateRecord (snrValue,
259  bitErrorRate,
260  burstErrorRate,
261  sigma2,
262  I1,
263  I2);
264 
265  m_recordModulation[i]->push_back (record);
266 
267  }
268  m_ifTraceFile.close ();
269  }
270  m_activateLoss = true;
271 }
272 
273 void
274 SNRToBlockErrorRateManager::SetTraceFilePath (char *traceFilePath)
275 {
276  std::strcpy (m_traceFilePath, traceFilePath);
277 }
278 
279 std::string
280 SNRToBlockErrorRateManager::GetTraceFilePath (void)
281 {
282  return (std::string (m_traceFilePath));
283 }
284 
285 double
286 SNRToBlockErrorRateManager::GetBlockErrorRate (double SNR, uint8_t modulation)
287 {
288 
289  if (m_activateLoss == false)
290  {
291  return 0;
292  }
293 
294  std::vector<SNRToBlockErrorRateRecord *> *record = 0;
295 
296  record = m_recordModulation[modulation];
297 
298  if (SNR <= (record->at (0)->GetSNRValue ()))
299  {
300  return 1;
301  }
302  if (SNR >= (record->at (record->size () - 1)->GetSNRValue ()))
303  {
304  return 0;
305  }
306 
307  std::vector<SNRToBlockErrorRateRecord*>::const_iterator iter;
308  unsigned int i;
309  for (i = 0; i < record->size (); i++)
310  {
311  if (SNR < record->at (i)->GetSNRValue ())
312  {
313  break;
314  }
315  }
316  double intervalSize = (record->at (i)->GetSNRValue () - record->at (i - 1)->GetSNRValue ());
317  double coeff1 = (SNR - record->at (i - 1)->GetSNRValue ()) / intervalSize;
318  double coeff2 = -1 * (SNR - record->at (i)->GetSNRValue ()) / intervalSize;
319  double BlockErrorRate = coeff2 * (record->at (i - 1)->GetBlockErrorRate ()) + coeff1 * (record->at (i)->GetBlockErrorRate ());
320  return BlockErrorRate;
321 }
322 
323 SNRToBlockErrorRateRecord *
324 SNRToBlockErrorRateManager::GetSNRToBlockErrorRateRecord (double SNR,
325  uint8_t modulation)
326 {
327 
328  if (m_activateLoss == false)
329  {
330  return new SNRToBlockErrorRateRecord (SNR, 0, 0, 0, 0, 0);
331  }
332 
333  std::vector<SNRToBlockErrorRateRecord *> *record = 0;
334  record = m_recordModulation[modulation];
335 
336  if (SNR <= (record->at (0)->GetSNRValue ()))
337  {
338  return
339  record->at (0)->Copy ();
340  }
341  if (SNR >= (record->at (record->size () - 1)->GetSNRValue ()))
342  {
343  return
344  record->at (record->size () - 1)->Copy ();
345  }
346 
347  std::vector<SNRToBlockErrorRateRecord*>::const_iterator iter;
348  unsigned int i;
349  for (i = 0; i < record->size (); i++)
350  {
351  if (SNR < record->at (i)->GetSNRValue ())
352  {
353  break;
354  }
355  }
356  double intervalSize = (record->at (i)->GetSNRValue ()
357  - record->at (i - 1)->GetSNRValue ());
358  double coeff1 = (SNR - record->at (i - 1)->GetSNRValue ()) / intervalSize;
359  double coeff2 = -1 * (SNR - record->at (i)->GetSNRValue ()) / intervalSize;
360  double BER = coeff2 * (record->at (i - 1)->GetBitErrorRate ()) + coeff1 * (record->at (i)->GetBitErrorRate ());
361  double BlcER = coeff2 * (record->at (i - 1)->GetBlockErrorRate ()) + coeff1 * (record->at (i)->GetBlockErrorRate ());
362  double sigma2 = coeff2 * (record->at (i - 1)->GetSigma2 ()) + coeff1 * (record->at (i)->GetSigma2 ());
363  double I1 = coeff2 * (record->at (i - 1)->GetI1 ()) + coeff1 * (record->at (i)->GetI1 ());
364  double I2 = coeff2 * (record->at (i - 1)->GetI2 ()) + coeff1 * (record->at (i)->GetI2 ());
365 
366  SNRToBlockErrorRateRecord * SNRToBlockErrorRate = new SNRToBlockErrorRateRecord (SNR, BER, BlcER, sigma2, I1,I2);
367  return SNRToBlockErrorRate;
368 }
369 
370 }
371 
ns3::SNRToBlockErrorRateManager::LoadDefaultTraces
void LoadDefaultTraces(void)
Loads the default traces from default-traces.h file.
Definition: snr-to-block-error-rate-manager.cc:115
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Definition: log.h:122
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Definition: log.h:264
ns3::SNRToBlockErrorRateRecord
This class represents a record (handled by SnrToBlockErrorRate manager) that keeps a mapping between ...
Definition: snr-to-block-error-rate-record.h:34
ns3::SNRToBlockErrorRateManager::GetSNRToBlockErrorRateRecord
SNRToBlockErrorRateRecord * GetSNRToBlockErrorRateRecord(double SNR, uint8_t modulation)
returns a record of type SNRToBlockErrorRateRecord corresponding to a given modulation and SNR value ...
Definition: snr-to-block-error-rate-manager.cc:324
ns3::SNRToBlockErrorRateManager::ActivateLoss
void ActivateLoss(bool loss)
If activate loss is called with false, all the returned BlcER will be 0 (no losses) ...
Definition: snr-to-block-error-rate-manager.cc:73
ns3::SNRToBlockErrorRateManager::SetTraceFilePath
void SetTraceFilePath(char *traceFilePath)
Set the path of the repository containing the traces.
Definition: snr-to-block-error-rate-manager.cc:274
ns3::SNRToBlockErrorRateManager::LoadTraces
void LoadTraces(void)
Loads the traces form the repository specified in the constructor or setted by SetTraceFilePath funct...
Definition: snr-to-block-error-rate-manager.cc:79
ns3::SNRToBlockErrorRateManager::GetBlockErrorRate
double GetBlockErrorRate(double SNR, uint8_t modulation)
returns the Block Error Rate for a given modulation and SNR value
Definition: snr-to-block-error-rate-manager.cc:286