A Discrete-Event Network Simulator
API
multi-model-spectrum-channel.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2009 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: Nicola Baldo <nbaldo@cttc.es>
19  */
20 
21 #include <algorithm>
22 #include <iostream>
23 #include <utility>
24 #include <ns3/object.h>
25 #include <ns3/simulator.h>
26 #include <ns3/log.h>
27 #include <ns3/packet.h>
28 #include <ns3/packet-burst.h>
29 #include <ns3/net-device.h>
30 #include <ns3/node.h>
31 #include <ns3/double.h>
32 #include <ns3/mobility-model.h>
33 #include <ns3/spectrum-phy.h>
34 #include <ns3/spectrum-converter.h>
35 #include <ns3/spectrum-propagation-loss-model.h>
36 #include <ns3/propagation-loss-model.h>
37 #include <ns3/propagation-delay-model.h>
38 #include <ns3/antenna-model.h>
39 #include <ns3/angles.h>
41 
42 namespace ns3 {
43 
44 NS_LOG_COMPONENT_DEFINE ("MultiModelSpectrumChannel");
45 
46 NS_OBJECT_ENSURE_REGISTERED (MultiModelSpectrumChannel);
47 
54 std::ostream& operator<< (std::ostream& lhs, TxSpectrumModelInfoMap_t& rhs)
55 {
56  for (TxSpectrumModelInfoMap_t::iterator it = rhs.begin ();
57  it != rhs.end ();
58  ++it)
59  {
60  SpectrumConverterMap_t::iterator jt;
61  for (jt = it->second.m_spectrumConverterMap.begin ();
62  jt != it->second.m_spectrumConverterMap.end ();
63  ++jt)
64  {
65  lhs << "(" << it->first << "," << jt->first << ") ";
66  }
67  }
68  return lhs;
69 }
70 
72  : m_txSpectrumModel (txSpectrumModel)
73 {
74 }
75 
77  : m_rxSpectrumModel (rxSpectrumModel)
78 {
79 }
80 
82  : m_numDevices {0}
83 {
84  NS_LOG_FUNCTION (this);
85 }
86 
87 void
89 {
90  NS_LOG_FUNCTION (this);
91  m_txSpectrumModelInfoMap.clear ();
92  m_rxSpectrumModelInfoMap.clear ();
94 }
95 
96 TypeId
98 {
99  static TypeId tid = TypeId ("ns3::MultiModelSpectrumChannel")
101  .SetGroupName ("Spectrum")
102  .AddConstructor<MultiModelSpectrumChannel> ()
103 
104  ;
105  return tid;
106 }
107 
108 void
110 {
111  NS_LOG_FUNCTION (this << phy);
112 
113  Ptr<const SpectrumModel> rxSpectrumModel = phy->GetRxSpectrumModel ();
114 
115  NS_ASSERT_MSG ((0 != rxSpectrumModel), "phy->GetRxSpectrumModel () returned 0. Please check that the RxSpectrumModel is already set for the phy before calling MultiModelSpectrumChannel::AddRx (phy)");
116 
117  SpectrumModelUid_t rxSpectrumModelUid = rxSpectrumModel->GetUid ();
118 
119  // remove a previous entry of this phy if it exists
120  // we need to scan for all rxSpectrumModel values since we don't
121  // know which spectrum model the phy had when it was previously added
122  // (it's probably different than the current one)
123  for (RxSpectrumModelInfoMap_t::iterator rxInfoIterator = m_rxSpectrumModelInfoMap.begin ();
124  rxInfoIterator != m_rxSpectrumModelInfoMap.end ();
125  ++rxInfoIterator)
126  {
127  auto phyIt = std::find (rxInfoIterator->second.m_rxPhys.begin(), rxInfoIterator->second.m_rxPhys.end(), phy);
128  if (phyIt != rxInfoIterator->second.m_rxPhys.end ())
129  {
130  rxInfoIterator->second.m_rxPhys.erase (phyIt);
131  --m_numDevices;
132  break; // there should be at most one entry
133  }
134  }
135 
136  ++m_numDevices;
137 
138  RxSpectrumModelInfoMap_t::iterator rxInfoIterator = m_rxSpectrumModelInfoMap.find (rxSpectrumModelUid);
139 
140  if (rxInfoIterator == m_rxSpectrumModelInfoMap.end ())
141  {
142  // spectrum model unknown, add it to the list of RxSpectrumModels
143  std::pair<RxSpectrumModelInfoMap_t::iterator, bool> ret;
144  ret = m_rxSpectrumModelInfoMap.insert (std::make_pair (rxSpectrumModelUid, RxSpectrumModelInfo (rxSpectrumModel)));
145  NS_ASSERT (ret.second);
146  // also add the phy to the newly created set of SpectrumPhy for this RxSpectrumModel
147  ret.first->second.m_rxPhys.push_back (phy);
148 
149  // and create the necessary converters for all the TX spectrum models that we know of
150  for (TxSpectrumModelInfoMap_t::iterator txInfoIterator = m_txSpectrumModelInfoMap.begin ();
151  txInfoIterator != m_txSpectrumModelInfoMap.end ();
152  ++txInfoIterator)
153  {
154  Ptr<const SpectrumModel> txSpectrumModel = txInfoIterator->second.m_txSpectrumModel;
155  SpectrumModelUid_t txSpectrumModelUid = txSpectrumModel->GetUid ();
156 
157  if (rxSpectrumModelUid != txSpectrumModelUid && !txSpectrumModel->IsOrthogonal (*rxSpectrumModel))
158  {
159  NS_LOG_LOGIC ("Creating converter between SpectrumModelUid " << txSpectrumModel->GetUid () << " and " << rxSpectrumModelUid);
160  SpectrumConverter converter (txSpectrumModel, rxSpectrumModel);
161  std::pair<SpectrumConverterMap_t::iterator, bool> ret2;
162  ret2 = txInfoIterator->second.m_spectrumConverterMap.insert (std::make_pair (rxSpectrumModelUid, converter));
163  NS_ASSERT (ret2.second);
164  }
165  }
166  }
167  else
168  {
169  // spectrum model is already known, just add the device to the corresponding list
170  rxInfoIterator->second.m_rxPhys.push_back (phy);
171  }
172 }
173 
174 TxSpectrumModelInfoMap_t::const_iterator
176 {
177  NS_LOG_FUNCTION (this << txSpectrumModel);
178  SpectrumModelUid_t txSpectrumModelUid = txSpectrumModel->GetUid ();
179  TxSpectrumModelInfoMap_t::iterator txInfoIterator = m_txSpectrumModelInfoMap.find (txSpectrumModelUid);
180 
181  if (txInfoIterator == m_txSpectrumModelInfoMap.end ())
182  {
183  // first time we see this TX SpectrumModel
184  // we add it to the list
185  std::pair<TxSpectrumModelInfoMap_t::iterator, bool> ret;
186  ret = m_txSpectrumModelInfoMap.insert (std::make_pair (txSpectrumModelUid, TxSpectrumModelInfo (txSpectrumModel)));
187  NS_ASSERT (ret.second);
188  txInfoIterator = ret.first;
189 
190  // and we create the converters for all the RX SpectrumModels that we know of
191  for (RxSpectrumModelInfoMap_t::const_iterator rxInfoIterator = m_rxSpectrumModelInfoMap.begin ();
192  rxInfoIterator != m_rxSpectrumModelInfoMap.end ();
193  ++rxInfoIterator)
194  {
195  Ptr<const SpectrumModel> rxSpectrumModel = rxInfoIterator->second.m_rxSpectrumModel;
196  SpectrumModelUid_t rxSpectrumModelUid = rxSpectrumModel->GetUid ();
197 
198  if (rxSpectrumModelUid != txSpectrumModelUid && !txSpectrumModel->IsOrthogonal (*rxSpectrumModel))
199  {
200  NS_LOG_LOGIC ("Creating converter between SpectrumModelUid " << txSpectrumModelUid << " and " << rxSpectrumModelUid);
201 
202  SpectrumConverter converter (txSpectrumModel, rxSpectrumModel);
203  std::pair<SpectrumConverterMap_t::iterator, bool> ret2;
204  ret2 = txInfoIterator->second.m_spectrumConverterMap.insert (std::make_pair (rxSpectrumModelUid, converter));
205  NS_ASSERT (ret2.second);
206  }
207  }
208  }
209  else
210  {
211  NS_LOG_LOGIC ("SpectrumModelUid " << txSpectrumModelUid << " already present");
212  }
213  return txInfoIterator;
214 }
215 
216 void
218 {
219  NS_LOG_FUNCTION (this << txParams);
220 
221  NS_ASSERT (txParams->txPhy);
222  NS_ASSERT (txParams->psd);
223  Ptr<SpectrumSignalParameters> txParamsTrace = txParams->Copy (); // copy it since traced value cannot be const (because of potential underlying DynamicCasts)
224  m_txSigParamsTrace (txParamsTrace);
225 
226  Ptr<MobilityModel> txMobility = txParams->txPhy->GetMobility ();
227  SpectrumModelUid_t txSpectrumModelUid = txParams->psd->GetSpectrumModelUid ();
228  NS_LOG_LOGIC ("txSpectrumModelUid " << txSpectrumModelUid);
229 
230  //
231  TxSpectrumModelInfoMap_t::const_iterator txInfoIteratorerator = FindAndEventuallyAddTxSpectrumModel (txParams->psd->GetSpectrumModel ());
232  NS_ASSERT (txInfoIteratorerator != m_txSpectrumModelInfoMap.end ());
233 
234  NS_LOG_LOGIC ("converter map for TX SpectrumModel with Uid " << txInfoIteratorerator->first);
235  NS_LOG_LOGIC ("converter map size: " << txInfoIteratorerator->second.m_spectrumConverterMap.size ());
236  NS_LOG_LOGIC ("converter map first element: " << txInfoIteratorerator->second.m_spectrumConverterMap.begin ()->first);
237 
238  for (RxSpectrumModelInfoMap_t::const_iterator rxInfoIterator = m_rxSpectrumModelInfoMap.begin ();
239  rxInfoIterator != m_rxSpectrumModelInfoMap.end ();
240  ++rxInfoIterator)
241  {
242  SpectrumModelUid_t rxSpectrumModelUid = rxInfoIterator->second.m_rxSpectrumModel->GetUid ();
243  NS_LOG_LOGIC ("rxSpectrumModelUids " << rxSpectrumModelUid);
244 
245  Ptr <SpectrumValue> convertedTxPowerSpectrum;
246  if (txSpectrumModelUid == rxSpectrumModelUid)
247  {
248  NS_LOG_LOGIC ("no spectrum conversion needed");
249  convertedTxPowerSpectrum = txParams->psd;
250  }
251  else
252  {
253  NS_LOG_LOGIC ("converting txPowerSpectrum SpectrumModelUids " << txSpectrumModelUid << " --> " << rxSpectrumModelUid);
254  SpectrumConverterMap_t::const_iterator rxConverterIterator = txInfoIteratorerator->second.m_spectrumConverterMap.find (rxSpectrumModelUid);
255  if (rxConverterIterator == txInfoIteratorerator->second.m_spectrumConverterMap.end ())
256  {
257  // No converter means TX SpectrumModel is orthogonal to RX SpectrumModel
258  continue;
259  }
260  convertedTxPowerSpectrum = rxConverterIterator->second.Convert (txParams->psd);
261  }
262 
263  for (auto rxPhyIterator = rxInfoIterator->second.m_rxPhys.begin ();
264  rxPhyIterator != rxInfoIterator->second.m_rxPhys.end ();
265  ++rxPhyIterator)
266  {
267  NS_ASSERT_MSG ((*rxPhyIterator)->GetRxSpectrumModel ()->GetUid () == rxSpectrumModelUid,
268  "SpectrumModel change was not notified to MultiModelSpectrumChannel (i.e., AddRx should be called again after model is changed)");
269 
270  if ((*rxPhyIterator) != txParams->txPhy)
271  {
272  NS_LOG_LOGIC ("copying signal parameters " << txParams);
273  Ptr<SpectrumSignalParameters> rxParams = txParams->Copy ();
274  rxParams->psd = Copy<SpectrumValue> (convertedTxPowerSpectrum);
275  Time delay = MicroSeconds (0);
276 
277  Ptr<MobilityModel> receiverMobility = (*rxPhyIterator)->GetMobility ();
278 
279  if (txMobility && receiverMobility)
280  {
281  double txAntennaGain = 0;
282  double rxAntennaGain = 0;
283  double propagationGainDb = 0;
284  double pathLossDb = 0;
285  if (rxParams->txAntenna != 0)
286  {
287  Angles txAngles (receiverMobility->GetPosition (), txMobility->GetPosition ());
288  txAntennaGain = rxParams->txAntenna->GetGainDb (txAngles);
289  NS_LOG_LOGIC ("txAntennaGain = " << txAntennaGain << " dB");
290  pathLossDb -= txAntennaGain;
291  }
292  Ptr<AntennaModel> rxAntenna = (*rxPhyIterator)->GetRxAntenna ();
293  if (rxAntenna != 0)
294  {
295  Angles rxAngles (txMobility->GetPosition (), receiverMobility->GetPosition ());
296  rxAntennaGain = rxAntenna->GetGainDb (rxAngles);
297  NS_LOG_LOGIC ("rxAntennaGain = " << rxAntennaGain << " dB");
298  pathLossDb -= rxAntennaGain;
299  }
300  if (m_propagationLoss)
301  {
302  propagationGainDb = m_propagationLoss->CalcRxPower (0, txMobility, receiverMobility);
303  NS_LOG_LOGIC ("propagationGainDb = " << propagationGainDb << " dB");
304  pathLossDb -= propagationGainDb;
305  }
306  NS_LOG_LOGIC ("total pathLoss = " << pathLossDb << " dB");
307  // Gain trace
308  m_gainTrace (txMobility, receiverMobility, txAntennaGain, rxAntennaGain, propagationGainDb, pathLossDb);
309  // Pathloss trace
310  m_pathLossTrace (txParams->txPhy, *rxPhyIterator, pathLossDb);
311  if (pathLossDb > m_maxLossDb)
312  {
313  // beyond range
314  continue;
315  }
316  double pathGainLinear = std::pow (10.0, (-pathLossDb) / 10.0);
317  *(rxParams->psd) *= pathGainLinear;
318 
320  {
321  rxParams->psd = m_spectrumPropagationLoss->CalcRxPowerSpectralDensity (rxParams->psd, txMobility, receiverMobility);
322  }
323 
324  if (m_propagationDelay)
325  {
326  delay = m_propagationDelay->GetDelay (txMobility, receiverMobility);
327  }
328  }
329 
330  Ptr<NetDevice> netDev = (*rxPhyIterator)->GetDevice ();
331  if (netDev)
332  {
333  // the receiver has a NetDevice, so we expect that it is attached to a Node
334  uint32_t dstNode = netDev->GetNode ()->GetId ();
336  rxParams, *rxPhyIterator);
337  }
338  else
339  {
340  // the receiver is not attached to a NetDevice, so we cannot assume that it is attached to a node
342  rxParams, *rxPhyIterator);
343  }
344  }
345  }
346 
347  }
348 
349 }
350 
351 void
353 {
354  NS_LOG_FUNCTION (this);
355  receiver->StartRx (params);
356 }
357 
358 std::size_t
360 {
361  return m_numDevices;
362 }
363 
366 {
367  NS_ASSERT (i < m_numDevices);
368  // this method implementation is computationally intensive. This
369  // method would be faster if we actually used a std::vector for
370  // storing devices, which we don't due to the need to have fast
371  // SpectrumModel conversions and to allow PHY devices to change a
372  // SpectrumModel at run time. Note that having this method slow is
373  // acceptable as it is not used much at run time (often not at all).
374  // On the other hand, having slow SpectrumModel conversion would be
375  // less acceptable.
376  std::size_t j = 0;
377  for (RxSpectrumModelInfoMap_t::const_iterator rxInfoIterator = m_rxSpectrumModelInfoMap.begin ();
378  rxInfoIterator != m_rxSpectrumModelInfoMap.end ();
379  ++rxInfoIterator)
380  {
381  for (const auto &phyIt : rxInfoIterator->second.m_rxPhys)
382  {
383  if (j == i)
384  {
385  return (*phyIt).GetDevice ();
386  }
387  j++;
388  }
389  }
390  NS_FATAL_ERROR ("m_numDevices > actual number of devices");
391  return 0;
392 }
393 
394 } // namespace ns3
ns3::TypeId
a unique identifier for an interface.
Definition: type-id.h:59
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
ns3::TxSpectrumModelInfoMap_t
std::map< SpectrumModelUid_t, TxSpectrumModelInfo > TxSpectrumModelInfoMap_t
Container: SpectrumModelUid_t, TxSpectrumModelInfo.
Definition: multi-model-spectrum-channel.h:65
NS_OBJECT_ENSURE_REGISTERED
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:67
ns3::Simulator::ScheduleWithContext
static void ScheduleWithContext(uint32_t context, Time const &delay, FUNC f, Ts &&... args)
Schedule an event with the given context.
Definition: simulator.h:571
ns3::TxSpectrumModelInfo::TxSpectrumModelInfo
TxSpectrumModelInfo(Ptr< const SpectrumModel > txSpectrumModel)
Constructor.
Definition: multi-model-spectrum-channel.cc:71
ns3::SpectrumChannel
Defines the interface for spectrum-aware channel implementations.
Definition: spectrum-channel.h:49
ns3::Node::GetId
uint32_t GetId(void) const
Definition: node.cc:109
multi-model-spectrum-channel.h
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::MicroSeconds
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1305
ns3::SpectrumChannel::m_gainTrace
TracedCallback< Ptr< const MobilityModel >, Ptr< const MobilityModel >, double, double, double, double > m_gainTrace
The Gain trace source.
Definition: spectrum-channel.h:172
ns3::MultiModelSpectrumChannel::DoDispose
void DoDispose()
Destructor implementation.
Definition: multi-model-spectrum-channel.cc:88
ns3::PropagationLossModel::CalcRxPower
double CalcRxPower(double txPowerDbm, Ptr< MobilityModel > a, Ptr< MobilityModel > b) const
Returns the Rx Power taking into account all the PropagationLossModel(s) chained to the current one.
Definition: propagation-loss-model.cc:73
ns3::MultiModelSpectrumChannel::FindAndEventuallyAddTxSpectrumModel
TxSpectrumModelInfoMap_t::const_iterator FindAndEventuallyAddTxSpectrumModel(Ptr< const SpectrumModel > txSpectrumModel)
This method checks if m_rxSpectrumModelInfoMap contains an entry for the given TX SpectrumModel.
Definition: multi-model-spectrum-channel.cc:175
ns3::MultiModelSpectrumChannel::m_rxSpectrumModelInfoMap
RxSpectrumModelInfoMap_t m_rxSpectrumModelInfoMap
Data structure holding, for each RX spectrum model, all the corresponding SpectrumPhy instances.
Definition: multi-model-spectrum-channel.h:165
ns3::Simulator::Schedule
static EventId Schedule(Time const &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:556
ns3::TypeId::SetParent
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:923
ns3::MultiModelSpectrumChannel::GetNDevices
virtual std::size_t GetNDevices(void) const
Definition: multi-model-spectrum-channel.cc:359
ns3::MultiModelSpectrumChannel::MultiModelSpectrumChannel
MultiModelSpectrumChannel()
Definition: multi-model-spectrum-channel.cc:81
ns3::AntennaModel::GetGainDb
virtual double GetGainDb(Angles a)=0
this method is expected to be re-implemented by each antenna model
ns3::MultiModelSpectrumChannel::m_numDevices
std::size_t m_numDevices
Number of devices connected to the channel.
Definition: multi-model-spectrum-channel.h:170
ns3::Ptr< const SpectrumModel >
ns3::MultiModelSpectrumChannel::StartRx
virtual void StartRx(Ptr< SpectrumSignalParameters > params, Ptr< SpectrumPhy > receiver)
Used internally to reschedule transmission after the propagation delay.
Definition: multi-model-spectrum-channel.cc:352
NS_FATAL_ERROR
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:165
ns3::SpectrumChannel::m_maxLossDb
double m_maxLossDb
Maximum loss [dB].
Definition: spectrum-channel.h:184
ns3::MultiModelSpectrumChannel::m_txSpectrumModelInfoMap
TxSpectrumModelInfoMap_t m_txSpectrumModelInfoMap
Data structure holding, for each TX SpectrumModel, all the converters to any RX SpectrumModel,...
Definition: multi-model-spectrum-channel.h:158
ns3::SpectrumChannel::m_spectrumPropagationLoss
Ptr< SpectrumPropagationLossModel > m_spectrumPropagationLoss
Frequency-dependent propagation loss model to be used with this channel.
Definition: spectrum-channel.h:199
ns3::NetDevice::GetNode
virtual Ptr< Node > GetNode(void) const =0
ns3::TxSpectrumModelInfo
The Tx spectrum model information.
Definition: multi-model-spectrum-channel.h:48
ns3::MultiModelSpectrumChannel::GetTypeId
static TypeId GetTypeId(void)
Get the type ID.
Definition: multi-model-spectrum-channel.cc:97
ns3::RxSpectrumModelInfo
The Rx spectrum model information.
Definition: multi-model-spectrum-channel.h:74
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:104
NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:88
ns3::MultiModelSpectrumChannel::AddRx
virtual void AddRx(Ptr< SpectrumPhy > phy)
Add a SpectrumPhy to a channel, so it can receive packets.
Definition: multi-model-spectrum-channel.cc:109
ns3::SpectrumChannel::DoDispose
virtual void DoDispose(void)
Destructor implementation.
Definition: spectrum-channel.cc:44
ns3::SpectrumChannel::m_propagationDelay
Ptr< PropagationDelayModel > m_propagationDelay
Propagation delay model to be used with this channel.
Definition: spectrum-channel.h:194
NS_LOG_LOGIC
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:289
ns3::MultiModelSpectrumChannel::GetDevice
virtual Ptr< NetDevice > GetDevice(std::size_t i) const
Definition: multi-model-spectrum-channel.cc:365
ns3::Angles
Class holding the azimuth and inclination angles of spherical coordinates.
Definition: angles.h:119
ns3::SpectrumConverter
Class which implements a converter between SpectrumValue which are defined over different SpectrumMod...
Definition: spectrum-converter.h:43
ns3::SpectrumModel::IsOrthogonal
bool IsOrthogonal(const SpectrumModel &other) const
Check if another SpectrumModels has bands orthogonal to our bands.
Definition: spectrum-model.cc:112
ns3::MultiModelSpectrumChannel
This SpectrumChannel implementation can handle the presence of SpectrumPhy instances which can use di...
Definition: multi-model-spectrum-channel.h:107
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition: log-macros-enabled.h:244
ns3::SpectrumModel::GetUid
SpectrumModelUid_t GetUid() const
Definition: spectrum-model.cc:106
ns3::SpectrumChannel::m_pathLossTrace
TracedCallback< Ptr< const SpectrumPhy >, Ptr< const SpectrumPhy >, double > m_pathLossTrace
The PathLoss trace source.
Definition: spectrum-channel.h:165
ns3::SpectrumChannel::m_txSigParamsTrace
TracedCallback< Ptr< SpectrumSignalParameters > > m_txSigParamsTrace
Traced callback for SpectrumSignalParameters in StartTx requests.
Definition: spectrum-channel.h:177
ns3::MultiModelSpectrumChannel::StartTx
virtual void StartTx(Ptr< SpectrumSignalParameters > params)
Used by attached PHY instances to transmit signals on the channel.
Definition: multi-model-spectrum-channel.cc:217
ns3::operator<<
std::ostream & operator<<(std::ostream &os, const Angles &a)
Definition: angles.cc:137
ns3::RxSpectrumModelInfo::RxSpectrumModelInfo
RxSpectrumModelInfo(Ptr< const SpectrumModel > rxSpectrumModel)
Constructor.
Definition: multi-model-spectrum-channel.cc:76
ns3::SpectrumModelUid_t
uint32_t SpectrumModelUid_t
Uid for SpectrumModels.
Definition: spectrum-model.h:57
ns3::MobilityModel::GetPosition
Vector GetPosition(void) const
Definition: mobility-model.cc:64
ns3::SpectrumPhy::StartRx
virtual void StartRx(Ptr< SpectrumSignalParameters > params)=0
Notify the SpectrumPhy instance of an incoming signal.
ns3::SpectrumChannel::m_propagationLoss
Ptr< PropagationLossModel > m_propagationLoss
Single-frequency propagation loss model to be used with this channel.
Definition: spectrum-channel.h:189
third.phy
phy
Definition: third.py:93