A Discrete-Event Network Simulator
API
lena-rem-sector-antenna.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
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: Jaume Nin <jnin@cttc.es>
19  */
20 
21 #include "ns3/core-module.h"
22 #include "ns3/network-module.h"
23 #include "ns3/mobility-module.h"
24 #include "ns3/lte-module.h"
25 #include "ns3/config-store.h"
26 #include <ns3/buildings-propagation-loss-model.h>
27 #include <ns3/buildings-helper.h>
28 #include <ns3/radio-environment-map-helper.h>
29 #include <iomanip>
30 #include <string>
31 #include <vector>
32 //#include "ns3/gtk-config-store.h"
33 
34 using namespace ns3;
35 using std::vector;
36 
37 int
38 main (int argc, char *argv[])
39 {
41  cmd.Parse (argc, argv);
42 
43  ConfigStore inputConfig;
44  inputConfig.ConfigureDefaults ();
45 
46  cmd.Parse (argc, argv);
47 
48  // Geometry of the scenario (in meters)
49  // Assume squared building
50  double nodeHeight = 1.5;
51  double roomHeight = 3;
52  double roomLength = 500;
53  uint32_t nRooms = 2;
54  // Create one eNodeB per room + one 3 sector eNodeB (i.e. 3 eNodeB) + one regular eNodeB
55  uint32_t nEnb = nRooms*nRooms + 4;
56  uint32_t nUe = 1;
57 
58  Ptr < LteHelper > lteHelper = CreateObject<LteHelper> ();
59  //lteHelper->EnableLogComponents ();
60  lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::FriisPropagationLossModel"));
61 
62  // Create Nodes: eNodeB and UE
63  NodeContainer enbNodes;
64  NodeContainer oneSectorNodes;
65  NodeContainer threeSectorNodes;
66  vector < NodeContainer > ueNodes;
67 
68  oneSectorNodes.Create (nEnb-3);
69  threeSectorNodes.Create (3);
70 
71  enbNodes.Add (oneSectorNodes);
72  enbNodes.Add (threeSectorNodes);
73 
74  for (uint32_t i = 0; i < nEnb; i++)
75  {
76  NodeContainer ueNode;
77  ueNode.Create (nUe);
78  ueNodes.push_back (ueNode);
79  }
80 
82  vector<Vector> enbPosition;
83  Ptr < ListPositionAllocator > positionAlloc = CreateObject<ListPositionAllocator> ();
84  Ptr < Building > building;
85  building = Create<Building> ();
86  building->SetBoundaries (Box (0.0, nRooms * roomLength,
87  0.0, nRooms * roomLength,
88  0.0, roomHeight));
89  building->SetBuildingType (Building::Residential);
90  building->SetExtWallsType (Building::ConcreteWithWindows);
91  building->SetNFloors (1);
92  building->SetNRoomsX (nRooms);
93  building->SetNRoomsY (nRooms);
94  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
95  mobility.Install (enbNodes);
96  BuildingsHelper::Install (enbNodes);
97  uint32_t plantedEnb = 0;
98  for (uint32_t row = 0; row < nRooms; row++)
99  {
100  for (uint32_t column = 0; column < nRooms; column++, plantedEnb++)
101  {
102  Vector v (roomLength * (column + 0.5),
103  roomLength * (row + 0.5),
104  nodeHeight );
105  positionAlloc->Add (v);
106  enbPosition.push_back (v);
107  Ptr<MobilityModel> mmEnb = enbNodes.Get (plantedEnb)->GetObject<MobilityModel> ();
108  mmEnb->SetPosition (v);
109  }
110  }
111 
112  // Add a 1-sector site
113  Vector v (500, 3000, nodeHeight);
114  positionAlloc->Add (v);
115  enbPosition.push_back (v);
116  mobility.Install (ueNodes.at(plantedEnb));
117  plantedEnb++;
118 
119  // Add the 3-sector site
120  for (uint32_t index = 0; index < 3; index++, plantedEnb++)
121  {
122  Vector v (500, 2000, nodeHeight);
123  positionAlloc->Add (v);
124  enbPosition.push_back (v);
125  mobility.Install (ueNodes.at(plantedEnb));
126  }
127 
128 
129  mobility.SetPositionAllocator (positionAlloc);
130  mobility.Install (enbNodes);
131 
132  // Position of UEs attached to eNB
133  for (uint32_t i = 0; i < nEnb; i++)
134  {
135  Ptr<UniformRandomVariable> posX = CreateObject<UniformRandomVariable> ();
136  posX->SetAttribute ("Min", DoubleValue (enbPosition.at(i).x - roomLength * 0));
137  posX->SetAttribute ("Max", DoubleValue (enbPosition.at(i).x + roomLength * 0));
138  Ptr<UniformRandomVariable> posY = CreateObject<UniformRandomVariable> ();
139  posY->SetAttribute ("Min", DoubleValue (enbPosition.at(i).y - roomLength * 0));
140  posY->SetAttribute ("Max", DoubleValue (enbPosition.at(i).y + roomLength * 0));
141  positionAlloc = CreateObject<ListPositionAllocator> ();
142  for (uint32_t j = 0; j < nUe; j++)
143  {
144  if ( i == nEnb - 3 )
145  {
146  positionAlloc->Add (Vector (enbPosition.at(i).x + 10, enbPosition.at(i).y, nodeHeight));
147  }
148  else if ( i == nEnb - 2 )
149  {
150  positionAlloc->Add (Vector (enbPosition.at(i).x - std::sqrt (10), enbPosition.at(i).y + std::sqrt (10), nodeHeight));
151  }
152  else if ( i == nEnb - 1 )
153  {
154  positionAlloc->Add (Vector (enbPosition.at(i).x - std::sqrt (10), enbPosition.at(i).y - std::sqrt (10), nodeHeight));
155  }
156  else
157  {
158  positionAlloc->Add (Vector (posX->GetValue (), posY->GetValue (), nodeHeight));
159  }
160  mobility.SetPositionAllocator (positionAlloc);
161  }
162  mobility.Install (ueNodes.at(i));
163  BuildingsHelper::Install (ueNodes.at(i));
164  }
165 
166  // Create Devices and install them in the Nodes (eNB and UE)
167  NetDeviceContainer enbDevs;
168  vector < NetDeviceContainer > ueDevs;
169 
170  // power setting in dBm for small cells
171  Config::SetDefault ("ns3::LteEnbPhy::TxPower", DoubleValue (20.0));
172  enbDevs = lteHelper->InstallEnbDevice (oneSectorNodes);
173 
174 
175  // power setting for three-sector macrocell
176  Config::SetDefault ("ns3::LteEnbPhy::TxPower", DoubleValue (43.0));
177 
178  // Beam width is made quite narrow so sectors can be noticed in the REM
179  lteHelper->SetEnbAntennaModelType ("ns3::CosineAntennaModel");
180  lteHelper->SetEnbAntennaModelAttribute ("Orientation", DoubleValue (0));
181  lteHelper->SetEnbAntennaModelAttribute ("Beamwidth", DoubleValue (100));
182  lteHelper->SetEnbAntennaModelAttribute ("MaxGain", DoubleValue (0.0));
183  enbDevs.Add ( lteHelper->InstallEnbDevice (threeSectorNodes.Get (0)));
184 
185  lteHelper->SetEnbAntennaModelType ("ns3::CosineAntennaModel");
186  lteHelper->SetEnbAntennaModelAttribute ("Orientation", DoubleValue (360/3));
187  lteHelper->SetEnbAntennaModelAttribute ("Beamwidth", DoubleValue (100));
188  lteHelper->SetEnbAntennaModelAttribute ("MaxGain", DoubleValue (0.0));
189  enbDevs.Add ( lteHelper->InstallEnbDevice (threeSectorNodes.Get (1)));
190 
191  lteHelper->SetEnbAntennaModelType ("ns3::CosineAntennaModel");
192  lteHelper->SetEnbAntennaModelAttribute ("Orientation", DoubleValue (2*360/3));
193  lteHelper->SetEnbAntennaModelAttribute ("Beamwidth", DoubleValue (100));
194  lteHelper->SetEnbAntennaModelAttribute ("MaxGain", DoubleValue (0.0));
195  enbDevs.Add ( lteHelper->InstallEnbDevice (threeSectorNodes.Get (2)));
196 
197  for (uint32_t i = 0; i < nEnb; i++)
198  {
199  NetDeviceContainer ueDev = lteHelper->InstallUeDevice (ueNodes.at(i));
200  ueDevs.push_back (ueDev);
201  lteHelper->Attach (ueDev, enbDevs.Get (i));
203  EpsBearer bearer (q);
204  lteHelper->ActivateDataRadioBearer (ueDev, bearer);
205  }
206 
208 
209  // by default, simulation will anyway stop right after the REM has been generated
210  Simulator::Stop (Seconds (0.0069));
211 
212  Ptr<RadioEnvironmentMapHelper> remHelper = CreateObject<RadioEnvironmentMapHelper> ();
213  remHelper->SetAttribute ("ChannelPath", StringValue ("/ChannelList/0"));
214  remHelper->SetAttribute ("OutputFile", StringValue ("rem.out"));
215  remHelper->SetAttribute ("XMin", DoubleValue (-2000.0));
216  remHelper->SetAttribute ("XMax", DoubleValue (+2000.0));
217  remHelper->SetAttribute ("YMin", DoubleValue (-500.0));
218  remHelper->SetAttribute ("YMax", DoubleValue (+3500.0));
219  remHelper->SetAttribute ("Z", DoubleValue (1.5));
220  remHelper->Install ();
221 
222  Simulator::Run ();
223 
224 // GtkConfigStore config;
225 // config.ConfigureAttributes ();
226 
227  lteHelper = 0;
229  return 0;
230 }
Introspection did not find any typical Config paths.
Definition: config-store.h:54
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:382
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:462
Hold variables of type string.
Definition: string.h:41
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr stored in this container at a given index.
static void Run(void)
Run the simulation.
Definition: simulator.cc:201
void Attach(NetDeviceContainer ueDevices)
Enables automatic attachment of a set of UE devices to a suitable cell using Idle mode initial cell s...
Definition: lte-helper.cc:716
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
Definition: lte-helper.cc:1046
tuple cmd
Definition: second.py:35
a 3d box
Definition: box.h:34
Keep track of the current position and velocity of an object.
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:71
void Install(Ptr< Node > node) const
"Layout" a single node according to the current position allocator type.
tuple mobility
Definition: third.py:101
static void MakeMobilityModelConsistent()
This method goes through the whole NodeList and, for each node in the list, calls BuildingsHelper::Ma...
void Add(NetDeviceContainer other)
Append the contents of another NetDeviceContainer to the end of this container.
holds a vector of ns3::NetDevice pointers
Parse command-line arguments.
Definition: command-line.h:205
void SetEnbAntennaModelType(std::string type)
Set the type of antenna model to be used by eNodeB devices.
Definition: lte-helper.cc:315
static void Destroy(void)
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:165
void ConfigureDefaults(void)
Every class exported by the ns3 library is enclosed in the ns3 namespace.
keep track of a set of node pointers.
void SetMobilityModel(std::string type, std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue(), std::string n8="", const AttributeValue &v8=EmptyAttributeValue(), std::string n9="", const AttributeValue &v9=EmptyAttributeValue())
double GetValue(double min, double max)
Get the next random value, as a double in the specified range .
void Install()
Deploy the RemSpectrumPhy objects that generate the map according to the specified settings...
void SetPosition(const Vector &position)
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:397
Helper class used to assign positions and mobility models to nodes.
void Add(NodeContainer other)
Append the contents of another NodeContainer to the end of this container.
static void Stop(void)
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:209
Ptr< Node > Get(uint32_t i) const
Get the Ptr stored in this container at a given index.
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:895
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:774
void Add(Vector v)
Add a position to the list of positions.
void SetEnbAntennaModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB antenna model to be created.
Definition: lte-helper.cc:322
void Parse(int argc, char *argv[])
Parse the program arguments.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
void SetPositionAllocator(Ptr< PositionAllocator > allocator)
Set the position allocator which will be used to allocate the initial position of every node initiali...
This class can be used to hold variables of floating point type such as 'double' or 'float'...
Definition: double.h:41
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:191
Qci
QoS Class Indicator.
Definition: eps-bearer.h:77
static void Install(Ptr< Node > node)
Install the MobilityBuildingInfo to a node.