A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
multi-model-spectrum-channel.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2009 CTTC
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Author: Nicola Baldo <nbaldo@cttc.es>
7 */
8
10
11#include "spectrum-converter.h"
12#include "spectrum-phy.h"
15#include "wraparound-model.h"
16
17#include "ns3/angles.h"
18#include "ns3/antenna-model.h"
19#include "ns3/double.h"
20#include "ns3/log.h"
21#include "ns3/mobility-model.h"
22#include "ns3/net-device.h"
23#include "ns3/node.h"
24#include "ns3/object.h"
25#include "ns3/packet-burst.h"
26#include "ns3/packet.h"
27#include "ns3/propagation-delay-model.h"
28#include "ns3/propagation-loss-model.h"
29#include "ns3/simulator.h"
30
31#include <algorithm>
32#include <iostream>
33#include <utility>
34
35namespace ns3
36{
37
38NS_LOG_COMPONENT_DEFINE("MultiModelSpectrumChannel");
39
41
42/**
43 * @brief Output stream operator
44 * @param lhs output stream
45 * @param rhs the TxSpectrumModelInfoMap to print
46 * @return an output stream
47 */
48std::ostream&
49operator<<(std::ostream& lhs, TxSpectrumModelInfoMap_t& rhs)
50{
51 for (auto it = rhs.begin(); it != rhs.end(); ++it)
52 {
53 for (auto jt = it->second.m_spectrumConverterMap.begin();
54 jt != it->second.m_spectrumConverterMap.end();
55 ++jt)
56 {
57 lhs << "(" << it->first << "," << jt->first << ") ";
58 }
59 }
60 return lhs;
61}
62
67
72
78
79void
87
90{
91 static TypeId tid = TypeId("ns3::MultiModelSpectrumChannel")
93 .SetGroupName("Spectrum")
94 .AddConstructor<MultiModelSpectrumChannel>()
95
96 ;
97 return tid;
98}
99
100void
102{
103 NS_LOG_FUNCTION(this << phy);
104
105 // remove a previous entry of this phy if it exists
106 // we need to scan for all rxSpectrumModel values since we don't
107 // know which spectrum model the phy had when it was previously added
108 // (it's probably different than the current one)
109 for (auto rxInfoIterator = m_rxSpectrumModelInfoMap.begin();
110 rxInfoIterator != m_rxSpectrumModelInfoMap.end();
111 ++rxInfoIterator)
112 {
113 auto phyIt = std::find(rxInfoIterator->second.m_rxPhys.begin(),
114 rxInfoIterator->second.m_rxPhys.end(),
115 phy);
116 if (phyIt != rxInfoIterator->second.m_rxPhys.end())
117 {
118 rxInfoIterator->second.m_rxPhys.erase(phyIt);
119 --m_numDevices;
120 break; // there should be at most one entry
121 }
122 }
123}
124
125void
127{
128 NS_LOG_FUNCTION(this << phy);
129
130 Ptr<const SpectrumModel> rxSpectrumModel = phy->GetRxSpectrumModel();
131
132 NS_ASSERT_MSG(rxSpectrumModel,
133 "phy->GetRxSpectrumModel () returned 0. Please check that the RxSpectrumModel is "
134 "already set for the phy before calling MultiModelSpectrumChannel::AddRx (phy)");
135
136 const auto rxSpectrumModelUid = rxSpectrumModel->GetUid();
137
138 RemoveRx(phy);
139
140 ++m_numDevices;
141
142 auto [rxInfoIterator, inserted] =
143 m_rxSpectrumModelInfoMap.emplace(rxSpectrumModelUid, RxSpectrumModelInfo(rxSpectrumModel));
144
145 // rxInfoIterator points either to the newly inserted element or to the element that
146 // prevented insertion. In both cases, add the phy to the element pointed to by rxInfoIterator
147 rxInfoIterator->second.m_rxPhys.push_back(phy);
148
149 if (inserted)
150 {
151 // create the necessary converters for all the TX spectrum models that we know of
152 for (auto txInfoIterator = m_txSpectrumModelInfoMap.begin();
153 txInfoIterator != m_txSpectrumModelInfoMap.end();
154 ++txInfoIterator)
155 {
156 auto txSpectrumModel = txInfoIterator->second.m_txSpectrumModel;
157 const auto txSpectrumModelUid = txSpectrumModel->GetUid();
158
159 if (rxSpectrumModelUid != txSpectrumModelUid &&
160 !txSpectrumModel->IsOrthogonal(*rxSpectrumModel))
161 {
162 NS_LOG_LOGIC("Creating converter between SpectrumModelUid "
163 << txSpectrumModel->GetUid() << " and " << rxSpectrumModelUid);
164 SpectrumConverter converter(txSpectrumModel, rxSpectrumModel);
165 auto ret2 = txInfoIterator->second.m_spectrumConverterMap.insert(
166 std::make_pair(rxSpectrumModelUid, converter));
167 NS_ASSERT(ret2.second);
168 }
169 }
170 }
171}
172
173TxSpectrumModelInfoMap_t::const_iterator
175 Ptr<const SpectrumModel> txSpectrumModel)
176{
177 NS_LOG_FUNCTION(this << txSpectrumModel);
178 const auto txSpectrumModelUid = txSpectrumModel->GetUid();
179 auto 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 auto ret = m_txSpectrumModelInfoMap.insert(
186 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 (auto rxInfoIterator = m_rxSpectrumModelInfoMap.begin();
192 rxInfoIterator != m_rxSpectrumModelInfoMap.end();
193 ++rxInfoIterator)
194 {
195 auto rxSpectrumModel = rxInfoIterator->second.m_rxSpectrumModel;
196 const auto rxSpectrumModelUid = rxSpectrumModel->GetUid();
197
198 if (rxSpectrumModelUid != txSpectrumModelUid &&
199 !txSpectrumModel->IsOrthogonal(*rxSpectrumModel))
200 {
201 NS_LOG_LOGIC("Creating converter between SpectrumModelUid "
202 << txSpectrumModelUid << " and " << rxSpectrumModelUid);
203
204 SpectrumConverter converter(txSpectrumModel, rxSpectrumModel);
205 auto ret2 = txInfoIterator->second.m_spectrumConverterMap.insert(
206 std::make_pair(rxSpectrumModelUid, converter));
207 NS_ASSERT(ret2.second);
208 }
209 }
210 }
211 else
212 {
213 NS_LOG_LOGIC("SpectrumModelUid " << txSpectrumModelUid << " already present");
214 }
215 return txInfoIterator;
216}
217
218void
220{
221 NS_LOG_FUNCTION(this << txParams);
222
223 NS_ASSERT(txParams->txPhy);
224 NS_ASSERT(txParams->psd);
225 auto txParamsTrace = txParams->Copy(); // copy it since traced value cannot be const (because of
226 // potential underlying DynamicCasts)
227 m_txSigParamsTrace(txParamsTrace);
228
229 auto wraparound = GetObject<WraparoundModel>();
230 auto refTxMobility = txParams->txPhy->GetMobility();
231 auto txMobility = refTxMobility;
232 const auto txSpectrumModelUid = txParams->psd->GetSpectrumModelUid();
233 NS_LOG_LOGIC("txSpectrumModelUid " << txSpectrumModelUid);
234
235 const auto txInfoIterator =
236 FindAndEventuallyAddTxSpectrumModel(txParams->psd->GetSpectrumModel());
237 NS_ASSERT(txInfoIterator != m_txSpectrumModelInfoMap.cend());
238
239 NS_LOG_LOGIC("converter map for TX SpectrumModel with Uid " << txInfoIterator->first);
240 NS_LOG_LOGIC("converter map size: " << txInfoIterator->second.m_spectrumConverterMap.size());
241 NS_LOG_LOGIC("converter map first element: "
242 << txInfoIterator->second.m_spectrumConverterMap.begin()->first);
243
244 std::map<SpectrumModelUid_t, Ptr<SpectrumValue>> convertedPsds{};
245 for (auto rxInfoIterator = m_rxSpectrumModelInfoMap.begin();
246 rxInfoIterator != m_rxSpectrumModelInfoMap.end();
247 ++rxInfoIterator)
248 {
249 const auto rxSpectrumModelUid = rxInfoIterator->second.m_rxSpectrumModel->GetUid();
250 NS_LOG_LOGIC("rxSpectrumModelUids " << rxSpectrumModelUid);
251
252 Ptr<SpectrumValue> convertedTxPowerSpectrum;
253 if (txSpectrumModelUid == rxSpectrumModelUid)
254 {
255 NS_LOG_LOGIC("no spectrum conversion needed");
256 convertedTxPowerSpectrum = txParams->psd;
257 }
258 else
259 {
260 NS_LOG_LOGIC("converting txPowerSpectrum SpectrumModelUids "
261 << txSpectrumModelUid << " --> " << rxSpectrumModelUid);
262 auto rxConverterIterator =
263 txInfoIterator->second.m_spectrumConverterMap.find(rxSpectrumModelUid);
264 if (rxConverterIterator == txInfoIterator->second.m_spectrumConverterMap.end())
265 {
266 // No converter means TX SpectrumModel is orthogonal to RX SpectrumModel
267 continue;
268 }
269 convertedTxPowerSpectrum = rxConverterIterator->second.Convert(txParams->psd);
270 }
271 convertedPsds.emplace(rxSpectrumModelUid, convertedTxPowerSpectrum);
272 }
273
274 for (auto rxInfoIterator = m_rxSpectrumModelInfoMap.begin();
275 rxInfoIterator != m_rxSpectrumModelInfoMap.end();
276 ++rxInfoIterator)
277 {
278 const auto rxSpectrumModelUid = rxInfoIterator->second.m_rxSpectrumModel->GetUid();
279
280 if ((txSpectrumModelUid != rxSpectrumModelUid) &&
281 !txInfoIterator->second.m_spectrumConverterMap.contains(rxSpectrumModelUid))
282 {
283 // No converter means TX SpectrumModel is orthogonal to RX SpectrumModel
284 continue;
285 }
286
287 for (auto rxPhyIterator = rxInfoIterator->second.m_rxPhys.begin();
288 rxPhyIterator != rxInfoIterator->second.m_rxPhys.end();
289 ++rxPhyIterator)
290 {
291 NS_ASSERT_MSG((*rxPhyIterator)->GetRxSpectrumModel()->GetUid() == rxSpectrumModelUid,
292 "SpectrumModel change was not notified to MultiModelSpectrumChannel "
293 "(i.e., AddRx should be called again after model is changed)");
294
295 auto txAntennaGain{0.0};
296 if ((*rxPhyIterator) != txParams->txPhy)
297 {
298 auto rxNetDevice = (*rxPhyIterator)->GetDevice();
299 auto txNetDevice = txParams->txPhy->GetDevice();
300
301 if (rxNetDevice && txNetDevice)
302 {
303 // we assume that devices are attached to a node
304 if (rxNetDevice->GetNode()->GetId() == txNetDevice->GetNode()->GetId())
305 {
307 "Skipping the pathloss calculation among different antennas of the "
308 "same node, not supported yet by any pathloss model in ns-3.");
309 continue;
310 }
311 }
312
313 if (m_filter && m_filter->Filter(txParams, *rxPhyIterator))
314 {
315 continue;
316 }
317
318 NS_LOG_LOGIC("copying signal parameters " << txParams);
319 auto rxParams = txParams->Copy();
320 rxParams->psd = Copy<SpectrumValue>(convertedPsds.at(rxSpectrumModelUid));
321 Time delay{0};
322
323 auto receiverMobility = (*rxPhyIterator)->GetMobility();
324
325 if (txMobility && receiverMobility)
326 {
327 if (wraparound)
328 {
329 // Use virtual mobility model instead
330 txMobility =
331 wraparound->GetVirtualMobilityModel(refTxMobility, receiverMobility);
332 }
333 rxParams->txMobility = txMobility;
334
335 if (rxParams->txAntenna)
336 {
337 Angles txAngles(receiverMobility->GetPosition(), txMobility->GetPosition());
338 txAntennaGain = rxParams->txAntenna->GetGainDb(txAngles);
339 NS_LOG_LOGIC("txAntennaGain = " << txAntennaGain << " dB");
340 }
342 {
343 delay = m_propagationDelay->GetDelay(txMobility, receiverMobility);
344 }
345 }
346
347 if (rxNetDevice)
348 {
349 // the receiver has a NetDevice, so we expect that it is attached to a Node
350 auto dstNode = rxNetDevice->GetNode()->GetId();
352 delay,
354 this,
355 txParams->psd,
356 txAntennaGain,
357 rxParams,
358 *rxPhyIterator,
359 convertedPsds);
360 }
361 else
362 {
363 // the receiver is not attached to a NetDevice, so we cannot assume that it is
364 // attached to a node
367 this,
368 txParams->psd,
369 txAntennaGain,
370 rxParams,
371 *rxPhyIterator,
372 convertedPsds);
373 }
374 }
375 }
376 }
377}
378
379void
381 Ptr<SpectrumValue> txPsd,
382 double txAntennaGain,
384 Ptr<SpectrumPhy> receiver,
385 const std::map<SpectrumModelUid_t, Ptr<SpectrumValue>>& availableConvertedPsds)
386{
387 NS_LOG_FUNCTION(this);
388
389 const auto rxSpectrumModelUid = params->psd->GetSpectrumModelUid();
390 const auto phySpectrumModelUid = receiver->GetRxSpectrumModel()->GetUid();
391 NS_LOG_LOGIC("rxSpectrumModelUid " << rxSpectrumModelUid << " phySpectrumModelUid "
392 << phySpectrumModelUid);
393
394 if (rxSpectrumModelUid != phySpectrumModelUid)
395 {
396 NS_LOG_LOGIC("SpectrumModelUid changed since TX started");
397
398 const auto itConvertedPsd = availableConvertedPsds.find(phySpectrumModelUid);
399 if (itConvertedPsd != availableConvertedPsds.cend())
400 {
401 NS_LOG_LOGIC("converted PSD already exists for " << phySpectrumModelUid);
402 params->psd = itConvertedPsd->second;
403 }
404 else
405 {
406 const auto txInfoIterator =
407 FindAndEventuallyAddTxSpectrumModel(txPsd->GetSpectrumModel());
408 NS_ASSERT(txInfoIterator != m_txSpectrumModelInfoMap.cend());
409
410 const auto txSpectrumModelUid = txPsd->GetSpectrumModelUid();
411 NS_LOG_LOGIC("converting txPowerSpectrum SpectrumModelUids "
412 << txSpectrumModelUid << " --> " << phySpectrumModelUid);
413 const auto rxConverterIterator =
414 txInfoIterator->second.m_spectrumConverterMap.find(phySpectrumModelUid);
415 if (rxConverterIterator == txInfoIterator->second.m_spectrumConverterMap.cend())
416 {
417 // No converter means TX SpectrumModel is orthogonal to current PHY SpectrumModel
418 params->psd = txPsd;
419 }
420 else
421 {
422 params->psd = rxConverterIterator->second.Convert(txPsd);
423 }
424 }
425 }
426
427 auto txMobility = params->txMobility;
428 auto rxMobility = receiver->GetMobility();
429 if (txMobility && rxMobility)
430 {
431 auto pathLossDb{-txAntennaGain};
432 auto rxAntennaGain{0.0};
433 auto propagationGainDb{0.0};
434
435 if (auto rxAntenna = DynamicCast<AntennaModel>(receiver->GetAntenna()))
436 {
437 Angles rxAngles(txMobility->GetPosition(), rxMobility->GetPosition());
438 rxAntennaGain = rxAntenna->GetGainDb(rxAngles);
439 NS_LOG_LOGIC("rxAntennaGain = " << rxAntennaGain << " dB");
440 pathLossDb -= rxAntennaGain;
441 }
442
443 if (m_propagationLoss && (txMobility->GetPosition() != rxMobility->GetPosition()))
444 {
445 propagationGainDb = m_propagationLoss->CalcRxPower(0, txMobility, rxMobility);
446 NS_LOG_LOGIC("propagationGainDb = " << propagationGainDb << " dB");
447 pathLossDb -= propagationGainDb;
448 }
449
450 NS_LOG_LOGIC("total pathLoss = " << pathLossDb << " dB");
451
452 // Gain trace
453 m_gainTrace(txMobility,
454 rxMobility,
455 txAntennaGain,
456 rxAntennaGain,
457 propagationGainDb,
458 pathLossDb);
459
460 // Pathloss trace
461 m_pathLossTrace(params->txPhy, receiver, pathLossDb);
462
463 if (pathLossDb > m_maxLossDb)
464 {
465 // beyond range
466 return;
467 }
468
469 const auto pathLossLinear = std::pow(10.0, (-pathLossDb) / 10.0);
470 *(params->psd) *= pathLossLinear;
471
473 {
474 params->psd = m_spectrumPropagationLoss->CalcRxPowerSpectralDensity(params,
475 txMobility,
476 rxMobility);
477 }
479 {
480 auto txPhasedArrayModel = DynamicCast<PhasedArrayModel>(params->txPhy->GetAntenna());
481 auto rxPhasedArrayModel = DynamicCast<PhasedArrayModel>(receiver->GetAntenna());
482
483 NS_ASSERT_MSG(txPhasedArrayModel && rxPhasedArrayModel,
484 "PhasedArrayModel instances should be installed at both TX and RX "
485 "SpectrumPhy in order to use PhasedArraySpectrumPropagationLoss.");
486
487 params = m_phasedArraySpectrumPropagationLoss->CalcRxPowerSpectralDensity(
488 params,
489 txMobility,
490 rxMobility,
491 txPhasedArrayModel,
492 rxPhasedArrayModel);
493 }
494 }
495
496 receiver->StartRx(params);
497}
498
499std::size_t
504
507{
509 // this method implementation is computationally intensive. This
510 // method would be faster if we actually used a std::vector for
511 // storing devices, which we don't due to the need to have fast
512 // SpectrumModel conversions and to allow PHY devices to change a
513 // SpectrumModel at run time. Note that having this method slow is
514 // acceptable as it is not used much at run time (often not at all).
515 // On the other hand, having slow SpectrumModel conversion would be
516 // less acceptable.
517 std::size_t j = 0;
518 for (auto rxInfoIterator = m_rxSpectrumModelInfoMap.begin();
519 rxInfoIterator != m_rxSpectrumModelInfoMap.end();
520 ++rxInfoIterator)
521 {
522 for (const auto& phyIt : rxInfoIterator->second.m_rxPhys)
523 {
524 if (j == i)
525 {
526 return (*phyIt).GetDevice();
527 }
528 j++;
529 }
530 }
531 NS_FATAL_ERROR("m_numDevices > actual number of devices");
532 return nullptr;
533}
534
535} // namespace ns3
Class holding the azimuth and inclination angles of spherical coordinates.
Definition angles.h:107
This SpectrumChannel implementation can handle the presence of SpectrumPhy instances which can use di...
void RemoveRx(Ptr< SpectrumPhy > phy) override
Remove a SpectrumPhy from a channel.
virtual void StartRx(Ptr< SpectrumValue > txPsd, double txAntennaGain, Ptr< SpectrumSignalParameters > params, Ptr< SpectrumPhy > receiver, const std::map< SpectrumModelUid_t, Ptr< SpectrumValue > > &availableConvertedPsds)
Used internally to reschedule transmission after the propagation delay.
Ptr< NetDevice > GetDevice(std::size_t i) const override
void AddRx(Ptr< SpectrumPhy > phy) override
Add a SpectrumPhy to a channel, so it can receive packets.
TxSpectrumModelInfoMap_t m_txSpectrumModelInfoMap
Data structure holding, for each TX SpectrumModel, all the converters to any RX SpectrumModel,...
std::size_t m_numDevices
Number of devices connected to the channel.
void DoDispose() override
Destructor implementation.
void StartTx(Ptr< SpectrumSignalParameters > params) override
Used by attached PHY instances to transmit signals on the channel.
TxSpectrumModelInfoMap_t::const_iterator FindAndEventuallyAddTxSpectrumModel(Ptr< const SpectrumModel > txSpectrumModel)
This method checks if m_rxSpectrumModelInfoMap contains an entry for the given TX SpectrumModel.
static TypeId GetTypeId()
Get the type ID.
RxSpectrumModelInfoMap_t m_rxSpectrumModelInfoMap
Data structure holding, for each RX spectrum model, all the corresponding SpectrumPhy instances.
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition object.h:511
Smart pointer class similar to boost::intrusive_ptr.
Definition ptr.h:67
The Rx spectrum model information.
RxSpectrumModelInfo(Ptr< const SpectrumModel > rxSpectrumModel)
Constructor.
Ptr< const SpectrumModel > m_rxSpectrumModel
Rx Spectrum model.
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition simulator.h:561
static void ScheduleWithContext(uint32_t context, const Time &delay, FUNC f, Ts &&... args)
Schedule an event with the given context.
Definition simulator.h:578
TracedCallback< Ptr< SpectrumSignalParameters > > m_txSigParamsTrace
Traced callback for SpectrumSignalParameters in StartTx requests.
void DoDispose() override
Destructor implementation.
Ptr< SpectrumTransmitFilter > m_filter
Transmit filter to be used with this channel.
Ptr< PropagationDelayModel > m_propagationDelay
Propagation delay model to be used with this channel.
Ptr< SpectrumPropagationLossModel > m_spectrumPropagationLoss
Frequency-dependent propagation loss model to be used with this channel.
Ptr< PhasedArraySpectrumPropagationLossModel > m_phasedArraySpectrumPropagationLoss
Frequency-dependent propagation loss model to be used with this channel.
TracedCallback< Ptr< const SpectrumPhy >, Ptr< const SpectrumPhy >, double > m_pathLossTrace
The PathLoss trace source.
TracedCallback< Ptr< const MobilityModel >, Ptr< const MobilityModel >, double, double, double, double > m_gainTrace
The Gain trace source.
Ptr< PropagationLossModel > m_propagationLoss
Single-frequency propagation loss model to be used with this channel.
double m_maxLossDb
Maximum loss [dB].
Class which implements a converter between SpectrumValue which are defined over different SpectrumMod...
Simulation virtual time values and global simulation resolution.
Definition nstime.h:96
The Tx spectrum model information.
Ptr< const SpectrumModel > m_txSpectrumModel
Tx Spectrum model.
TxSpectrumModelInfo(Ptr< const SpectrumModel > txSpectrumModel)
Constructor.
a unique identifier for an interface.
Definition type-id.h:49
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition type-id.cc:1001
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition assert.h:55
#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:75
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition log.h:257
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition log.h:271
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition object-base.h:35
std::map< SpectrumModelUid_t, TxSpectrumModelInfo > TxSpectrumModelInfoMap_t
Container: SpectrumModelUid_t, TxSpectrumModelInfo.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
std::ostream & operator<<(std::ostream &os, const Angles &a)
Definition angles.cc:148
uint32_t SpectrumModelUid_t
Uid for SpectrumModels.
Ptr< T1 > DynamicCast(const Ptr< T2 > &p)
Cast a Ptr.
Definition ptr.h:585
Ptr< T > Copy(Ptr< T > object)
Return a deep copy of a Ptr.
Definition ptr.h:609