A Discrete-Event Network Simulator
API
animation-interface.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * This program is free software; you can redistribute it and/or modify
4  * it under the terms of the GNU General Public License version 2 as
5  * published by the Free Software Foundation;
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software
14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15  *
16  * Author: George F. Riley<riley@ece.gatech.edu>
17  * Modified by: John Abraham <john.abraham@gatech.edu>
18  * Contributions: Eugene Kalishenko <ydginster@gmail.com> (Open Source and Linux Laboratory http://dev.osll.ru/)
19  * Tommaso Pecorella <tommaso.pecorella@unifi.it>
20  * Pavel Vasilyev <pavel.vasilyev@sredasolutions.com>
21  */
22 
23 // Interface between ns-3 and the network animator
24 
25 
26 
27 #include <cstdio>
28 #ifndef WIN32
29 #include <unistd.h>
30 #endif
31 #include <sstream>
32 #include <fstream>
33 #include <string>
34 #include <iomanip>
35 #include <map>
36 
37 // ns3 includes
38 #include "ns3/animation-interface.h"
39 #include "ns3/channel.h"
40 #include "ns3/config.h"
41 #include "ns3/node.h"
42 #include "ns3/mobility-model.h"
43 #include "ns3/packet.h"
44 #include "ns3/simulator.h"
45 #include "ns3/wifi-mac-header.h"
46 #include "ns3/wimax-mac-header.h"
47 #include "ns3/wifi-net-device.h"
48 #include "ns3/wifi-mac.h"
49 #include "ns3/wifi-psdu.h"
50 #include "ns3/lr-wpan-mac-header.h"
51 #include "ns3/lr-wpan-net-device.h"
52 #include "ns3/constant-position-mobility-model.h"
53 #include "ns3/lte-ue-phy.h"
54 #include "ns3/lte-enb-phy.h"
55 #include "ns3/uan-net-device.h"
56 #include "ns3/uan-mac.h"
57 #include "ns3/double.h"
58 #include "ns3/ipv4.h"
59 #include "ns3/ipv6.h"
60 #include "ns3/ipv4-routing-protocol.h"
61 #include "ns3/energy-source-container.h"
62 #include "animation-interface.h"
63 
64 namespace ns3 {
65 
66 NS_LOG_COMPONENT_DEFINE ("AnimationInterface");
67 
68 // Globals
69 
70 static bool initialized = false;
71 
72 
73 // Public methods
74 
76  : m_f (0),
77  m_routingF (0),
78  m_mobilityPollInterval (Seconds (0.25)),
79  m_outputFileName (fn),
80  gAnimUid (0),
81  m_writeCallback (0),
82  m_started (false),
83  m_enablePacketMetadata (false),
84  m_startTime (Seconds (0)),
85  m_stopTime (Seconds (3600 * 1000)),
86  m_maxPktsPerFile (MAX_PKTS_PER_TRACE_FILE),
87  m_originalFileName (fn),
88  m_routingStopTime (Seconds (0)),
89  m_routingFileName (""),
90  m_routingPollInterval (Seconds (5)),
91  m_trackPackets (true)
92 {
93  initialized = true;
94  StartAnimation ();
95 }
96 
98 {
99  StopAnimation ();
100 }
101 
102 void
104 {
105  m_trackPackets = false;
106 }
107 
108 void
110 {
112  m_wifiPhyCountersPollInterval = pollInterval;
115  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
116  {
117  Ptr<Node> n = *i;
118  m_nodeWifiPhyTxDrop[n->GetId ()] = 0;
119  m_nodeWifiPhyRxDrop[n->GetId ()] = 0;
122  }
124 
125 }
126 
127 void
129 {
131  m_wifiMacCountersPollInterval = pollInterval;
136  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
137  {
138  Ptr<Node> n = *i;
139  m_nodeWifiMacTx[n->GetId ()] = 0;
140  m_nodeWifiMacTxDrop[n->GetId ()] = 0;
141  m_nodeWifiMacRx[n->GetId ()] = 0;
142  m_nodeWifiMacRxDrop[n->GetId ()] = 0;
143  UpdateNodeCounter (m_wifiMacTxCounterId, n->GetId (), 0);
145  UpdateNodeCounter (m_wifiMacRxCounterId, n->GetId (), 0);
147  }
149 }
150 
151 void
153 {
155  m_queueCountersPollInterval = pollInterval;
159  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
160  {
161  Ptr<Node> n = *i;
162  m_nodeQueueEnqueue[n->GetId ()] = 0;
163  m_nodeQueueDequeue[n->GetId ()] = 0;
164  m_nodeQueueDrop[n->GetId ()] = 0;
167  UpdateNodeCounter (m_queueDropCounterId, n->GetId (), 0);
168  }
170 }
171 
172 void
174 {
180  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
181  {
182  Ptr<Node> n = *i;
183  m_nodeIpv4Tx[n->GetId ()] = 0;
184  m_nodeIpv4Rx[n->GetId ()] = 0;
185  m_nodeIpv4Drop[n->GetId ()] = 0;
189  }
191 }
192 
194 AnimationInterface::EnableIpv4RouteTracking (std::string fileName, Time startTime, Time stopTime, Time pollInterval)
195 {
196  SetOutputFile (fileName, true);
198  m_routingPollInterval = pollInterval;
199  WriteXmlAnim (true);
201  return *this;
202 }
203 
205 AnimationInterface::EnableIpv4RouteTracking (std::string fileName, Time startTime, Time stopTime, NodeContainer nc, Time pollInterval)
206 {
207  m_routingNc = nc;
208  return EnableIpv4RouteTracking (fileName, startTime, stopTime, pollInterval);
209 }
210 
212 AnimationInterface::AddSourceDestination (uint32_t fromNodeId, std::string ipv4Address)
213 {
214  Ipv4RouteTrackElement element = { ipv4Address, fromNodeId };
215  m_ipv4RouteTrackElements.push_back (element);
216  return *this;
217 }
218 
219 void
221 {
222  m_startTime = t;
223 }
224 
225 void
227 {
228  m_stopTime = t;
229 }
230 
231 void
232 AnimationInterface::SetMaxPktsPerTraceFile (uint64_t maxPacketsPerFile)
233 {
234  m_maxPktsPerFile = maxPacketsPerFile;
235 }
236 
237 uint32_t
238 AnimationInterface::AddNodeCounter (std::string counterName, CounterType counterType)
239 {
240  m_nodeCounters.push_back (counterName);
241  uint32_t counterId = m_nodeCounters.size () - 1; // counter ID is zero-indexed
242  WriteXmlAddNodeCounter (counterId, counterName, counterType);
243  return counterId;
244 }
245 
246 uint32_t
247 AnimationInterface::AddResource (std::string resourcePath)
248 {
249  m_resources.push_back (resourcePath);
250  uint32_t resourceId = m_resources.size () - 1; // resource ID is zero-indexed
251  WriteXmlAddResource (resourceId, resourcePath);
252  return resourceId;
253 }
254 
255 void
257 {
258  m_enablePacketMetadata = enable;
259  if (enable)
260  {
262  }
263 }
264 
265 bool
267 {
268  return initialized;
269 }
270 
271 bool
273 {
274  return m_started;
275 }
276 
277 void
279 {
280  m_writeCallback = cb;
281 }
282 
283 void
285 {
286  m_writeCallback = 0;
287 }
288 
289 void
291 {
293 }
294 
295 
296 void
298 {
299  NS_ASSERT (n);
301  if (loc == 0)
302  {
303  loc = CreateObject<ConstantPositionMobilityModel> ();
304  n->AggregateObject (loc);
305  }
306  Vector hubVec (x, y, z);
307  loc->SetPosition (hubVec);
308  NS_LOG_INFO ("Node:" << n->GetId () << " Position set to:(" << x << "," << y << "," << z << ")");
309 
310 }
311 
312 void
314 {
315  NS_LOG_INFO ("Setting node image for Node Id:" << nodeId);
316  if (resourceId > (m_resources.size () - 1))
317  {
318  NS_FATAL_ERROR ("Resource Id:" << resourceId << " not found. Did you use AddResource?");
319  }
320  WriteXmlUpdateNodeImage (nodeId, resourceId);
321 }
322 
323 void
324 AnimationInterface::UpdateNodeCounter (uint32_t nodeCounterId, uint32_t nodeId, double counter)
325 {
326  if (nodeCounterId > (m_nodeCounters.size () - 1))
327  {
328  NS_FATAL_ERROR ("NodeCounter Id:" << nodeCounterId << " not found. Did you use AddNodeCounter?");
329  }
330  WriteXmlUpdateNodeCounter (nodeCounterId, nodeId, counter);
331 }
332 
333 void
334 AnimationInterface::SetBackgroundImage (std::string fileName, double x, double y, double scaleX, double scaleY, double opacity)
335 {
336  if ((opacity < 0) || (opacity > 1))
337  {
338  NS_FATAL_ERROR ("Opacity must be between 0.0 and 1.0");
339  }
340  WriteXmlUpdateBackground (fileName, x, y, scaleX, scaleY, opacity);
341 }
342 
343 void
344 AnimationInterface::UpdateNodeSize (uint32_t nodeId, double width, double height)
345 {
346  AnimationInterface::NodeSize s = { width, height };
347  m_nodeSizes[nodeId] = s;
348  WriteXmlUpdateNodeSize (nodeId, s.width, s.height);
349 }
350 
351 void
352 AnimationInterface::UpdateNodeColor (Ptr <Node> n, uint8_t r, uint8_t g, uint8_t b)
353 {
354  UpdateNodeColor (n->GetId (), r, g, b);
355 }
356 
357 void
358 AnimationInterface::UpdateNodeColor (uint32_t nodeId, uint8_t r, uint8_t g, uint8_t b)
359 {
360  NS_ASSERT (NodeList::GetNode (nodeId));
361  NS_LOG_INFO ("Setting node color for Node Id:" << nodeId);
362  Rgb rgb = {r, g, b};
363  m_nodeColors[nodeId] = rgb;
364  WriteXmlUpdateNodeColor (nodeId, r, g, b);
365 }
366 
367 void
369  std::string linkDescription)
370 {
371  WriteXmlUpdateLink (fromNode, toNode, linkDescription);
372 }
373 
374 void
376  std::string linkDescription)
377 {
378  NS_ASSERT (fromNode);
379  NS_ASSERT (toNode);
380  WriteXmlUpdateLink (fromNode->GetId (), toNode->GetId (), linkDescription);
381 }
382 
383 void
385 {
386  UpdateNodeDescription (n->GetId (), descr);
387 }
388 
389 void
391 {
392  NS_ASSERT (NodeList::GetNode (nodeId));
393  m_nodeDescriptions[nodeId] = descr;
395 }
396 
397 // Private methods
398 
399 
400 double
402 {
403  const EnergyFractionMap::const_iterator fractionIter = m_nodeEnergyFraction.find (node->GetId ());
404  NS_ASSERT (fractionIter != m_nodeEnergyFraction.end ());
405  return fractionIter->second;
406 }
407 
408 void
410 {
412  Ptr <Node> n = mobility->GetObject <Node> ();
413  NS_ASSERT (n);
414  Vector v;
415  if (!mobility)
416  {
417  v = GetPosition (n);
418  }
419  else
420  {
421  v = mobility->GetPosition ();
422  }
423  UpdatePosition (n, v);
424  WriteXmlUpdateNodePosition (n->GetId (), v.x, v.y);
425 }
426 
427 bool
429 {
430  Vector oldLocation = GetPosition (n);
431  bool moved = true;
432  if ((ceil (oldLocation.x) == ceil (newLocation.x))
433  && (ceil (oldLocation.y) == ceil (newLocation.y)))
434  {
435  moved = false;
436  }
437  else
438  {
439  moved = true;
440  }
441  return moved;
442 }
443 
444 void
446 {
448  std::vector <Ptr <Node> > MovedNodes = GetMovedNodes ();
449  for (uint32_t i = 0; i < MovedNodes.size (); i++)
450  {
451  Ptr <Node> n = MovedNodes [i];
452  NS_ASSERT (n);
453  Vector v = GetPosition (n);
454  WriteXmlUpdateNodePosition (n->GetId (), v.x, v.y);
455  }
456  if (!Simulator::IsFinished ())
457  {
465  }
466 }
467 
468 std::vector <Ptr <Node> >
470 {
471  std::vector < Ptr <Node> > movedNodes;
472  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
473  {
474  Ptr<Node> n = *i;
475  NS_ASSERT (n);
476  Ptr <MobilityModel> mobility = n->GetObject <MobilityModel> ();
477  Vector newLocation;
478  if (!mobility)
479  {
480  newLocation = GetPosition (n);
481  }
482  else
483  {
484  newLocation = mobility->GetPosition ();
485  }
486  if (!NodeHasMoved (n, newLocation))
487  {
488  continue; //Location has not changed
489  }
490  else
491  {
492  UpdatePosition (n, newLocation);
493  movedNodes.push_back (n);
494  }
495  }
496  return movedNodes;
497 }
498 
499 int
500 AnimationInterface::WriteN (const std::string& st, FILE * f)
501 {
502  if (!f)
503  {
504  return 0;
505  }
506  if (m_writeCallback)
507  {
508  m_writeCallback (st.c_str ());
509  }
510  return WriteN (st.c_str (), st.length (), f);
511 }
512 
513 int
514 AnimationInterface::WriteN (const char* data, uint32_t count, FILE * f)
515 {
516  if (!f)
517  {
518  return 0;
519  }
520  // Write count bytes to h from data
521  uint32_t nLeft = count;
522  const char* p = data;
523  uint32_t written = 0;
524  while (nLeft)
525  {
526  int n = std::fwrite (p, 1, nLeft, f);
527  if (n <= 0)
528  {
529  return written;
530  }
531  written += n;
532  nLeft -= n;
533  p += n;
534  }
535  return written;
536 }
537 
538 void
539 AnimationInterface::WriteRoutePath (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements)
540 {
541  NS_LOG_INFO ("Writing Route Path From :" << nodeId << " To: " << destination.c_str ());
542  WriteXmlRp (nodeId, destination, rpElements);
543  /*for (Ipv4RoutePathElements::const_iterator i = rpElements.begin ();
544  i != rpElements.end ();
545  ++i)
546  {
547  Ipv4RoutePathElement rpElement = *i;
548  NS_LOG_INFO ("Node:" << rpElement.nodeId << "-->" << rpElement.nextHop.c_str ());
549  WriteN (GetXmlRp (rpElement.node, GetIpv4RoutingTable (n)), m_routingF);
550 
551  }
552  */
553 }
554 
555 void
556 AnimationInterface::WriteNonP2pLinkProperties (uint32_t id, std::string ipv4Address, std::string channelType)
557 {
558  WriteXmlNonP2pLinkProperties (id, ipv4Address, channelType);
559 }
560 
561 const std::vector<std::string>
562 AnimationInterface::GetElementsFromContext (const std::string& context) const
563 {
564  std::vector <std::string> elements;
565  std::size_t pos1 = 0, pos2;
566  while (pos1 != context.npos)
567  {
568  pos1 = context.find ("/",pos1);
569  pos2 = context.find ("/",pos1 + 1);
570  elements.push_back (context.substr (pos1 + 1,pos2 - (pos1 + 1)));
571  pos1 = pos2;
572  pos2 = context.npos;
573  }
574  return elements;
575 }
576 
578 AnimationInterface::GetNodeFromContext (const std::string& context) const
579 {
580  // Use "NodeList/*/ as reference
581  // where element [1] is the Node Id
582 
583  std::vector <std::string> elements = GetElementsFromContext (context);
584  Ptr <Node> n = NodeList::GetNode (atoi (elements.at (1).c_str ()));
585  NS_ASSERT (n);
586 
587  return n;
588 }
589 
592 {
593  // Use "NodeList/*/DeviceList/*/ as reference
594  // where element [1] is the Node Id
595  // element [2] is the NetDevice Id
596 
597  std::vector <std::string> elements = GetElementsFromContext (context);
598  Ptr <Node> n = GetNodeFromContext (context);
599 
600  return n->GetDevice (atoi (elements.at (3).c_str ()));
601 }
602 
603 uint64_t
605 {
606  AnimByteTag tag;
607  TypeId tid = tag.GetInstanceTypeId ();
609  bool found = false;
610  while (i.HasNext ())
611  {
612  ByteTagIterator::Item item = i.Next ();
613  if (tid == item.GetTypeId ())
614  {
615  item.GetTag (tag);
616  found = true;
617  }
618  }
619  if (found)
620  {
621  return tag.Get ();
622  }
623  else
624  {
625  return 0;
626  }
627 }
628 
629 void
631 {
632  AnimByteTag tag;
633  tag.Set (animUid);
634  p->AddByteTag (tag);
635 }
636 
637 void
638 AnimationInterface::RemainingEnergyTrace (std::string context, double previousEnergy, double currentEnergy)
639 {
641  const Ptr <const Node> node = GetNodeFromContext (context);
642  const uint32_t nodeId = node->GetId ();
643 
644  NS_LOG_INFO ("Remaining energy on one of sources on node " << nodeId << ": " << currentEnergy);
645 
646  const Ptr<EnergySource> energySource = node->GetObject<EnergySource> ();
647 
648  NS_ASSERT (energySource);
649  // Don't call GetEnergyFraction () because of recursion
650  const double energyFraction = currentEnergy / energySource->GetInitialEnergy ();
651 
652  NS_LOG_INFO ("Total energy fraction on node " << nodeId << ": " << energyFraction);
653 
654  m_nodeEnergyFraction[nodeId] = energyFraction;
655  UpdateNodeCounter (m_remainingEnergyCounterId, nodeId, energyFraction);
656 }
657 
658 void
660 {
661  const Ptr <const Node> node = GetNodeFromContext (context);
662  ++m_nodeWifiPhyTxDrop[node->GetId ()];
663 }
664 
665 void
667 {
668  const Ptr <const Node> node = GetNodeFromContext (context);
669  ++m_nodeWifiPhyRxDrop[node->GetId ()];
670 }
671 
672 void
674 {
675  const Ptr <const Node> node = GetNodeFromContext (context);
676  ++m_nodeWifiMacTx[node->GetId ()];
677 }
678 
679 void
681 {
682  const Ptr <const Node> node = GetNodeFromContext (context);
683  ++m_nodeWifiMacTxDrop[node->GetId ()];
684 }
685 
686 void
688 {
689  const Ptr <const Node> node = GetNodeFromContext (context);
690  ++m_nodeWifiMacRx[node->GetId ()];
691 }
692 
693 void
695 {
696  const Ptr <const Node> node = GetNodeFromContext (context);
697  ++m_nodeWifiMacRxDrop[node->GetId ()];
698 }
699 
700 void
702 {
703  const Ptr <const Node> node = GetNodeFromContext (context);
704  ++m_nodeLrWpanMacTx[node->GetId ()];
705 }
706 
707 void
709 {
710  const Ptr <const Node> node = GetNodeFromContext (context);
711  ++m_nodeLrWpanMacTxDrop[node->GetId ()];
712 }
713 
714 void
716 {
717  const Ptr <const Node> node = GetNodeFromContext (context);
718  ++m_nodeLrWpanMacRx[node->GetId ()];
719 }
720 
721 void
723 {
724  const Ptr <const Node> node = GetNodeFromContext (context);
725  ++m_nodeLrWpanMacRxDrop[node->GetId ()];
726 }
727 
728 void
729 AnimationInterface::Ipv4TxTrace (std::string context, Ptr<const Packet> p, Ptr<Ipv4> ipv4, uint32_t interfaceIndex)
730 {
731  const Ptr <const Node> node = GetNodeFromContext (context);
732  ++m_nodeIpv4Tx[node->GetId ()];
733 }
734 
735 void
736 AnimationInterface::Ipv4RxTrace (std::string context, Ptr<const Packet> p, Ptr<Ipv4> ipv4, uint32_t interfaceIndex)
737 {
738  const Ptr <const Node> node = GetNodeFromContext (context);
739  ++m_nodeIpv4Rx[node->GetId ()];
740 }
741 
742 void
744  const Ipv4Header & ipv4Header,
746  Ipv4L3Protocol::DropReason dropReason,
747  Ptr<Ipv4> ipv4,
748  uint32_t)
749 {
750  const Ptr <const Node> node = GetNodeFromContext (context);
751  ++m_nodeIpv4Drop[node->GetId ()];
752 }
753 
754 void
755 AnimationInterface::EnqueueTrace (std::string context,
757 {
758  const Ptr <const Node> node = GetNodeFromContext (context);
759  ++m_nodeQueueEnqueue[node->GetId ()];
760 }
761 
762 void
763 AnimationInterface::DequeueTrace (std::string context,
765 {
766  const Ptr <const Node> node = GetNodeFromContext (context);
767  ++m_nodeQueueDequeue[node->GetId ()];
768 }
769 
770 void
773 {
774  const Ptr <const Node> node = GetNodeFromContext (context);
775  ++m_nodeQueueDrop[node->GetId ()];
776 }
777 
778 void
779 AnimationInterface::DevTxTrace (std::string context,
781  Ptr<NetDevice> tx,
782  Ptr<NetDevice> rx,
783  Time txTime,
784  Time rxTime)
785 {
786  NS_LOG_FUNCTION (this);
788  NS_ASSERT (tx);
789  NS_ASSERT (rx);
790  Time now = Simulator::Now ();
791  double fbTx = now.GetSeconds ();
792  double lbTx = (now + txTime).GetSeconds ();
793  double fbRx = (now + rxTime - txTime).GetSeconds ();
794  double lbRx = (now + rxTime).GetSeconds ();
796  WriteXmlP ("p",
797  tx->GetNode ()->GetId (),
798  fbTx,
799  lbTx,
800  rx->GetNode ()->GetId (),
801  fbRx,
802  lbRx,
804 }
805 
806 void
808 {
809  NS_LOG_FUNCTION (this);
811  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
812  NS_ASSERT (ndev);
813  UpdatePosition (ndev);
814 
815  ++gAnimUid;
816  NS_LOG_INFO (ProtocolTypeToString (protocolType).c_str () << " GenericWirelessTxTrace for packet:" << gAnimUid);
817  AddByteTag (gAnimUid, p);
818  AnimPacketInfo pktInfo (ndev, Simulator::Now ());
819  AddPendingPacket (protocolType, gAnimUid, pktInfo);
820 
821  Ptr<WifiNetDevice> netDevice = DynamicCast<WifiNetDevice> (ndev);
822  if (netDevice)
823  {
824  Mac48Address nodeAddr = netDevice->GetMac ()->GetAddress ();
825  std::ostringstream oss;
826  oss << nodeAddr;
827  Ptr <Node> n = netDevice->GetNode ();
828  NS_ASSERT (n);
829  m_macToNodeIdMap[oss.str ()] = n->GetId ();
830  NS_LOG_INFO ("Added Mac" << oss.str () << " node:" << m_macToNodeIdMap[oss.str ()]);
831  }
832  AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType);
833  OutputWirelessPacketTxInfo (p, pendingPackets->at (gAnimUid), gAnimUid);
834 }
835 
836 void
838 {
839  NS_LOG_FUNCTION (this);
841  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
842  NS_ASSERT (ndev);
843  UpdatePosition (ndev);
844  uint64_t animUid = GetAnimUidFromPacket (p);
845  NS_LOG_INFO (ProtocolTypeToString (protocolType).c_str () << " for packet:" << animUid);
846  if (!IsPacketPending (animUid, protocolType))
847  {
848  NS_LOG_WARN (ProtocolTypeToString (protocolType).c_str () << " GenericWirelessRxTrace: unknown Uid");
849  return;
850  }
851  AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType);
852  pendingPackets->at (animUid).ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ());
853  OutputWirelessPacketRxInfo (p, pendingPackets->at (animUid), animUid);
854 }
855 
856 void
858 {
859  NS_LOG_FUNCTION (this);
860  return GenericWirelessTxTrace (context, p, AnimationInterface::UAN);
861 }
862 
863 void
865 {
866  NS_LOG_FUNCTION (this);
867  return GenericWirelessRxTrace (context, p, AnimationInterface::UAN);
868 }
869 
870 void
871 AnimationInterface::WifiPhyTxBeginTrace (std::string context, WifiConstPsduMap psduMap, [[maybe_unused]] WifiTxVector txVector, double txPowerW)
872 {
873  NS_LOG_FUNCTION (this);
875  Ptr<NetDevice> ndev = GetNetDeviceFromContext (context);
876  NS_ASSERT (ndev);
877  UpdatePosition (ndev);
878 
879  AnimPacketInfo pktInfo (ndev, Simulator::Now ());
881  for (auto& psdu : psduMap)
882  {
883  for (auto& mpdu : *PeekPointer (psdu.second))
884  {
885  ++gAnimUid;
886  NS_LOG_INFO ("WifiPhyTxTrace for MPDU:" << gAnimUid);
887  AddByteTag (gAnimUid, mpdu->GetPacket ()); //the underlying MSDU/A-MSDU should be handed off
888  AddPendingPacket (WIFI, gAnimUid, pktInfo);
889  OutputWirelessPacketTxInfo (mpdu->GetProtocolDataUnit (), pendingPackets->at (gAnimUid), gAnimUid); //PDU should be considered in order to have header
890  }
891  }
892 
893  Ptr<WifiNetDevice> netDevice = DynamicCast<WifiNetDevice> (ndev);
894  if (netDevice)
895  {
896  Mac48Address nodeAddr = netDevice->GetMac ()->GetAddress ();
897  std::ostringstream oss;
898  oss << nodeAddr;
899  Ptr<Node> n = netDevice->GetNode ();
900  NS_ASSERT (n);
901  m_macToNodeIdMap[oss.str ()] = n->GetId ();
902  NS_LOG_INFO ("Added Mac" << oss.str () << " node:" << m_macToNodeIdMap[oss.str ()]);
903  }
904  else
905  {
906  NS_ABORT_MSG ("This NetDevice should be a Wi-Fi network device");
907  }
908 }
909 
910 void
912 {
913  NS_LOG_FUNCTION (this);
915  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
916  NS_ASSERT (ndev);
917  UpdatePosition (ndev);
918  uint64_t animUid = GetAnimUidFromPacket (p);
919  NS_LOG_INFO ("Wifi RxBeginTrace for packet: " << animUid);
921  {
922  NS_ASSERT_MSG (false, "WifiPhyRxBeginTrace: unknown Uid");
923  std::ostringstream oss;
924  WifiMacHeader hdr;
925  if (!p->PeekHeader (hdr))
926  {
927  NS_LOG_WARN ("WifiMacHeader not present");
928  return;
929  }
930  oss << hdr.GetAddr2 ();
931  if (m_macToNodeIdMap.find (oss.str ()) == m_macToNodeIdMap.end ())
932  {
933  NS_LOG_WARN ("Transmitter Mac address " << oss.str () << " never seen before. Skipping");
934  return;
935  }
936  Ptr <Node> txNode = NodeList::GetNode (m_macToNodeIdMap[oss.str ()]);
937  UpdatePosition (txNode);
938  AnimPacketInfo pktInfo (0, Simulator::Now (), m_macToNodeIdMap[oss.str ()]);
939  AddPendingPacket (AnimationInterface::WIFI, animUid, pktInfo);
940  NS_LOG_WARN ("WifiPhyRxBegin: unknown Uid, but we are adding a wifi packet");
941  }
943  m_pendingWifiPackets[animUid].ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ());
944  OutputWirelessPacketRxInfo (p, m_pendingWifiPackets[animUid], animUid);
945 }
946 
947 void
950 {
951  NS_LOG_FUNCTION (this);
953 
954  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
955  NS_ASSERT (ndev);
956  Ptr<LrWpanNetDevice> netDevice = DynamicCast<LrWpanNetDevice> (ndev);
957 
958  Ptr <Node> n = ndev->GetNode ();
959  NS_ASSERT (n);
960 
961  UpdatePosition (n);
962 
963  LrWpanMacHeader hdr;
964  if (!p->PeekHeader (hdr))
965  {
966  NS_LOG_WARN ("LrWpanMacHeader not present");
967  return;
968  }
969 
970  std::ostringstream oss;
971  if (hdr.GetSrcAddrMode () == 2)
972  {
973  Mac16Address nodeAddr = netDevice->GetMac ()->GetShortAddress ();
974  oss << nodeAddr;
975  }
976  else if (hdr.GetSrcAddrMode () == 3)
977  {
978  Mac64Address nodeAddr = netDevice->GetMac ()->GetExtendedAddress ();
979  oss << nodeAddr;
980  }
981  else
982  {
983  NS_LOG_WARN ("LrWpanMacHeader without source address");
984  return;
985  }
986  m_macToNodeIdMap[oss.str ()] = n->GetId ();
987  NS_LOG_INFO ("Added Mac" << oss.str () << " node:" << m_macToNodeIdMap[oss.str ()]);
988 
989  ++gAnimUid;
990  NS_LOG_INFO ("LrWpan TxBeginTrace for packet:" << gAnimUid);
991  AddByteTag (gAnimUid, p);
992 
993  AnimPacketInfo pktInfo (ndev, Simulator::Now ());
995 
997 }
998 
999 void
1002 {
1003  NS_LOG_FUNCTION (this);
1005  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
1006  NS_ASSERT (ndev);
1007  Ptr <Node> n = ndev->GetNode ();
1008  NS_ASSERT (n);
1009 
1010  AnimByteTag tag;
1011  if (!p->FindFirstMatchingByteTag (tag))
1012  {
1013  return;
1014  }
1015 
1016  uint64_t animUid = GetAnimUidFromPacket (p);
1017  NS_LOG_INFO ("LrWpan RxBeginTrace for packet:" << animUid);
1019  {
1020  NS_LOG_WARN ("LrWpanPhyRxBeginTrace: unknown Uid - most probably it's an ACK.");
1021  }
1022 
1023  UpdatePosition (n);
1024  m_pendingLrWpanPackets[animUid].ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ());
1025  OutputWirelessPacketRxInfo (p, m_pendingLrWpanPackets[animUid], animUid);
1026 }
1027 
1028 void
1030 {
1031  NS_LOG_FUNCTION (this);
1032  return GenericWirelessTxTrace (context, p, AnimationInterface::WAVE);
1033 }
1034 
1035 void
1037 {
1038  NS_LOG_FUNCTION (this);
1040  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
1041  NS_ASSERT (ndev);
1042  UpdatePosition (ndev);
1043  uint64_t animUid = GetAnimUidFromPacket (p);
1044  NS_LOG_INFO ("Wave RxBeginTrace for packet:" << animUid);
1045  if (!IsPacketPending (animUid, AnimationInterface::WAVE))
1046  {
1047  NS_ASSERT_MSG (false, "WavePhyRxBeginTrace: unknown Uid");
1048  std::ostringstream oss;
1049  WifiMacHeader hdr;
1050  if (!p->PeekHeader (hdr))
1051  {
1052  NS_LOG_WARN ("WaveMacHeader not present");
1053  return;
1054  }
1055  oss << hdr.GetAddr2 ();
1056  if (m_macToNodeIdMap.find (oss.str ()) == m_macToNodeIdMap.end ())
1057  {
1058  NS_LOG_WARN ("Transmitter Mac address " << oss.str () << " never seen before. Skipping");
1059  return;
1060  }
1061  Ptr <Node> txNode = NodeList::GetNode (m_macToNodeIdMap[oss.str ()]);
1062  UpdatePosition (txNode);
1063  AnimPacketInfo pktInfo (0, Simulator::Now (), m_macToNodeIdMap[oss.str ()]);
1064  AddPendingPacket (AnimationInterface::WAVE, animUid, pktInfo);
1065  NS_LOG_WARN ("WavePhyRxBegin: unknown Uid, but we are adding a wave packet");
1066  }
1068  m_pendingWavePackets[animUid].ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ());
1069  OutputWirelessPacketRxInfo (p, m_pendingWavePackets[animUid], animUid);
1070 }
1071 
1072 
1073 void
1075 {
1076  NS_LOG_FUNCTION (this);
1078 }
1079 
1080 
1081 void
1083 {
1084  NS_LOG_FUNCTION (this);
1086 }
1087 
1088 void
1090 {
1091  NS_LOG_FUNCTION (this);
1092  return GenericWirelessTxTrace (context, p, AnimationInterface::LTE);
1093 }
1094 
1095 void
1097 {
1098  NS_LOG_FUNCTION (this);
1099  return GenericWirelessRxTrace (context, p, AnimationInterface::LTE);
1100 }
1101 
1102 void
1104 {
1105  NS_LOG_FUNCTION (this);
1107  if (!pb)
1108  {
1109  NS_LOG_WARN ("pb == 0. Not yet supported");
1110  return;
1111  }
1112  context = "/" + context;
1113  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
1114  NS_ASSERT (ndev);
1115  UpdatePosition (ndev);
1116 
1117  std::list <Ptr <Packet> > pbList = pb->GetPackets ();
1118  for (std::list <Ptr <Packet> >::iterator i = pbList.begin ();
1119  i != pbList.end ();
1120  ++i)
1121  {
1122  Ptr <Packet> p = *i;
1123  ++gAnimUid;
1124  NS_LOG_INFO ("LteSpectrumPhyTxTrace for packet:" << gAnimUid);
1125  AnimPacketInfo pktInfo (ndev, Simulator::Now ());
1126  AddByteTag (gAnimUid, p);
1128  OutputWirelessPacketTxInfo (p, pktInfo, gAnimUid);
1129  }
1130 }
1131 
1132 void
1134 {
1135  NS_LOG_FUNCTION (this);
1137  if (!pb)
1138  {
1139  NS_LOG_WARN ("pb == 0. Not yet supported");
1140  return;
1141  }
1142  context = "/" + context;
1143  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
1144  NS_ASSERT (ndev);
1145  UpdatePosition (ndev);
1146 
1147  std::list <Ptr <Packet> > pbList = pb->GetPackets ();
1148  for (std::list <Ptr <Packet> >::iterator i = pbList.begin ();
1149  i != pbList.end ();
1150  ++i)
1151  {
1152  Ptr <Packet> p = *i;
1153  uint64_t animUid = GetAnimUidFromPacket (p);
1154  NS_LOG_INFO ("LteSpectrumPhyRxTrace for packet:" << gAnimUid);
1155  if (!IsPacketPending (animUid, AnimationInterface::LTE))
1156  {
1157  NS_LOG_WARN ("LteSpectrumPhyRxTrace: unknown Uid");
1158  return;
1159  }
1160  AnimPacketInfo& pktInfo = m_pendingLtePackets[animUid];
1161  pktInfo.ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ());
1162  OutputWirelessPacketRxInfo (p, pktInfo, animUid);
1163  }
1164 }
1165 
1166 void
1168 {
1169  NS_LOG_FUNCTION (this);
1171  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
1172  NS_ASSERT (ndev);
1173  UpdatePosition (ndev);
1174  ++gAnimUid;
1175  NS_LOG_INFO ("CsmaPhyTxBeginTrace for packet:" << gAnimUid);
1176  AddByteTag (gAnimUid, p);
1177  UpdatePosition (ndev);
1178  AnimPacketInfo pktInfo (ndev, Simulator::Now ());
1180 
1181 
1182 }
1183 
1184 void
1186 {
1187  NS_LOG_FUNCTION (this);
1189  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
1190  NS_ASSERT (ndev);
1191  UpdatePosition (ndev);
1192  uint64_t animUid = GetAnimUidFromPacket (p);
1193  NS_LOG_INFO ("CsmaPhyTxEndTrace for packet:" << animUid);
1194  if (!IsPacketPending (animUid, AnimationInterface::CSMA))
1195  {
1196  NS_LOG_WARN ("CsmaPhyTxEndTrace: unknown Uid");
1197  NS_FATAL_ERROR ("CsmaPhyTxEndTrace: unknown Uid");
1198  AnimPacketInfo pktInfo (ndev, Simulator::Now ());
1199  AddPendingPacket (AnimationInterface::CSMA, animUid, pktInfo);
1200  NS_LOG_WARN ("Unknown Uid, but adding Csma Packet anyway");
1201  }
1203  AnimPacketInfo& pktInfo = m_pendingCsmaPackets[animUid];
1204  pktInfo.m_lbTx = Simulator::Now ().GetSeconds ();
1205 }
1206 
1207 void
1209 {
1210  NS_LOG_FUNCTION (this);
1212  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
1213  NS_ASSERT (ndev);
1214  UpdatePosition (ndev);
1215  uint64_t animUid = GetAnimUidFromPacket (p);
1216  if (!IsPacketPending (animUid, AnimationInterface::CSMA))
1217  {
1218  NS_LOG_WARN ("CsmaPhyRxEndTrace: unknown Uid");
1219  return;
1220  }
1222  AnimPacketInfo& pktInfo = m_pendingCsmaPackets[animUid];
1223  pktInfo.ProcessRxBegin (ndev, Simulator::Now ().GetSeconds ());
1224  NS_LOG_INFO ("CsmaPhyRxEndTrace for packet:" << animUid);
1225  NS_LOG_INFO ("CsmaPhyRxEndTrace for packet:" << animUid << " complete");
1226  OutputCsmaPacket (p, pktInfo);
1227 }
1228 
1229 void
1232 {
1233  NS_LOG_FUNCTION (this);
1235  Ptr <NetDevice> ndev = GetNetDeviceFromContext (context);
1236  NS_ASSERT (ndev);
1237  uint64_t animUid = GetAnimUidFromPacket (p);
1238  if (!IsPacketPending (animUid, AnimationInterface::CSMA))
1239  {
1240  NS_LOG_WARN ("CsmaMacRxTrace: unknown Uid");
1241  return;
1242  }
1244  AnimPacketInfo& pktInfo = m_pendingCsmaPackets[animUid];
1245  NS_LOG_INFO ("MacRxTrace for packet:" << animUid << " complete");
1246  OutputCsmaPacket (p, pktInfo);
1247 }
1248 
1249 void
1251 {
1253  uint32_t nodeId = 0;
1254  if (pktInfo.m_txnd)
1255  {
1256  nodeId = pktInfo.m_txnd->GetNode ()->GetId ();
1257  }
1258  else
1259  {
1260  nodeId = pktInfo.m_txNodeId;
1261  }
1262  WriteXmlPRef (animUid, nodeId, pktInfo.m_fbTx, m_enablePacketMetadata ? GetPacketMetadata (p) : "");
1263 }
1264 
1265 void
1267 {
1269  uint32_t rxId = pktInfo.m_rxnd->GetNode ()->GetId ();
1270  WriteXmlP (animUid, "wpr", rxId, pktInfo.m_fbRx, pktInfo.m_lbRx);
1271 }
1272 
1273 void
1275 {
1277  NS_ASSERT (pktInfo.m_txnd);
1278  uint32_t nodeId = pktInfo.m_txnd->GetNode ()->GetId ();
1279  uint32_t rxId = pktInfo.m_rxnd->GetNode ()->GetId ();
1280 
1281  WriteXmlP ("p",
1282  nodeId,
1283  pktInfo.m_fbTx,
1284  pktInfo.m_lbTx,
1285  rxId,
1286  pktInfo.m_fbRx,
1287  pktInfo.m_lbRx,
1289 }
1290 
1291 void
1292 AnimationInterface::AddPendingPacket (ProtocolType protocolType, uint64_t animUid, AnimPacketInfo pktInfo)
1293 {
1294  AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType);
1295  NS_ASSERT (pendingPackets);
1296  pendingPackets->insert (AnimUidPacketInfoMap::value_type (animUid, pktInfo));
1297 }
1298 
1299 bool
1301 {
1302  AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType);
1303  NS_ASSERT (pendingPackets);
1304  return (pendingPackets->find (animUid) != pendingPackets->end ());
1305 }
1306 
1307 void
1309 {
1310  AnimUidPacketInfoMap * pendingPackets = ProtocolTypeToPendingPackets (protocolType);
1311  NS_ASSERT (pendingPackets);
1312  if (pendingPackets->empty ())
1313  {
1314  return;
1315  }
1316  std::vector <uint64_t> purgeList;
1317  for (AnimUidPacketInfoMap::iterator i = pendingPackets->begin ();
1318  i != pendingPackets->end ();
1319  ++i)
1320  {
1321 
1322  AnimPacketInfo pktInfo = i->second;
1323  double delta = (Simulator::Now ().GetSeconds () - pktInfo.m_fbTx);
1324  if (delta > PURGE_INTERVAL)
1325  {
1326  purgeList.push_back (i->first);
1327  }
1328  }
1329  for (std::vector <uint64_t>::iterator i = purgeList.begin ();
1330  i != purgeList.end ();
1331  ++i)
1332  {
1333  pendingPackets->erase (*i);
1334  }
1335 }
1336 
1339 {
1340  AnimUidPacketInfoMap * pendingPackets = 0;
1341  switch (protocolType)
1342  {
1344  {
1345  pendingPackets = &m_pendingWifiPackets;
1346  break;
1347  }
1349  {
1350  pendingPackets = &m_pendingUanPackets;
1351  break;
1352  }
1354  {
1355  pendingPackets = &m_pendingCsmaPackets;
1356  break;
1357  }
1359  {
1360  pendingPackets = &m_pendingWimaxPackets;
1361  break;
1362  }
1364  {
1365  pendingPackets = &m_pendingLtePackets;
1366  break;
1367  }
1369  {
1370  pendingPackets = &m_pendingLrWpanPackets;
1371  break;
1372  }
1374  {
1375  pendingPackets = &m_pendingWavePackets;
1376  break;
1377  }
1378  }
1379  return pendingPackets;
1380 
1381 }
1382 
1383 std::string
1385 {
1386  std::string result = "Unknown";
1387  switch (protocolType)
1388  {
1390  {
1391  result = "WIFI";
1392  break;
1393  }
1395  {
1396  result = "UAN";
1397  break;
1398  }
1400  {
1401  result = "CSMA";
1402  break;
1403  }
1405  {
1406  result = "WIMAX";
1407  break;
1408  }
1410  {
1411  result = "LTE";
1412  break;
1413  }
1415  {
1416  result = "LRWPAN";
1417  break;
1418  }
1420  {
1421  result = "WAVE";
1422  break;
1423  }
1424  }
1425  return result;
1426 }
1427 
1428 // Counters
1429 
1430 std::string
1432 {
1433  std::string typeString = "unknown";
1434  switch (counterType)
1435  {
1436  case UINT32_COUNTER:
1437  {
1438  typeString = "UINT32";
1439  break;
1440  }
1441  case DOUBLE_COUNTER:
1442  {
1443  typeString = "DOUBLE";
1444  break;
1445  }
1446  }
1447  return typeString;
1448 }
1449 
1450 // General
1451 
1452 std::string
1454 {
1455  std::ostringstream oss;
1456  p->Print (oss);
1457  return oss.str ();
1458 }
1459 
1460 uint64_t
1462 {
1463  return m_currentPktCount;
1464 }
1465 
1466 void
1468 {
1469  m_started = false;
1470  NS_LOG_INFO ("Stopping Animation");
1472  if (m_f)
1473  {
1474  // Terminate the anim element
1475  WriteXmlClose ("anim");
1476  std::fclose (m_f);
1477  m_f = 0;
1478  }
1479  if (onlyAnimation)
1480  {
1481  return;
1482  }
1483  if (m_routingF)
1484  {
1485  WriteXmlClose ("anim", true);
1486  std::fclose (m_routingF);
1487  m_routingF = 0;
1488  }
1489 }
1490 
1491 void
1493 {
1494  m_currentPktCount = 0;
1495  m_started = true;
1497  WriteXmlAnim ();
1498  WriteNodes ();
1499  WriteNodeColors ();
1501  WriteIpv4Addresses ();
1502  WriteIpv6Addresses ();
1503  WriteNodeSizes ();
1504  WriteNodeEnergies ();
1505  if (!restart)
1506  {
1508  ConnectCallbacks ();
1509  }
1510 }
1511 
1512 void
1514 {
1515  m_ipv4ToNodeIdMap[ipv4Address] = nodeId;
1516  m_nodeIdIpv4Map.insert (NodeIdIpv4Pair (nodeId, ipv4Address));
1517 }
1518 
1519 void
1520 AnimationInterface::AddToIpv4AddressNodeIdTable (std::vector<std::string> ipv4Addresses, uint32_t nodeId)
1521 {
1522  for (std::vector<std::string>::const_iterator i = ipv4Addresses.begin ();
1523  i != ipv4Addresses.end ();
1524  ++i)
1525  {
1526  AddToIpv4AddressNodeIdTable (*i, nodeId);
1527  }
1528 }
1529 
1530 void
1532 {
1533  m_ipv6ToNodeIdMap[ipv6Address] = nodeId;
1534  m_nodeIdIpv6Map.insert (NodeIdIpv6Pair (nodeId, ipv6Address));
1535 }
1536 
1537 void
1538 AnimationInterface::AddToIpv6AddressNodeIdTable (std::vector<std::string> ipv6Addresses, uint32_t nodeId)
1539 {
1540  for (std::vector<std::string>::const_iterator i = ipv6Addresses.begin ();
1541  i != ipv6Addresses.end ();
1542  ++i)
1543  {
1544  AddToIpv6AddressNodeIdTable (*i, nodeId);
1545  }
1546 }
1547 
1548 // Callbacks
1549 void
1551 {
1552 
1553  Ptr<LteEnbPhy> lteEnbPhy = nd->GetPhy ();
1554  Ptr<LteSpectrumPhy> dlPhy = lteEnbPhy->GetDownlinkSpectrumPhy ();
1555  Ptr<LteSpectrumPhy> ulPhy = lteEnbPhy->GetUplinkSpectrumPhy ();
1556  std::ostringstream oss;
1557  //NodeList/*/DeviceList/*/
1558  oss << "NodeList/" << n->GetId () << "/DeviceList/" << devIndex << "/";
1559  if (dlPhy)
1560  {
1561  dlPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this));
1562  dlPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this));
1563  }
1564  if (ulPhy)
1565  {
1566  ulPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this));
1567  ulPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this));
1568  }
1569 }
1570 
1571 
1572 
1573 void
1575 {
1576 
1577  Ptr<LteUePhy> lteUePhy = nd->GetPhy ();
1578  Ptr<LteSpectrumPhy> dlPhy = lteUePhy->GetDownlinkSpectrumPhy ();
1579  Ptr<LteSpectrumPhy> ulPhy = lteUePhy->GetUplinkSpectrumPhy ();
1580  std::ostringstream oss;
1581  //NodeList/*/DeviceList/*/
1582  oss << "NodeList/" << n->GetId () << "/DeviceList/" << devIndex << "/";
1583  if (dlPhy)
1584  {
1585  dlPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this));
1586  dlPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this));
1587  }
1588  if (ulPhy)
1589  {
1590  ulPhy->TraceConnect ("TxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyTxStart, this));
1591  ulPhy->TraceConnect ("RxStart", oss.str (), MakeCallback (&AnimationInterface::LteSpectrumPhyRxStart, this));
1592  }
1593 }
1594 
1595 void
1597 {
1598 
1599  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
1600  {
1601  Ptr<Node> n = *i;
1602  NS_ASSERT (n);
1603  uint32_t nDevices = n->GetNDevices ();
1604  for (uint32_t devIndex = 0; devIndex < nDevices; ++devIndex)
1605  {
1606  Ptr <NetDevice> nd = n->GetDevice (devIndex);
1607  if (!nd)
1608  {
1609  continue;
1610  }
1611  Ptr<LteUeNetDevice> lteUeNetDevice = DynamicCast<LteUeNetDevice> (nd);
1612  if (lteUeNetDevice)
1613  {
1614  ConnectLteUe (n, lteUeNetDevice, devIndex);
1615  continue;
1616  }
1617  Ptr<LteEnbNetDevice> lteEnbNetDevice = DynamicCast<LteEnbNetDevice> (nd);
1618  if (lteEnbNetDevice)
1619  {
1620  ConnectLteEnb (n, lteEnbNetDevice, devIndex);
1621  }
1622  }
1623 
1624  }
1625 }
1626 
1627 void
1629 {
1630  // Connect the callbacks
1631  Config::ConnectFailSafe ("/ChannelList/*/TxRxPointToPoint",
1633  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyTxPsduBegin",
1635  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxBegin",
1637  Config::ConnectWithoutContextFailSafe ("/NodeList/*/$ns3::MobilityModel/CourseChange",
1639  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WimaxNetDevice/Tx",
1641  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WimaxNetDevice/Rx",
1643  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::LteNetDevice/Tx",
1645  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::LteNetDevice/Rx",
1647  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/PhyTxBegin",
1649  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/PhyTxEnd",
1651  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/PhyRxEnd",
1653  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/MacRx",
1655  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::UanNetDevice/Phy/PhyTxBegin",
1657  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::UanNetDevice/Phy/PhyRxBegin",
1659  Config::ConnectFailSafe ("/NodeList/*/$ns3::BasicEnergySource/RemainingEnergy",
1661 
1662  ConnectLte ();
1663 
1664  Config::ConnectFailSafe ("/NodeList/*/$ns3::Ipv4L3Protocol/Tx",
1666  Config::ConnectFailSafe ("/NodeList/*/$ns3::Ipv4L3Protocol/Rx",
1668  Config::ConnectFailSafe ("/NodeList/*/$ns3::Ipv4L3Protocol/Drop",
1670 
1671  // Queue Enqueues
1672 
1673  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::AlohaNoackNetDevice/Queue/Enqueue",
1675  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/TxQueue/Enqueue",
1677  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/TxQueue/Enqueue",
1679 
1680  // Queue Dequeues
1681 
1682  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::AlohaNoackNetDevice/Queue/Dequeue",
1684  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/TxQueue/Dequeue",
1686  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/TxQueue/Dequeue",
1688 
1689  // Queue Drops
1690 
1691  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::AlohaNoackNetDevice/Queue/Drop",
1693  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::CsmaNetDevice/TxQueue/Drop",
1695  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::PointToPointNetDevice/TxQueue/Drop",
1697 
1698 
1699  // Wifi Mac
1700  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTx",
1702  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTxDrop",
1704  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRx",
1706  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRxDrop",
1708 
1709  // Wifi Phy
1710  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyTxDrop",
1712  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Phy/PhyRxDrop",
1714 
1715  // LrWpan
1716  Config::ConnectFailSafe ("NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Phy/PhyTxBegin",
1718  Config::ConnectFailSafe ("NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Phy/PhyRxBegin",
1720  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacTx",
1722  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacTxDrop",
1724  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacRx",
1726  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::LrWpanNetDevice/Mac/MacRxDrop",
1728 
1729  // Wave
1730  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/PhyTxBegin",
1732  Config::ConnectFailSafe ("/NodeList/*/DeviceList/*/$ns3::WaveNetDevice/PhyEntities/*/$ns3::WifiPhy/PhyRxBegin",
1734 }
1735 
1736 Vector
1738 {
1739  Ptr<MobilityModel> loc = n->GetObject<MobilityModel> ();
1740  if (loc)
1741  {
1742  m_nodeLocation[n->GetId ()] = loc->GetPosition ();
1743  }
1744  else
1745  {
1746  NS_LOG_UNCOND ( "AnimationInterface WARNING:Node:" << n->GetId () << " Does not have a mobility model. Use SetConstantPosition if it is stationary");
1747  Ptr<UniformRandomVariable> x = CreateObject<UniformRandomVariable> ();
1748  x->SetAttribute ("Min", DoubleValue (0));
1749  x->SetAttribute ("Max", DoubleValue (100));
1750  Ptr<UniformRandomVariable> y = CreateObject<UniformRandomVariable> ();
1751  y->SetAttribute ("Min", DoubleValue (0));
1752  y->SetAttribute ("Max", DoubleValue (100));
1753  m_nodeLocation[n->GetId ()] = Vector (int (x->GetValue ()), int (y->GetValue ()), 0);
1754  }
1755  return m_nodeLocation[n->GetId ()];
1756 }
1757 
1758 Vector
1760 {
1761  m_nodeLocation[n->GetId ()] = v;
1762  return v;
1763 }
1764 
1765 Vector
1767 {
1768  Ptr <Node> n = ndev->GetNode ();
1769  NS_ASSERT (n);
1770  return UpdatePosition (n);
1771 }
1772 
1773 Vector
1775 {
1776  if (m_nodeLocation.find (n->GetId ()) == m_nodeLocation.end ())
1777  {
1778  NS_FATAL_ERROR ("Node:" << n->GetId () << " not found in Location table");
1779  }
1780  return m_nodeLocation[n->GetId ()];
1781 }
1782 
1783 
1784 std::string
1786 {
1787  Address nodeAddr = nd->GetAddress ();
1788  std::ostringstream oss;
1789  oss << nodeAddr;
1790  return oss.str ().substr (6); // Skip the first 6 chars to get the Mac
1791 }
1792 
1793 std::string
1795 {
1796  Ptr<Ipv4> ipv4 = NodeList::GetNode (nd->GetNode ()->GetId ())->GetObject <Ipv4> ();
1797  if (!ipv4)
1798  {
1799  NS_LOG_WARN ("Node: " << nd->GetNode ()->GetId () << " No ipv4 object found");
1800  return "0.0.0.0";
1801  }
1802  int32_t ifIndex = ipv4->GetInterfaceForDevice (nd);
1803  if (ifIndex == -1)
1804  {
1805  NS_LOG_WARN ("Node :" << nd->GetNode ()->GetId () << " Could not find index of NetDevice");
1806  return "0.0.0.0";
1807  }
1808  Ipv4InterfaceAddress addr = ipv4->GetAddress (ifIndex, 0);
1809  std::ostringstream oss;
1810  oss << addr.GetLocal ();
1811  return oss.str ();
1812 }
1813 
1814 std::string
1816 {
1817  Ptr<Ipv6> ipv6 = NodeList::GetNode (nd->GetNode ()->GetId ())->GetObject <Ipv6> ();
1818  if (!ipv6)
1819  {
1820  NS_LOG_WARN ("Node: " << nd->GetNode ()->GetId () << " No ipv4 object found");
1821  return "::";
1822  }
1823  int32_t ifIndex = ipv6->GetInterfaceForDevice (nd);
1824  if (ifIndex == -1)
1825  {
1826  NS_LOG_WARN ("Node :" << nd->GetNode ()->GetId () << " Could not find index of NetDevice");
1827  return "::";
1828  }
1829  bool nonLinkLocalFound = false;
1830  uint32_t nAddresses = ipv6->GetNAddresses (ifIndex);
1831  Ipv6InterfaceAddress addr;
1832  for (uint32_t addressIndex = 0; addressIndex < nAddresses; ++addressIndex)
1833  {
1834  addr = ipv6->GetAddress (ifIndex, addressIndex);
1835  if (!addr.GetAddress ().IsLinkLocal ())
1836  {
1837  nonLinkLocalFound = true;
1838  break;
1839  }
1840  }
1841  if (!nonLinkLocalFound)
1842  {
1843  addr = ipv6->GetAddress (ifIndex, 0);
1844  }
1845  std::ostringstream oss;
1846  oss << addr.GetAddress ();
1847  return oss.str ();
1848 }
1849 
1850 
1851 
1852 std::vector<std::string>
1854 {
1855  std::vector<std::string> ipv4Addresses;
1856  Ptr<Ipv4> ipv4 = NodeList::GetNode (nd->GetNode ()->GetId ())->GetObject <Ipv4> ();
1857  if (!ipv4)
1858  {
1859  NS_LOG_WARN ("Node: " << nd->GetNode ()->GetId () << " No ipv4 object found");
1860  return ipv4Addresses;
1861  }
1862  int32_t ifIndex = ipv4->GetInterfaceForDevice (nd);
1863  if (ifIndex == -1)
1864  {
1865  NS_LOG_WARN ("Node :" << nd->GetNode ()->GetId () << " Could not find index of NetDevice");
1866  return ipv4Addresses;
1867  }
1868  for (uint32_t index = 0; index < ipv4->GetNAddresses (ifIndex); ++index)
1869  {
1870  Ipv4InterfaceAddress addr = ipv4->GetAddress (ifIndex, index);
1871  std::ostringstream oss;
1872  oss << addr.GetLocal ();
1873  ipv4Addresses.push_back (oss.str ());
1874  }
1875  return ipv4Addresses;
1876 }
1877 
1878 std::vector<std::string>
1880 {
1881  std::vector<std::string> ipv6Addresses;
1882  Ptr<Ipv6> ipv6 = NodeList::GetNode (nd->GetNode ()->GetId ())->GetObject <Ipv6> ();
1883  if (!ipv6)
1884  {
1885  NS_LOG_WARN ("Node: " << nd->GetNode ()->GetId () << " No ipv6 object found");
1886  return ipv6Addresses;
1887  }
1888  int32_t ifIndex = ipv6->GetInterfaceForDevice (nd);
1889  if (ifIndex == -1)
1890  {
1891  NS_LOG_WARN ("Node :" << nd->GetNode ()->GetId () << " Could not find index of NetDevice");
1892  return ipv6Addresses;
1893  }
1894  for (uint32_t index = 0; index < ipv6->GetNAddresses (ifIndex); ++index)
1895  {
1896  Ipv6InterfaceAddress addr = ipv6->GetAddress (ifIndex, index);
1897  std::ostringstream oss;
1898  oss << addr.GetAddress ();
1899  ipv6Addresses.push_back (oss.str ());
1900  }
1901  return ipv6Addresses;
1902 }
1903 
1904 
1905 void
1907 {
1908  for (NodeIdIpv4Map::const_iterator i = m_nodeIdIpv4Map.begin ();
1909  i != m_nodeIdIpv4Map.end ();
1910  ++i)
1911  {
1912  std::vector <std::string> ipv4Addresses;
1913  std::pair<NodeIdIpv4Map::const_iterator, NodeIdIpv4Map::const_iterator> iterPair = m_nodeIdIpv4Map.equal_range (i->first);
1914  for (NodeIdIpv4Map::const_iterator it = iterPair.first;
1915  it != iterPair.second;
1916  ++it)
1917  {
1918  ipv4Addresses.push_back (it->second);
1919  }
1920  WriteXmlIpv4Addresses (i->first, ipv4Addresses);
1921  }
1922 }
1923 
1924 void
1926 {
1927  for (NodeIdIpv6Map::const_iterator i = m_nodeIdIpv6Map.begin ();
1928  i != m_nodeIdIpv6Map.end ();
1929  i = m_nodeIdIpv6Map.upper_bound (i->first))
1930  {
1931  std::vector <std::string> ipv6Addresses;
1932  std::pair<NodeIdIpv6Map::const_iterator, NodeIdIpv6Map::const_iterator> iterPair = m_nodeIdIpv6Map.equal_range (i->first);
1933  for (NodeIdIpv6Map::const_iterator it = iterPair.first;
1934  it != iterPair.second;
1935  ++it)
1936  {
1937  ipv6Addresses.push_back (it->second);
1938  }
1939  WriteXmlIpv6Addresses (i->first, ipv6Addresses);
1940  }
1941 }
1942 
1943 void
1945 {
1946  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
1947  {
1948  Ptr<Node> n = *i;
1949  UpdatePosition (n);
1950  uint32_t n1Id = n->GetId ();
1951  uint32_t nDev = n->GetNDevices (); // Number of devices
1952  for (uint32_t i = 0; i < nDev; ++i)
1953  {
1954  Ptr<NetDevice> dev = n->GetDevice (i);
1955  NS_ASSERT (dev);
1956  Ptr<Channel> ch = dev->GetChannel ();
1957  std::string channelType = "Unknown channel";
1958  if (ch)
1959  {
1960  channelType = ch->GetInstanceTypeId ().GetName ();
1961  }
1962  NS_LOG_DEBUG ("Got ChannelType" << channelType);
1963 
1964  if (!ch || (channelType != std::string ("ns3::PointToPointChannel")))
1965  {
1966  NS_LOG_DEBUG ("No channel can't be a p2p device");
1967  /*
1968  // Try to see if it is an LTE NetDevice, which does not return a channel
1969  if ((dev->GetInstanceTypeId ().GetName () == "ns3::LteUeNetDevice") ||
1970  (dev->GetInstanceTypeId ().GetName () == "ns3::LteEnbNetDevice")||
1971  (dev->GetInstanceTypeId ().GetName () == "ns3::VirtualNetDevice"))
1972  {
1973  WriteNonP2pLinkProperties (n->GetId (), GetIpv4Address (dev) + "~" + GetMacAddress (dev), channelType);
1974  AddToIpv4AddressNodeIdTable (GetIpv4Address (dev), n->GetId ());
1975  }
1976  */
1977  std::vector<std::string> ipv4Addresses = GetIpv4Addresses (dev);
1978  AddToIpv4AddressNodeIdTable (ipv4Addresses, n->GetId ());
1979  std::vector<std::string> ipv6Addresses = GetIpv6Addresses (dev);
1980  AddToIpv6AddressNodeIdTable (ipv6Addresses, n->GetId ());
1981  if (!ipv4Addresses.empty ())
1982  {
1983  NS_LOG_INFO ("Writing Ipv4 link");
1984  WriteNonP2pLinkProperties (n->GetId (), GetIpv4Address (dev) + "~" + GetMacAddress (dev), channelType);
1985  }
1986  else if (!ipv6Addresses.empty ())
1987  {
1988  NS_LOG_INFO ("Writing Ipv6 link");
1989  WriteNonP2pLinkProperties (n->GetId (), GetIpv6Address (dev) + "~" + GetMacAddress (dev), channelType);
1990  }
1991  continue;
1992  }
1993 
1994  else if (channelType == std::string ("ns3::PointToPointChannel"))
1995  { // Since these are duplex links, we only need to dump
1996  // if srcid < dstid
1997  std::size_t nChDev = ch->GetNDevices ();
1998  for (std::size_t j = 0; j < nChDev; ++j)
1999  {
2000  Ptr<NetDevice> chDev = ch->GetDevice (j);
2001  uint32_t n2Id = chDev->GetNode ()->GetId ();
2002  if (n1Id < n2Id)
2003  {
2004 
2005  std::vector<std::string> ipv4Addresses = GetIpv4Addresses (dev);
2006  AddToIpv4AddressNodeIdTable (ipv4Addresses, n1Id);
2007  ipv4Addresses = GetIpv4Addresses (chDev);
2008  AddToIpv4AddressNodeIdTable (ipv4Addresses, n2Id);
2009  std::vector<std::string> ipv6Addresses = GetIpv6Addresses (dev);
2010  AddToIpv6AddressNodeIdTable (ipv6Addresses, n1Id);
2011  ipv6Addresses = GetIpv6Addresses (chDev);
2012  AddToIpv6AddressNodeIdTable (ipv6Addresses, n2Id);
2013 
2014  P2pLinkNodeIdPair p2pPair;
2015  p2pPair.fromNode = n1Id;
2016  p2pPair.toNode = n2Id;
2017  if (!ipv4Addresses.empty ())
2018  {
2019  LinkProperties lp = { GetIpv4Address (dev) + "~" + GetMacAddress (dev), GetIpv4Address (chDev) + "~" + GetMacAddress (chDev), "" };
2020  m_linkProperties[p2pPair] = lp;
2021  }
2022  else if (!ipv6Addresses.empty ())
2023  {
2024  LinkProperties lp = { GetIpv6Address (dev) + "~" + GetMacAddress (dev), GetIpv6Address (chDev) + "~" + GetMacAddress (chDev), "" };
2025  m_linkProperties[p2pPair] = lp;
2026  }
2027  WriteXmlLink (n1Id, 0, n2Id);
2028  }
2029  }
2030  }
2031  }
2032  }
2033  m_linkProperties.clear ();
2034 }
2035 
2036 void
2038 {
2039  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
2040  {
2041  Ptr<Node> n = *i;
2042  NS_LOG_INFO ("Update Position for Node: " << n->GetId ());
2043  Vector v = UpdatePosition (n);
2044  WriteXmlNode (n->GetId (), n->GetSystemId (), v.x, v.y);
2045  }
2046 }
2047 
2048 void
2050 {
2051  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
2052  {
2053  Ptr<Node> n = *i;
2054  Rgb rgb = {255, 0, 0};
2055  if (m_nodeColors.find (n->GetId ()) == m_nodeColors.end ())
2056  {
2057  m_nodeColors[n->GetId ()] = rgb;
2058  }
2059  UpdateNodeColor (n, rgb.r, rgb.g, rgb.b);
2060  }
2061 }
2062 
2063 void
2065 {
2066  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
2067  {
2068  Ptr<Node> n = *i;
2069  NS_LOG_INFO ("Update Size for Node: " << n->GetId ());
2070  AnimationInterface::NodeSize s = { 1, 1 };
2071  m_nodeSizes[n->GetId ()] = s;
2072  UpdateNodeSize (n->GetId (), s.width, s.height);
2073  }
2074 }
2075 
2076 void
2078 {
2080  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
2081  {
2082  Ptr<Node> n = *i;
2083  if (NodeList::GetNode (n->GetId ())->GetObject<EnergySource> ())
2084  {
2086  }
2087  }
2088 }
2089 
2090 bool
2092 {
2093  if ((Simulator::Now () >= m_startTime)
2094  && (Simulator::Now () <= m_stopTime))
2095  {
2096  return true;
2097  }
2098  else
2099  {
2100  return false;
2101  }
2102 }
2103 
2104 void
2105 AnimationInterface::SetOutputFile (const std::string& fn, bool routing)
2106 {
2107  if (!routing && m_f)
2108  {
2109  return;
2110  }
2111  if (routing && m_routingF)
2112  {
2113  NS_FATAL_ERROR ("SetRoutingOutputFile already used once");
2114  return;
2115  }
2116 
2117  NS_LOG_INFO ("Creating new trace file:" << fn.c_str ());
2118  FILE * f = 0;
2119  f = std::fopen (fn.c_str (), "w");
2120  if (!f)
2121  {
2122  NS_FATAL_ERROR ("Unable to open output file:" << fn.c_str ());
2123  return; // Can't open output file
2124  }
2125  if (routing)
2126  {
2127  m_routingF = f;
2128  m_routingFileName = fn;
2129  }
2130  else
2131  {
2132  m_f = f;
2133  m_outputFileName = fn;
2134  }
2135  return;
2136 }
2137 
2138 void
2140 {
2141  // Start a new trace file if the current packet count exceeded nax packets per file
2144  {
2145  return;
2146  }
2147  NS_LOG_UNCOND ("Max Packets per trace file exceeded");
2148  StopAnimation (true);
2149 }
2150 
2151 std::string
2153 {
2154  return NETANIM_VERSION;
2155 }
2156 
2157 
2158 void
2160 {
2162  {
2163  NS_LOG_INFO ("TrackQueueCounters Completed");
2164  return;
2165  }
2166  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
2167  {
2168  uint32_t nodeId = Ptr <Node> (*i)->GetId ();
2172  }
2174 }
2175 
2176 void
2178 {
2180  {
2181  NS_LOG_INFO ("TrackWifiMacCounters Completed");
2182  return;
2183  }
2184  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
2185  {
2186  uint32_t nodeId = Ptr <Node> (*i)->GetId ();
2191  }
2193 }
2194 
2195 void
2197 {
2199  {
2200  NS_LOG_INFO ("TrackWifiPhyCounters Completed");
2201  return;
2202  }
2203  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
2204  {
2205  uint32_t nodeId = Ptr <Node> (*i)->GetId ();
2208  }
2210 }
2211 
2212 void
2214 {
2216  {
2217  NS_LOG_INFO ("TrackIpv4L3ProtocolCounters Completed");
2218  return;
2219  }
2220  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
2221  {
2222  uint32_t nodeId = Ptr <Node> (*i)->GetId ();
2226  }
2228 }
2229 
2230 
2231 
2232 
2233 
2234 /***** Routing-related *****/
2235 
2236 void
2238 {
2239  if (m_ipv4RouteTrackElements.empty ())
2240  {
2241  return;
2242  }
2243  for (std::vector <Ipv4RouteTrackElement>::const_iterator i = m_ipv4RouteTrackElements.begin ();
2244  i != m_ipv4RouteTrackElements.end ();
2245  ++i)
2246  {
2247  Ipv4RouteTrackElement trackElement = *i;
2248  Ptr <Node> fromNode = NodeList::GetNode (trackElement.fromNodeId);
2249  if (!fromNode)
2250  {
2251  NS_FATAL_ERROR ("Node: " << trackElement.fromNodeId << " Not found");
2252  continue;
2253  }
2254  Ptr <ns3::Ipv4> ipv4 = fromNode->GetObject <ns3::Ipv4> ();
2255  if (!ipv4)
2256  {
2257  NS_LOG_WARN ("ipv4 object not found");
2258  continue;
2259  }
2261  if (!rp)
2262  {
2263  NS_LOG_WARN ("Routing protocol object not found");
2264  continue;
2265  }
2266  NS_LOG_INFO ("Begin Track Route for: " << trackElement.destination.c_str () << " From:" << trackElement.fromNodeId);
2267  Ptr<Packet> pkt = Create<Packet> ();
2268  Ipv4Header header;
2269  header.SetDestination (Ipv4Address (trackElement.destination.c_str ()));
2270  Socket::SocketErrno sockerr;
2271  Ptr <Ipv4Route> rt = rp->RouteOutput (pkt, header, 0, sockerr);
2272  Ipv4RoutePathElements rpElements;
2273  if (!rt)
2274  {
2275  NS_LOG_INFO ("No route to :" << trackElement.destination.c_str ());
2276  Ipv4RoutePathElement elem = { trackElement.fromNodeId, "-1" };
2277  rpElements.push_back (elem);
2278  WriteRoutePath (trackElement.fromNodeId, trackElement.destination, rpElements);
2279  continue;
2280  }
2281  std::ostringstream oss;
2282  oss << rt->GetGateway ();
2283  NS_LOG_INFO ("Node:" << trackElement.fromNodeId << "-->" << rt->GetGateway ());
2284  if (rt->GetGateway () == "0.0.0.0")
2285  {
2286  Ipv4RoutePathElement elem = { trackElement.fromNodeId, "C" };
2287  rpElements.push_back (elem);
2288  if ( m_ipv4ToNodeIdMap.find (trackElement.destination) != m_ipv4ToNodeIdMap.end ())
2289  {
2290  Ipv4RoutePathElement elem2 = { m_ipv4ToNodeIdMap[trackElement.destination], "L" };
2291  rpElements.push_back (elem2);
2292  }
2293  }
2294  else if (rt->GetGateway () == "127.0.0.1")
2295  {
2296  Ipv4RoutePathElement elem = { trackElement.fromNodeId, "-1" };
2297  rpElements.push_back (elem);
2298  }
2299  else
2300  {
2301  Ipv4RoutePathElement elem = { trackElement.fromNodeId, oss.str () };
2302  rpElements.push_back (elem);
2303  }
2304  RecursiveIpv4RoutePathSearch (oss.str (), trackElement.destination, rpElements);
2305  WriteRoutePath (trackElement.fromNodeId, trackElement.destination, rpElements);
2306  }
2307 
2308 }
2309 
2310 void
2312 {
2314  {
2315  NS_LOG_INFO ("TrackIpv4Route completed");
2316  return;
2317  }
2318  if (m_routingNc.GetN ())
2319  {
2320  for (NodeContainer::Iterator i = m_routingNc.Begin (); i != m_routingNc.End (); ++i)
2321  {
2322  Ptr <Node> n = *i;
2323  WriteXmlRouting (n->GetId (), GetIpv4RoutingTable (n));
2324  }
2325  }
2326  else
2327  {
2328  for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
2329  {
2330  Ptr <Node> n = *i;
2331  WriteXmlRouting (n->GetId (), GetIpv4RoutingTable (n));
2332  }
2333  }
2336 }
2337 
2338 std::string
2340 {
2341 
2342  NS_ASSERT (n);
2343  Ptr <ns3::Ipv4> ipv4 = n->GetObject <ns3::Ipv4> ();
2344  if (!ipv4)
2345  {
2346  NS_LOG_WARN ("Node " << n->GetId () << " Does not have an Ipv4 object");
2347  return "";
2348  }
2349  std::stringstream stream;
2350  Ptr<OutputStreamWrapper> routingstream = Create<OutputStreamWrapper> (&stream);
2351  ipv4->GetRoutingProtocol ()->PrintRoutingTable (routingstream);
2352  return stream.str ();
2353 
2354 }
2355 
2356 void
2357 AnimationInterface::RecursiveIpv4RoutePathSearch (std::string from, std::string to, Ipv4RoutePathElements & rpElements)
2358 {
2359  NS_LOG_INFO ("RecursiveIpv4RoutePathSearch from:" << from.c_str () << " to:" << to.c_str ());
2360  if ((from == "0.0.0.0") || (from == "127.0.0.1"))
2361  {
2362  NS_LOG_INFO ("Got " << from.c_str () << " End recursion");
2363  return;
2364  }
2365  Ptr <Node> fromNode = NodeList::GetNode (m_ipv4ToNodeIdMap[from]);
2367  if (fromNode->GetId () == toNode->GetId ())
2368  {
2369  Ipv4RoutePathElement elem = { fromNode->GetId (), "L" };
2370  rpElements.push_back (elem);
2371  return;
2372  }
2373  if (!fromNode)
2374  {
2375  NS_FATAL_ERROR ("Node: " << m_ipv4ToNodeIdMap[from] << " Not found");
2376  return;
2377  }
2378  if (!toNode)
2379  {
2380  NS_FATAL_ERROR ("Node: " << m_ipv4ToNodeIdMap[to] << " Not found");
2381  return;
2382  }
2383  Ptr <ns3::Ipv4> ipv4 = fromNode->GetObject <ns3::Ipv4> ();
2384  if (!ipv4)
2385  {
2386  NS_LOG_WARN ("ipv4 object not found");
2387  return;
2388  }
2390  if (!rp)
2391  {
2392  NS_LOG_WARN ("Routing protocol object not found");
2393  return;
2394  }
2395  Ptr<Packet> pkt = Create<Packet> ();
2396  Ipv4Header header;
2397  header.SetDestination (Ipv4Address (to.c_str ()));
2398  Socket::SocketErrno sockerr;
2399  Ptr <Ipv4Route> rt = rp->RouteOutput (pkt, header, 0, sockerr);
2400  if (!rt)
2401  {
2402  return;
2403  }
2404  NS_LOG_DEBUG ("Node: " << fromNode->GetId () << " G:" << rt->GetGateway ());
2405  std::ostringstream oss;
2406  oss << rt->GetGateway ();
2407  if (oss.str () == "0.0.0.0" && (sockerr != Socket::ERROR_NOROUTETOHOST))
2408  {
2409  NS_LOG_INFO ("Null gw");
2410  Ipv4RoutePathElement elem = { fromNode->GetId (), "C" };
2411  rpElements.push_back (elem);
2412  if ( m_ipv4ToNodeIdMap.find (to) != m_ipv4ToNodeIdMap.end ())
2413  {
2414  Ipv4RoutePathElement elem2 = { m_ipv4ToNodeIdMap[to], "L" };
2415  rpElements.push_back (elem2);
2416  }
2417  return;
2418  }
2419  NS_LOG_INFO ("Node:" << fromNode->GetId () << "-->" << rt->GetGateway ());
2420  Ipv4RoutePathElement elem = { fromNode->GetId (), oss.str () };
2421  rpElements.push_back (elem);
2422  RecursiveIpv4RoutePathSearch (oss.str (), to, rpElements);
2423 
2424 }
2425 
2426 
2427 
2428 /***** WriteXml *****/
2429 
2430 void
2432 {
2433  AnimXmlElement element ("anim");
2434  element.AddAttribute ("ver", GetNetAnimVersion ());
2435  FILE * f = m_f;
2436  if (!routing)
2437  {
2438  element.AddAttribute ("filetype", "animation");
2439  }
2440  else
2441  {
2442  element.AddAttribute ("filetype", "routing");
2443  f = m_routingF;
2444  }
2445  WriteN (element.ToString (false) + ">\n", f);
2446 }
2447 
2448 void
2449 AnimationInterface::WriteXmlClose (std::string name, bool routing)
2450 {
2451  std::string closeString = "</" + name + ">\n";
2452  if (!routing)
2453  {
2454  WriteN (closeString, m_f);
2455  }
2456  else
2457  {
2458  WriteN (closeString, m_routingF);
2459  }
2460 }
2461 
2462 void
2463 AnimationInterface::WriteXmlNode (uint32_t id, uint32_t sysId, double locX, double locY)
2464 {
2465  AnimXmlElement element ("node");
2466  element.AddAttribute ("id", id);
2467  element.AddAttribute ("sysId", sysId);
2468  element.AddAttribute ("locX", locX);
2469  element.AddAttribute ("locY", locY);
2470  WriteN (element.ToString (), m_f);
2471 }
2472 
2473 void
2474 AnimationInterface::WriteXmlUpdateLink (uint32_t fromId, uint32_t toId, std::string linkDescription)
2475 {
2476  AnimXmlElement element ("linkupdate");
2477  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
2478  element.AddAttribute ("fromId", fromId);
2479  element.AddAttribute ("toId", toId);
2480  element.AddAttribute ("ld", linkDescription, true);
2481  WriteN (element.ToString (), m_f);
2482 }
2483 
2484 void
2486 {
2487  AnimXmlElement element ("link");
2488  element.AddAttribute ("fromId", fromId);
2489  element.AddAttribute ("toId", toId);
2490 
2491  LinkProperties lprop;
2492  lprop.fromNodeDescription = "";
2493  lprop.toNodeDescription = "";
2494  lprop.linkDescription = "";
2495 
2496  P2pLinkNodeIdPair p1 = { fromId, toId };
2497  P2pLinkNodeIdPair p2 = { toId, fromId };
2498  if (m_linkProperties.find (p1) != m_linkProperties.end ())
2499  {
2500  lprop = m_linkProperties[p1];
2501  }
2502  else if (m_linkProperties.find (p2) != m_linkProperties.end ())
2503  {
2504  lprop = m_linkProperties[p2];
2505  }
2506 
2507  element.AddAttribute ("fd", lprop.fromNodeDescription, true);
2508  element.AddAttribute ("td", lprop.toNodeDescription, true);
2509  element.AddAttribute ("ld", lprop.linkDescription, true);
2510  WriteN (element.ToString (), m_f);
2511 }
2512 
2513 void
2514 AnimationInterface::WriteXmlIpv4Addresses (uint32_t nodeId, std::vector<std::string> ipv4Addresses)
2515 {
2516  AnimXmlElement element ("ip");
2517  element.AddAttribute ("n", nodeId);
2518  for (std::vector<std::string>::const_iterator i = ipv4Addresses.begin ();
2519  i != ipv4Addresses.end ();
2520  ++i)
2521  {
2522  AnimXmlElement valueElement ("address");
2523  valueElement.SetText (*i);
2524  element.AppendChild (valueElement);
2525  }
2526  WriteN (element.ToString (), m_f);
2527 }
2528 
2529 void
2530 AnimationInterface::WriteXmlIpv6Addresses (uint32_t nodeId, std::vector<std::string> ipv6Addresses)
2531 {
2532  AnimXmlElement element ("ipv6");
2533  element.AddAttribute ("n", nodeId);
2534  for (std::vector<std::string>::const_iterator i = ipv6Addresses.begin ();
2535  i != ipv6Addresses.end ();
2536  ++i)
2537  {
2538  AnimXmlElement valueElement ("address");
2539  valueElement.SetText (*i);
2540  element.AppendChild (valueElement);
2541  }
2542  WriteN (element.ToString (), m_f);
2543 }
2544 
2545 void
2546 AnimationInterface::WriteXmlRouting (uint32_t nodeId, std::string routingInfo)
2547 {
2548  AnimXmlElement element ("rt");
2549  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
2550  element.AddAttribute ("id", nodeId);
2551  element.AddAttribute ("info", routingInfo.c_str (), true);
2552  WriteN (element.ToString (), m_routingF);
2553 }
2554 
2555 void
2556 AnimationInterface::WriteXmlRp (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements)
2557 {
2558  std::string tagName = "rp";
2559  AnimXmlElement element (tagName, false);
2560  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
2561  element.AddAttribute ("id", nodeId);
2562  element.AddAttribute ("d", destination.c_str ());
2563  element.AddAttribute ("c", rpElements.size ());
2564  for (Ipv4RoutePathElements::const_iterator i = rpElements.begin ();
2565  i != rpElements.end ();
2566  ++i)
2567  {
2568  Ipv4RoutePathElement rpElement = *i;
2569  AnimXmlElement rpeElement ("rpe");
2570  rpeElement.AddAttribute ("n", rpElement.nodeId);
2571  rpeElement.AddAttribute ("nH", rpElement.nextHop.c_str ());
2572  element.AppendChild (rpeElement);
2573  }
2574  WriteN (element.ToString (), m_routingF);
2575 }
2576 
2577 
2578 void
2579 AnimationInterface::WriteXmlPRef (uint64_t animUid, uint32_t fId, double fbTx, std::string metaInfo)
2580 {
2581  AnimXmlElement element ("pr");
2582  element.AddAttribute ("uId", animUid);
2583  element.AddAttribute ("fId", fId);
2584  element.AddAttribute ("fbTx", fbTx);
2585  if (!metaInfo.empty ())
2586  {
2587  element.AddAttribute ("meta-info", metaInfo.c_str (), true);
2588  }
2589  WriteN (element.ToString (), m_f);
2590 }
2591 
2592 void
2593 AnimationInterface::WriteXmlP (uint64_t animUid, std::string pktType, uint32_t tId, double fbRx, double lbRx)
2594 {
2595  AnimXmlElement element (pktType);
2596  element.AddAttribute ("uId", animUid);
2597  element.AddAttribute ("tId", tId);
2598  element.AddAttribute ("fbRx", fbRx);
2599  element.AddAttribute ("lbRx", lbRx);
2600  WriteN (element.ToString (), m_f);
2601 }
2602 
2603 void
2604 AnimationInterface::WriteXmlP (std::string pktType, uint32_t fId, double fbTx, double lbTx,
2605  uint32_t tId, double fbRx, double lbRx, std::string metaInfo)
2606 {
2607  AnimXmlElement element (pktType);
2608  element.AddAttribute ("fId", fId);
2609  element.AddAttribute ("fbTx", fbTx);
2610  element.AddAttribute ("lbTx", lbTx);
2611  if (!metaInfo.empty ())
2612  {
2613  element.AddAttribute ("meta-info", metaInfo.c_str (), true);
2614  }
2615  element.AddAttribute ("tId", tId);
2616  element.AddAttribute ("fbRx", fbRx);
2617  element.AddAttribute ("lbRx", lbRx);
2618  WriteN (element.ToString (), m_f);
2619 }
2620 
2621 void
2622 AnimationInterface::WriteXmlAddNodeCounter (uint32_t nodeCounterId, std::string counterName, CounterType counterType)
2623 {
2624  AnimXmlElement element ("ncs");
2625  element.AddAttribute ("ncId", nodeCounterId);
2626  element.AddAttribute ("n", counterName);
2627  element.AddAttribute ("t", CounterTypeToString (counterType));
2628  WriteN (element.ToString (), m_f);
2629 }
2630 
2631 void
2632 AnimationInterface::WriteXmlAddResource (uint32_t resourceId, std::string resourcePath)
2633 {
2634  AnimXmlElement element ("res");
2635  element.AddAttribute ("rid", resourceId);
2636  element.AddAttribute ("p", resourcePath);
2637  WriteN (element.ToString (), m_f);
2638 }
2639 
2640 void
2642 {
2643  AnimXmlElement element ("nu");
2644  element.AddAttribute ("p", "i");
2645  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
2646  element.AddAttribute ("id", nodeId);
2647  element.AddAttribute ("rid", resourceId);
2648  WriteN (element.ToString (), m_f);
2649 }
2650 
2651 void
2652 AnimationInterface::WriteXmlUpdateNodeSize (uint32_t nodeId, double width, double height)
2653 {
2654  AnimXmlElement element ("nu");
2655  element.AddAttribute ("p", "s");
2656  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
2657  element.AddAttribute ("id", nodeId);
2658  element.AddAttribute ("w", width);
2659  element.AddAttribute ("h", height);
2660  WriteN (element.ToString (), m_f);
2661 }
2662 
2663 void
2665 {
2666  AnimXmlElement element ("nu");
2667  element.AddAttribute ("p", "p");
2668  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
2669  element.AddAttribute ("id", nodeId);
2670  element.AddAttribute ("x", x);
2671  element.AddAttribute ("y", y);
2672  WriteN (element.ToString (), m_f);
2673 }
2674 
2675 void
2676 AnimationInterface::WriteXmlUpdateNodeColor (uint32_t nodeId, uint8_t r, uint8_t g, uint8_t b)
2677 {
2678  AnimXmlElement element ("nu");
2679  element.AddAttribute ("p", "c");
2680  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
2681  element.AddAttribute ("id", nodeId);
2682  element.AddAttribute ("r", (uint32_t) r);
2683  element.AddAttribute ("g", (uint32_t) g);
2684  element.AddAttribute ("b", (uint32_t) b);
2685  WriteN (element.ToString (), m_f);
2686 }
2687 
2688 void
2690 {
2691  AnimXmlElement element ("nu");
2692  element.AddAttribute ("p", "d");
2693  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
2694  element.AddAttribute ("id", nodeId);
2695  if (m_nodeDescriptions.find (nodeId) != m_nodeDescriptions.end ())
2696  {
2697  element.AddAttribute ("descr", m_nodeDescriptions[nodeId], true);
2698  }
2699  WriteN (element.ToString (), m_f);
2700 }
2701 
2702 
2703 void
2704 AnimationInterface::WriteXmlUpdateNodeCounter (uint32_t nodeCounterId, uint32_t nodeId, double counterValue)
2705 {
2706  AnimXmlElement element ("nc");
2707  element.AddAttribute ("c", nodeCounterId);
2708  element.AddAttribute ("i", nodeId);
2709  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
2710  element.AddAttribute ("v", counterValue);
2711  WriteN (element.ToString (), m_f);
2712 }
2713 
2714 void
2715 AnimationInterface::WriteXmlUpdateBackground (std::string fileName, double x, double y, double scaleX, double scaleY, double opacity)
2716 {
2717  AnimXmlElement element ("bg");
2718  element.AddAttribute ("f", fileName);
2719  element.AddAttribute ("x", x);
2720  element.AddAttribute ("y", y);
2721  element.AddAttribute ("sx", scaleX);
2722  element.AddAttribute ("sy", scaleY);
2723  element.AddAttribute ("o", opacity);
2724  WriteN (element.ToString (), m_f);
2725 }
2726 
2727 void
2728 AnimationInterface::WriteXmlNonP2pLinkProperties (uint32_t id, std::string ipAddress, std::string channelType)
2729 {
2730  AnimXmlElement element ("nonp2plinkproperties");
2731  element.AddAttribute ("id", id);
2732  element.AddAttribute ("ipAddress", ipAddress);
2733  element.AddAttribute ("channelType", channelType);
2734  WriteN (element.ToString (), m_f);
2735 }
2736 
2737 
2738 
2739 /***** AnimXmlElement *****/
2740 
2741 AnimationInterface::AnimXmlElement::AnimXmlElement (std::string tagName, bool emptyElement)
2742  : m_tagName (tagName),
2743  m_text ("")
2744 {
2745 }
2746 
2747 template <typename T>
2748 void
2749 AnimationInterface::AnimXmlElement::AddAttribute (std::string attribute, T value, bool xmlEscape)
2750 {
2751  std::ostringstream oss;
2752  oss << std::setprecision (10);
2753  oss << value;
2754  std::string attributeString = attribute.c_str ();
2755  if (xmlEscape)
2756  {
2757  attributeString += "=\"";
2758  std::string valueStr = oss.str ();
2759  for (std::string::iterator it = valueStr.begin (); it != valueStr.end (); ++it)
2760  {
2761  switch (*it)
2762  {
2763  case '&':
2764  attributeString += "&amp;";
2765  break;
2766  case '\"':
2767  attributeString += "&quot;";
2768  break;
2769  case '\'':
2770  attributeString += "&apos;";
2771  break;
2772  case '<':
2773  attributeString += "&lt;";
2774  break;
2775  case '>':
2776  attributeString += "&gt;";
2777  break;
2778  default:
2779  attributeString += *it;
2780  break;
2781  }
2782  }
2783  attributeString += "\" ";
2784  }
2785  else
2786  {
2787  attributeString += "=\"" + oss.str () + "\" ";
2788  }
2789  m_attributes.push_back (attributeString);
2790 }
2791 
2792 void
2794 {
2795  m_children.push_back (e.ToString ());
2796 }
2797 
2798 void
2800 {
2801  m_text = text;
2802 }
2803 
2804 std::string
2806 {
2807  std::string elementString = "<" + m_tagName + " ";
2808 
2809 
2810  for (std::vector<std::string>::const_iterator i = m_attributes.begin ();
2811  i != m_attributes.end ();
2812  ++i)
2813  {
2814  elementString += *i;
2815  }
2816  if (m_children.empty () && m_text.empty ())
2817  {
2818  if (autoClose)
2819  {
2820  elementString += "/>";
2821  }
2822  }
2823  else
2824  {
2825  elementString += ">";
2826  if (!m_text.empty ())
2827  {
2828  elementString += m_text;
2829  }
2830  if (!m_children.empty ())
2831  {
2832  elementString += "\n";
2833  for (std::vector<std::string>::const_iterator i = m_children.begin ();
2834  i != m_children.end ();
2835  ++i)
2836  {
2837  elementString += *i + "\n";
2838  }
2839 
2840  }
2841  if (autoClose)
2842  {
2843  elementString += "</" + m_tagName + ">";
2844  }
2845  }
2846 
2847 
2848  return elementString + ((autoClose) ? "\n" : "");
2849 }
2850 
2851 
2852 
2853 
2854 
2855 /***** AnimByteTag *****/
2856 
2857 TypeId
2859 {
2860  static TypeId tid = TypeId ("ns3::AnimByteTag")
2861  .SetParent<Tag> ()
2862  .SetGroupName ("NetAnim")
2863  .AddConstructor<AnimByteTag> ()
2864  ;
2865  return tid;
2866 }
2867 
2868 TypeId
2870 {
2871  return GetTypeId ();
2872 }
2873 
2874 uint32_t
2876 {
2877  return sizeof (uint64_t);
2878 }
2879 
2880 void
2882 {
2883  i.WriteU64 (m_AnimUid);
2884 }
2885 
2886 void
2888 {
2889  m_AnimUid = i.ReadU64 ();
2890 }
2891 
2892 void
2893 AnimByteTag::Print (std::ostream &os) const
2894 {
2895  os << "AnimUid=" << m_AnimUid;
2896 }
2897 
2898 void
2899 AnimByteTag::Set (uint64_t AnimUid)
2900 {
2901  m_AnimUid = AnimUid;
2902 }
2903 
2904 uint64_t
2905 AnimByteTag::Get (void) const
2906 {
2907  return m_AnimUid;
2908 }
2909 
2911  : m_txnd (0),
2912  m_txNodeId (0),
2913  m_fbTx (0),
2914  m_lbTx (0),
2915  m_lbRx (0)
2916 {
2917 }
2918 
2920 {
2921  m_txnd = pInfo.m_txnd;
2922  m_txNodeId = pInfo.m_txNodeId;
2923  m_fbTx = pInfo.m_fbTx;
2924  m_lbTx = pInfo.m_lbTx;
2925  m_lbRx = pInfo.m_lbRx;
2926 }
2927 
2929  const Time fbTx,
2930  uint32_t txNodeId)
2931  : m_txnd (txnd),
2932  m_txNodeId (0),
2933  m_fbTx (fbTx.GetSeconds ()),
2934  m_lbTx (0),
2935  m_lbRx (0)
2936 {
2937  if (!m_txnd)
2938  {
2939  m_txNodeId = txNodeId;
2940  }
2941 }
2942 
2943 void
2945 {
2946  Ptr <Node> n = nd->GetNode ();
2947  m_fbRx = fbRx;
2948  m_rxnd = nd;
2949 }
2950 
2951 } // namespace ns3
ns3::AnimationInterface::WriteRoutePath
void WriteRoutePath(uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements)
Write route path function.
Definition: animation-interface.cc:539
ns3::AnimationInterface::EnableQueueCounters
void EnableQueueCounters(Time startTime, Time stopTime, Time pollInterval=Seconds(1))
Enable tracking of Queue Counters such as Enqueue, Dequeue, Queue Drops.
Definition: animation-interface.cc:152
ns3::AnimationInterface::WriteNonP2pLinkProperties
void WriteNonP2pLinkProperties(uint32_t id, std::string ipv4Address, std::string channelType)
Write non P2P link properties function.
Definition: animation-interface.cc:556
ns3::AnimationInterface::WavePhyRxBeginTrace
void WavePhyRxBeginTrace(std::string context, Ptr< const Packet > p)
WAVE Phy receive begin trace function.
Definition: animation-interface.cc:1036
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::AnimationInterface::m_queueCountersPollInterval
Time m_queueCountersPollInterval
queue counters poll interval
Definition: animation-interface.h:607
ns3::Ipv4Header
Packet header for IPv4.
Definition: ipv4-header.h:34
ns3::AnimationInterface::m_routingPollInterval
Time m_routingPollInterval
routing poll interval
Definition: animation-interface.h:602
ns3::AnimationInterface::EnableWifiMacCounters
void EnableWifiMacCounters(Time startTime, Time stopTime, Time pollInterval=Seconds(1))
Enable tracking of Wifi Mac Counters such as Tx, TxDrop, Rx, RxDrop.
Definition: animation-interface.cc:128
ns3::AnimationInterface::m_wifiPhyTxDropCounterId
uint32_t m_wifiPhyTxDropCounterId
wifi Phy transmit drop counter ID
Definition: animation-interface.h:631
ns3::AnimationInterface::NodeSize
NodeSize structure.
Definition: animation-interface.h:520
rgb::b
uint8_t b
blue
Definition: colors-link-description.cc:37
ns3::AnimationInterface::PurgePendingPackets
void PurgePendingPackets(ProtocolType protocolType)
Purge pending packets function.
Definition: animation-interface.cc:1308
ns3::Config::ConnectWithoutContextFailSafe
bool ConnectWithoutContextFailSafe(std::string path, const CallbackBase &cb)
Definition: config.cc:909
ns3::Ipv6InterfaceAddress
IPv6 address associated with an interface.
Definition: ipv6-interface-address.h:38
ns3::AnimationInterface::UINT32_COUNTER
@ UINT32_COUNTER
Definition: animation-interface.h:90
ns3::AnimationInterface::WriteNodeColors
void WriteNodeColors()
Write node colors function.
Definition: animation-interface.cc:2049
ns3::AnimationInterface::ConnectLteUe
void ConnectLteUe(Ptr< Node > n, Ptr< LteUeNetDevice > nd, uint32_t devIndex)
Connect LTE ue function.
Definition: animation-interface.cc:1574
ns3::AnimationInterface::WriteNodeSizes
void WriteNodeSizes()
Write node sizes function.
Definition: animation-interface.cc:2064
ns3::AnimationInterface::WIMAX
@ WIMAX
Definition: animation-interface.h:512
ns3::AnimationInterface::UpdateNodeColor
void UpdateNodeColor(Ptr< Node > n, uint8_t r, uint8_t g, uint8_t b)
Helper function to update the node color.
Definition: animation-interface.cc:352
stopTime
Time stopTime
Definition: tcp-linux-reno.cc:52
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::AnimationInterface::m_nodeWifiMacTxDrop
NodeCounterMap64 m_nodeWifiMacTxDrop
node wifi MAC transmit drop
Definition: animation-interface.h:667
ns3::AnimationInterface::SetMaxPktsPerTraceFile
void SetMaxPktsPerTraceFile(uint64_t maxPktsPerFile)
Set Max packets per trace file.
Definition: animation-interface.cc:232
ns3::AnimationInterface::WriteXmlIpv6Addresses
void WriteXmlIpv6Addresses(uint32_t nodeId, std::vector< std::string > ipv6Addresses)
Write XML Ipv6 addresses function.
Definition: animation-interface.cc:2530
ns3::AnimationInterface::m_linkProperties
LinkPropertiesMap m_linkProperties
link properties
Definition: animation-interface.h:651
ns3::AnimationInterface::CheckMaxPktsPerTraceFile
void CheckMaxPktsPerTraceFile()
Check maximum packets per trace file function.
Definition: animation-interface.cc:2139
ns3::Packet::PeekHeader
uint32_t PeekHeader(Header &header) const
Deserialize but does not remove the header from the internal buffer.
Definition: packet.cc:290
ns3::AnimationInterface::Ipv4RouteTrackElement::fromNodeId
uint32_t fromNodeId
from node ID
Definition: animation-interface.h:496
ns3::AnimationInterface::AnimPacketInfo::ProcessRxBegin
void ProcessRxBegin(Ptr< const NetDevice > nd, const double fbRx)
Process receive begin.
Definition: animation-interface.cc:2944
ns3::ByteTagIterator::Item::GetTypeId
TypeId GetTypeId(void) const
Definition: packet.cc:34
ns3::AnimationInterface::UpdateNodeCounter
void UpdateNodeCounter(uint32_t nodeCounterId, uint32_t nodeId, double counter)
Helper function to update a node's counter referenced by the nodeCounterId.
Definition: animation-interface.cc:324
ns3::AnimationInterface::GetPacketMetadata
std::string GetPacketMetadata(Ptr< const Packet > p)
Get packet metadata function.
Definition: animation-interface.cc:1453
ns3::AnimationInterface::AnimXmlElement::AppendChild
void AppendChild(AnimXmlElement e)
Append child function.
Definition: animation-interface.cc:2793
ns3::AnimationInterface::WriteXmlUpdateBackground
void WriteXmlUpdateBackground(std::string fileName, double x, double y, double scaleX, double scaleY, double opacity)
Write XML update background function.
Definition: animation-interface.cc:2715
ns3::AnimationInterface::ConnectCallbacks
void ConnectCallbacks()
Connect callbacks function.
Definition: animation-interface.cc:1628
ns3::AnimationInterface::AnimXmlElement::ToString
std::string ToString(bool autoClose=true)
Get text for the element function.
Definition: animation-interface.cc:2805
ns3::NodeList::Begin
static Iterator Begin(void)
Definition: node-list.cc:229
ns3::AnimationInterface::WriteXmlLink
void WriteXmlLink(uint32_t fromId, uint32_t toLp, uint32_t toId)
Write XML link counter function.
Definition: animation-interface.cc:2485
ns3::AnimationInterface::EnableWifiPhyCounters
void EnableWifiPhyCounters(Time startTime, Time stopTime, Time pollInterval=Seconds(1))
Enable tracking of Wifi Phy Counters such as TxDrop, RxDrop.
Definition: animation-interface.cc:109
ns3::AnimationInterface::m_nodeIpv4Rx
NodeCounterMap64 m_nodeIpv4Rx
node IPv4 receive
Definition: animation-interface.h:662
ns3::AnimationInterface::NodeIdIpv6Pair
std::pair< uint32_t, std::string > NodeIdIpv6Pair
NodeIdIpv6Pair typedef.
Definition: animation-interface.h:533
ns3::Node::GetId
uint32_t GetId(void) const
Definition: node.cc:109
ns3::Socket::SocketErrno
SocketErrno
Enumeration of the possible errors returned by a socket.
Definition: socket.h:82
ns3::AnimationInterface::m_nodeLrWpanMacRx
NodeCounterMap64 m_nodeLrWpanMacRx
node LR-WPAN MAC receive
Definition: animation-interface.h:674
ns3::AnimationInterface::DequeueTrace
void DequeueTrace(std::string context, Ptr< const Packet >)
Dequeue trace function.
Definition: animation-interface.cc:763
ns3::NetDevice::GetAddress
virtual Address GetAddress(void) const =0
ns3::AnimationInterface::ProtocolType
ProtocolType
ProtocolType enumeration.
Definition: animation-interface.h:508
ns3::ConstantPositionMobilityModel
Mobility model for which the current position does not change once it has been set and until it is se...
Definition: constant-position-mobility-model.h:33
ns3::AnimationInterface::m_nodeIpv4Tx
NodeCounterMap64 m_nodeIpv4Tx
node IPv4 transmit
Definition: animation-interface.h:661
ns3::Simulator::Now
static Time Now(void)
Return the current simulation virtual time.
Definition: simulator.cc:195
ns3::AnimationInterface::m_macToNodeIdMap
std::map< std::string, uint32_t > m_macToNodeIdMap
MAC to node ID map.
Definition: animation-interface.h:643
ns3::AnimationInterface::QueueDropTrace
void QueueDropTrace(std::string context, Ptr< const Packet >)
Queue trace function.
Definition: animation-interface.cc:771
ns3::AnimationInterface::TrackIpv4Route
void TrackIpv4Route()
Track IPv4 router function.
Definition: animation-interface.cc:2311
ns3::ByteTagIterator::Item::GetTag
void GetTag(Tag &tag) const
Read the requested tag and store it in the user-provided tag instance.
Definition: packet.cc:49
ns3::AnimationInterface::Ipv4RoutePathElement::nextHop
std::string nextHop
next hop
Definition: animation-interface.h:503
ns3::AnimationInterface::m_stopTime
Time m_stopTime
stop time
Definition: animation-interface.h:597
ns3::AnimByteTag::Deserialize
virtual void Deserialize(TagBuffer i)
Deserialize function.
Definition: animation-interface.cc:2887
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::Ipv6InterfaceAddress::GetAddress
Ipv6Address GetAddress() const
Get the IPv6 address.
Definition: ipv6-interface-address.cc:89
ns3::AnimationInterface::gAnimUid
uint64_t gAnimUid
Packet unique identifier used by AnimationInterface.
Definition: animation-interface.h:592
PURGE_INTERVAL
#define PURGE_INTERVAL
Definition: animation-interface.h:52
ns3::AnimationInterface::AnimPacketInfo::m_fbTx
double m_fbTx
fb transmit
Definition: animation-interface.h:429
ns3::AnimationInterface::Ipv4RoutePathElements
std::vector< Ipv4RoutePathElement > Ipv4RoutePathElements
Ipv4RoutePathElements typedef.
Definition: animation-interface.h:529
ns3::AnimationInterface::m_nodeQueueEnqueue
NodeCounterMap64 m_nodeQueueEnqueue
node queue enqueue
Definition: animation-interface.h:663
ns3::ByteTagIterator::Next
Item Next(void)
Definition: packet.cc:70
ns3::AnimationInterface::LteRxTrace
void LteRxTrace(std::string context, Ptr< const Packet > p, const Mac48Address &m)
LTE receive trace function.
Definition: animation-interface.cc:1096
ns3::AnimationInterface::IsInitialized
static bool IsInitialized(void)
Check if AnimationInterface is initialized.
Definition: animation-interface.cc:266
ns3::AnimationInterface::m_wifiMacTxDropCounterId
uint32_t m_wifiMacTxDropCounterId
wifi MAC transmit drop counter ID
Definition: animation-interface.h:627
ns3::AnimationInterface::AddSourceDestination
AnimationInterface & AddSourceDestination(uint32_t fromNodeId, std::string destinationIpv4Address)
Helper function to print the routing path from a source node to destination IP.
Definition: animation-interface.cc:212
ns3::initialized
static bool initialized
Initialization flag.
Definition: animation-interface.cc:70
ns3::AnimationInterface::WriteN
int WriteN(const char *data, uint32_t count, FILE *f)
WriteN function.
Definition: animation-interface.cc:514
ns3::AnimationInterface::WriteXmlAddResource
void WriteXmlAddResource(uint32_t resourceId, std::string resourcePath)
Write XML add resource function.
Definition: animation-interface.cc:2632
ns3::Mac16Address
This class can contain 16 bit addresses.
Definition: mac16-address.h:42
ns3::AnimationInterface::IsPacketPending
bool IsPacketPending(uint64_t animUid, ProtocolType protocolType)
Is packet pending function.
Definition: animation-interface.cc:1300
ns3::AnimationInterface::GetIpv6Addresses
std::vector< std::string > GetIpv6Addresses(Ptr< NetDevice > nd)
Get IPv6 addresses.
Definition: animation-interface.cc:1879
ns3::AnimationInterface::m_pendingWavePackets
AnimUidPacketInfoMap m_pendingWavePackets
pending WAVE packets
Definition: animation-interface.h:640
ns3::AnimationInterface::EnableIpv4L3ProtocolCounters
void EnableIpv4L3ProtocolCounters(Time startTime, Time stopTime, Time pollInterval=Seconds(1))
Enable tracking of Ipv4 L3 Protocol Counters such as Tx, Rx, Drop.
Definition: animation-interface.cc:173
ns3::AnimationInterface::LrWpanMacTxTrace
void LrWpanMacTxTrace(std::string context, Ptr< const Packet > p)
LR-WPAN MAC transmit trace function.
Definition: animation-interface.cc:701
ns3::Object::GetObject
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
ns3::Packet::EnablePrinting
static void EnablePrinting(void)
Enable printing packets metadata.
Definition: packet.cc:572
ns3::AnimationInterface::m_remainingEnergyCounterId
uint32_t m_remainingEnergyCounterId
remaining energy counter ID
Definition: animation-interface.h:616
ns3::AnimationInterface::SetBackgroundImage
void SetBackgroundImage(std::string fileName, double x, double y, double scaleX, double scaleY, double opacity)
Helper function to set the background image.
Definition: animation-interface.cc:334
ns3::AnimationInterface::GetIpv6Address
std::string GetIpv6Address(Ptr< NetDevice > nd)
Get IPv6 address.
Definition: animation-interface.cc:1815
ns3::Node
A network Node.
Definition: node.h:57
ns3::Config::ConnectFailSafe
bool ConnectFailSafe(std::string path, const CallbackBase &cb)
Definition: config.cc:929
ns3::AnimationInterface::UpdatePosition
Vector UpdatePosition(Ptr< Node > n)
Update position function.
Definition: animation-interface.cc:1737
ns3::AnimationInterface::m_nodeWifiPhyTxDrop
NodeCounterMap64 m_nodeWifiPhyTxDrop
node wifi Phy transmit drop
Definition: animation-interface.h:670
ns3::AnimationInterface::Ipv4RoutePathElement::nodeId
uint32_t nodeId
node ID
Definition: animation-interface.h:502
ns3::AnimationInterface::m_outputFileName
std::string m_outputFileName
output file name
Definition: animation-interface.h:591
ns3::AnimationInterface::m_nodeLrWpanMacRxDrop
NodeCounterMap64 m_nodeLrWpanMacRxDrop
node LR-WPAN MAC receive drop
Definition: animation-interface.h:675
NS_LOG_WARN
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:265
ns3::AnimationInterface::m_nodeWifiMacTx
NodeCounterMap64 m_nodeWifiMacTx
node wifi MAC transmit
Definition: animation-interface.h:666
ns3::AnimationInterface::m_pendingCsmaPackets
AnimUidPacketInfoMap m_pendingCsmaPackets
pending CSMA packets
Definition: animation-interface.h:638
ns3::AnimationInterface::AnimPacketInfo::m_rxnd
Ptr< const NetDevice > m_rxnd
receive device
Definition: animation-interface.h:433
ns3::AnimationInterface::m_nodeSizes
std::map< uint32_t, NodeSize > m_nodeSizes
node sizes
Definition: animation-interface.h:655
ns3::AnimationInterface::m_started
bool m_started
started
Definition: animation-interface.h:594
rgb
RGB structure.
Definition: colors-link-description.cc:34
ns3::Ipv4Address
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
ns3::AnimationInterface::m_wifiMacCountersPollInterval
Time m_wifiMacCountersPollInterval
wifi MAC counters poll interval
Definition: animation-interface.h:609
ns3::Channel::GetDevice
virtual Ptr< NetDevice > GetDevice(std::size_t i) const =0
ns3::AnimationInterface::WriteXmlNode
void WriteXmlNode(uint32_t id, uint32_t sysId, double locX, double locY)
Write XML node function.
Definition: animation-interface.cc:2463
ns3::NodeContainer::GetN
uint32_t GetN(void) const
Get the number of Ptr<Node> stored in this container.
Definition: node-container.cc:88
ns3::AnimByteTag
Byte tag using by Anim to uniquely identify packets.
Definition: animation-interface.h:1477
ns3::AnimationInterface::WriteXmlUpdateNodeDescription
void WriteXmlUpdateNodeDescription(uint32_t nodeId)
Write XML update node description function.
Definition: animation-interface.cc:2689
ns3::AnimationInterface
Interface to network animator.
Definition: animation-interface.h:76
ns3::Mac48Address
an EUI-48 address
Definition: mac48-address.h:44
ns3::AnimationInterface::GetIpv4RoutingTable
std::string GetIpv4RoutingTable(Ptr< Node > n)
Get IPv4 routing table function.
Definition: animation-interface.cc:2339
ns3::AnimationInterface::SetConstantPosition
static void SetConstantPosition(Ptr< Node > n, double x, double y, double z=0)
Helper function to set Constant Position for a given node.
Definition: animation-interface.cc:297
ns3::AnimationInterface::EnqueueTrace
void EnqueueTrace(std::string context, Ptr< const Packet >)
Enqueue trace function.
Definition: animation-interface.cc:755
ns3::ObjectBase::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:256
ns3::Channel::GetNDevices
virtual std::size_t GetNDevices(void) const =0
ns3::WifiTxVector
This class mimics the TXVECTOR which is to be passed to the PHY in order to define the parameters whi...
Definition: wifi-tx-vector.h:71
ns3::AnimByteTag::GetInstanceTypeId
virtual TypeId GetInstanceTypeId(void) const
Get Instance Type Id.
Definition: animation-interface.cc:2869
animation-interface.h
ns3::AnimationInterface::WifiPhyTxDropTrace
void WifiPhyTxDropTrace(std::string context, Ptr< const Packet > p)
wifi Phy transmit drop trace function
Definition: animation-interface.cc:659
ns3::AnimationInterface::WriteXmlAddNodeCounter
void WriteXmlAddNodeCounter(uint32_t counterId, std::string counterName, CounterType counterType)
Write XML add node counter function.
Definition: animation-interface.cc:2622
ns3::AnimationInterface::LrWpanPhyRxBeginTrace
void LrWpanPhyRxBeginTrace(std::string context, Ptr< const Packet > p)
LR-WPAN Phy receive begin trace function.
Definition: animation-interface.cc:1000
ns3::AnimationInterface::CsmaMacRxTrace
void CsmaMacRxTrace(std::string context, Ptr< const Packet > p)
CSMA MAC receive trace function.
Definition: animation-interface.cc:1230
ns3::AnimationInterface::m_trackPackets
bool m_trackPackets
track packets
Definition: animation-interface.h:613
ns3::WifiConstPsduMap
std::unordered_map< uint16_t, Ptr< const WifiPsdu > > WifiConstPsduMap
Map of const PSDUs indexed by STA-ID.
Definition: he-frame-exchange-manager.h:43
ns3::AnimationInterface::m_nodeIdIpv4Map
NodeIdIpv4Map m_nodeIdIpv4Map
node ID to IPv4 map
Definition: animation-interface.h:646
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::Ipv4L3Protocol::DropReason
DropReason
Reason why a packet has been dropped.
Definition: ipv4-l3-protocol.h:102
ns3::Packet::GetByteTagIterator
ByteTagIterator GetByteTagIterator(void) const
Returns an iterator over the set of byte tags included in this packet.
Definition: packet.cc:933
ns3::Mac64Address
an EUI-64 address
Definition: mac64-address.h:44
ns3::ByteTagIterator::Item
Identifies a byte tag and a set of bytes within a packet to which the tag applies.
Definition: packet.h:62
ns3::PeekPointer
U * PeekPointer(const Ptr< U > &p)
Definition: ptr.h:415
ns3::AnimationInterface::m_routingNc
NodeContainer m_routingNc
routing node container
Definition: animation-interface.h:603
ns3::TypeId::SetParent
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41
ns3::AnimationInterface::m_nodeIdIpv6Map
NodeIdIpv6Map m_nodeIdIpv6Map
node ID to IPv6 map
Definition: animation-interface.h:647
ns3::AnimationInterface::NodeSize::height
double height
height
Definition: animation-interface.h:522
ns3::AnimationInterface::AnimUidPacketInfoMap
std::map< uint64_t, AnimPacketInfo > AnimUidPacketInfoMap
AnimUidPacketInfoMap typedef.
Definition: animation-interface.h:527
ns3::AnimationInterface::WriteXmlP
void WriteXmlP(std::string pktType, uint32_t fId, double fbTx, double lbTx, uint32_t tId, double fbRx, double lbRx, std::string metaInfo="")
Write XMLP function.
Definition: animation-interface.cc:2604
ns3::AnimationInterface::StopAnimation
void StopAnimation(bool onlyAnimation=false)
Stop animation function.
Definition: animation-interface.cc:1467
ns3::AnimationInterface::MobilityAutoCheck
void MobilityAutoCheck()
Mobility auto check function.
Definition: animation-interface.cc:445
ns3::AnimationInterface::WriteXmlUpdateNodeSize
void WriteXmlUpdateNodeSize(uint32_t nodeId, double width, double height)
Write XML update node size function.
Definition: animation-interface.cc:2652
ns3::LteEnbNetDevice::GetPhy
Ptr< LteEnbPhy > GetPhy(void) const
Definition: lte-enb-net-device.cc:194
ns3::AnimationInterface::LrWpanPhyTxBeginTrace
void LrWpanPhyTxBeginTrace(std::string context, Ptr< const Packet > p)
LR-WPAN Phy receive begin trace function.
Definition: animation-interface.cc:948
ns3::AnimationInterface::GetIpv4Addresses
std::vector< std::string > GetIpv4Addresses(Ptr< NetDevice > nd)
Get IPv4 addresses.
Definition: animation-interface.cc:1853
ns3::AnimationInterface::m_wifiPhyCountersStopTime
Time m_wifiPhyCountersStopTime
wifi Phy counters stop time
Definition: animation-interface.h:610
ns3::AnimationInterface::GetMovedNodes
std::vector< Ptr< Node > > GetMovedNodes()
Get moved nodes function.
Definition: animation-interface.cc:469
ns3::AnimationInterface::m_ipv4L3ProtocolDropCounterId
uint32_t m_ipv4L3ProtocolDropCounterId
IPv4 protocol drop counter ID.
Definition: animation-interface.h:620
ns3::AnimationInterface::WriteXmlUpdateNodeColor
void WriteXmlUpdateNodeColor(uint32_t nodeId, uint8_t r, uint8_t g, uint8_t b)
Write XML update node color function.
Definition: animation-interface.cc:2676
ns3::AnimationInterface::GetNetAnimVersion
std::string GetNetAnimVersion()
Get netanim version function.
Definition: animation-interface.cc:2152
ns3::WifiMacHeader
Implements the IEEE 802.11 MAC header.
Definition: wifi-mac-header.h:85
ns3::AnimationInterface::CounterType
CounterType
Counter Types.
Definition: animation-interface.h:89
ns3::Ipv4
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:77
ns3::AnimationInterface::m_writeCallback
AnimWriteCallback m_writeCallback
write callback
Definition: animation-interface.h:593
ns3::AnimationInterface::SetOutputFile
void SetOutputFile(const std::string &fn, bool routing=false)
Set output file function.
Definition: animation-interface.cc:2105
ns3::AnimByteTag::Get
uint64_t Get(void) const
Get Uid in tag.
Definition: animation-interface.cc:2905
ns3::AnimationInterface::GenericWirelessRxTrace
void GenericWirelessRxTrace(std::string context, Ptr< const Packet > p, ProtocolType protocolType)
Generic wireless receive trace function.
Definition: animation-interface.cc:837
ns3::AnimationInterface::AddPendingPacket
void AddPendingPacket(ProtocolType protocolType, uint64_t animUid, AnimPacketInfo pktInfo)
Add pending packet function.
Definition: animation-interface.cc:1292
ns3::Ptr< Node >
NS_FATAL_ERROR
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:165
ns3::AnimationInterface::CSMA
@ CSMA
Definition: animation-interface.h:513
ns3::AnimationInterface::m_ipv4L3ProtocolTxCounterId
uint32_t m_ipv4L3ProtocolTxCounterId
IPv4 L3 protocol transmit counter ID.
Definition: animation-interface.h:618
ns3::AnimationInterface::AnimPacketInfo::m_txnd
Ptr< const NetDevice > m_txnd
transmit device
Definition: animation-interface.h:427
ns3::Ipv6Address::IsLinkLocal
bool IsLinkLocal() const
If the IPv6 address is a link-local address (fe80::/64).
Definition: ipv6-address.cc:917
ns3::AnimationInterface::OutputWirelessPacketRxInfo
void OutputWirelessPacketRxInfo(Ptr< const Packet > p, AnimPacketInfo &pktInfo, uint64_t animUid)
Output wireless packet receive info.
Definition: animation-interface.cc:1266
ns3::AnimationInterface::m_wifiMacRxCounterId
uint32_t m_wifiMacRxCounterId
wifi MAC receive counter ID
Definition: animation-interface.h:628
ns3::AnimationInterface::RecursiveIpv4RoutePathSearch
void RecursiveIpv4RoutePathSearch(std::string from, std::string to, Ipv4RoutePathElements &rpElements)
Recursive IPv4 route path search function.
Definition: animation-interface.cc:2357
ns3::AnimationInterface::m_queueEnqueueCounterId
uint32_t m_queueEnqueueCounterId
queue enqueue counter ID
Definition: animation-interface.h:622
ns3::AnimByteTag::GetSerializedSize
virtual uint32_t GetSerializedSize(void) const
Get Serialized Size.
Definition: animation-interface.cc:2875
ns3::WifiPhyRxfailureReason
WifiPhyRxfailureReason
Enumeration of the possible reception failure reasons.
Definition: wifi-phy-common.h:263
ns3::AnimationInterface::UpdateLinkDescription
void UpdateLinkDescription(uint32_t fromNode, uint32_t toNode, std::string linkDescription)
Helper function to update the description for a link.
Definition: animation-interface.cc:368
ns3::AnimationInterface::m_nodeWifiPhyRxDrop
NodeCounterMap64 m_nodeWifiPhyRxDrop
node wifi Phy receive drop
Definition: animation-interface.h:671
ns3::AnimationInterface::WriteXmlUpdateLink
void WriteXmlUpdateLink(uint32_t fromId, uint32_t toId, std::string linkDescription)
Write XML update link counter function.
Definition: animation-interface.cc:2474
ns3::AnimationInterface::WifiPhyRxDropTrace
void WifiPhyRxDropTrace(std::string context, Ptr< const Packet > p, WifiPhyRxfailureReason reason)
wifi Phy receive drop trace function
Definition: animation-interface.cc:666
ns3::AnimationInterface::TrackIpv4L3ProtocolCounters
void TrackIpv4L3ProtocolCounters()
Track IPv4 L3 protocol counters function.
Definition: animation-interface.cc:2213
ns3::NodeList::Iterator
std::vector< Ptr< Node > >::const_iterator Iterator
Node container iterator.
Definition: node-list.h:44
CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS
#define CHECK_STARTED_INTIMEWINDOW_TRACKPACKETS
Definition: animation-interface.h:55
ns3::LrWpanMacHeader::GetSrcAddrMode
uint8_t GetSrcAddrMode(void) const
Get the Source Addressing Mode of Frame control field.
Definition: lr-wpan-mac-header.cc:149
ns3::AnimationInterface::WimaxRxTrace
void WimaxRxTrace(std::string context, Ptr< const Packet > p, const Mac48Address &m)
WIMax receive trace function.
Definition: animation-interface.cc:1082
ns3::AnimationInterface::AnimXmlElement
AnimXmlElement class.
Definition: animation-interface.h:542
ns3::AnimationInterface::EnablePacketMetadata
void EnablePacketMetadata(bool enable=true)
Enable Packet metadata.
Definition: animation-interface.cc:256
ns3::AnimationInterface::LteSpectrumPhyTxStart
void LteSpectrumPhyTxStart(std::string context, Ptr< const PacketBurst > pb)
LTE Spectrum Phy transmit start function.
Definition: animation-interface.cc:1103
ns3::AnimationInterface::SetAnimWriteCallback
void SetAnimWriteCallback(AnimWriteCallback cb)
Set a callback function to listen to AnimationInterface write events.
Definition: animation-interface.cc:278
ns3::AnimationInterface::m_ipv4L3ProtocolCountersStopTime
Time m_ipv4L3ProtocolCountersStopTime
IPv4 L3 protocol counters stop time.
Definition: animation-interface.h:604
ns3::Tag
tag a set of bytes in a packet
Definition: tag.h:37
ns3::Address
a polymophic address class
Definition: address.h:91
ns3::AnimationInterface::WAVE
@ WAVE
Definition: animation-interface.h:515
ns3::Ipv4InterfaceAddress
a class to store IPv4 address information on an interface
Definition: ipv4-interface-address.h:44
ns3::NodeContainer::Begin
Iterator Begin(void) const
Get an iterator which refers to the first Node in the container.
Definition: node-container.cc:77
ns3::AnimationInterface::WriteXmlClose
void WriteXmlClose(std::string name, bool routing=false)
Write XML close function.
Definition: animation-interface.cc:2449
data
uint8_t data[writeSize]
Definition: socket-bound-tcp-static-routing.cc:53
ns3::AnimationInterface::m_nodeDescriptions
NodeDescriptionsMap m_nodeDescriptions
node description
Definition: animation-interface.h:650
ns3::AnimationInterface::TrackQueueCounters
void TrackQueueCounters()
Track queue counters function.
Definition: animation-interface.cc:2159
ns3::AnimationInterface::m_routingStopTime
Time m_routingStopTime
routing stop time
Definition: animation-interface.h:600
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
ns3::AnimationInterface::GetNetDeviceFromContext
Ptr< NetDevice > GetNetDeviceFromContext(std::string context)
Get net device from context.
Definition: animation-interface.cc:591
ns3::AnimationInterface::IsStarted
bool IsStarted(void)
Is AnimationInterface started.
Definition: animation-interface.cc:272
ns3::AnimationInterface::AddResource
uint32_t AddResource(std::string resourcePath)
Add a resource such as the path to an image file.
Definition: animation-interface.cc:247
ns3::NetDevice::GetNode
virtual Ptr< Node > GetNode(void) const =0
ns3::AnimationInterface::m_maxPktsPerFile
uint64_t m_maxPktsPerFile
maximum pakets per file
Definition: animation-interface.h:598
ns3::AnimationInterface::m_routingFileName
std::string m_routingFileName
routing file name
Definition: animation-interface.h:601
ns3::WifiNetDevice::GetNode
Ptr< Node > GetNode(void) const override
Definition: wifi-net-device.cc:350
ns3::AnimationInterface::ConnectLte
void ConnectLte()
Connect LTE function.
Definition: animation-interface.cc:1596
ns3::LrWpanMacHeader
Represent the Mac Header with the Frame Control and Sequence Number fields.
Definition: lr-wpan-mac-header.h:54
ns3::AnimationInterface::WifiMacRxDropTrace
void WifiMacRxDropTrace(std::string context, Ptr< const Packet > p)
wifi MAC receive drop trace function
Definition: animation-interface.cc:694
ns3::EnergySource
Introspection did not find any typical Config paths.
Definition: energy-source.h:82
ns3::AnimationInterface::EnableIpv4RouteTracking
AnimationInterface & EnableIpv4RouteTracking(std::string fileName, Time startTime, Time stopTime, Time pollInterval=Seconds(5))
Enable tracking of the Ipv4 routing table for all Nodes.
Definition: animation-interface.cc:194
MAX_PKTS_PER_TRACE_FILE
#define MAX_PKTS_PER_TRACE_FILE
Definition: animation-interface.h:51
ns3::AnimationInterface::m_nodeLrWpanMacTx
NodeCounterMap64 m_nodeLrWpanMacTx
node LR-WPAN MAC transmit
Definition: animation-interface.h:672
ns3::AnimationInterface::GetAnimUidFromPacket
uint64_t GetAnimUidFromPacket(Ptr< const Packet >)
Get anim UID from packet function.
Definition: animation-interface.cc:604
ns3::AnimationInterface::AnimXmlElement::SetText
void SetText(std::string text)
Set text function.
Definition: animation-interface.cc:2799
ns3::AnimationInterface::StartAnimation
void StartAnimation(bool restart=false)
Start animation function.
Definition: animation-interface.cc:1492
ns3::AnimationInterface::CsmaPhyTxEndTrace
void CsmaPhyTxEndTrace(std::string context, Ptr< const Packet > p)
CSMA Phy transmit end trace function.
Definition: animation-interface.cc:1185
ns3::AnimationInterface::m_pendingWifiPackets
AnimUidPacketInfoMap m_pendingWifiPackets
pending wifi packets
Definition: animation-interface.h:634
ns3::AnimationInterface::WriteXmlRp
void WriteXmlRp(uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements)
Write XMLRP function.
Definition: animation-interface.cc:2556
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:103
ns3::AnimationInterface::ProtocolTypeToPendingPackets
AnimUidPacketInfoMap * ProtocolTypeToPendingPackets(ProtocolType protocolType)
Protocol type to pending packets function.
Definition: animation-interface.cc:1338
ns3::AnimationInterface::Ipv4RoutePathElement
Ipv4RoutePathElement structure.
Definition: animation-interface.h:501
ns3::AnimationInterface::SkipPacketTracing
void SkipPacketTracing()
Do not trace packets.
Definition: animation-interface.cc:103
ns3::AnimationInterface::DOUBLE_COUNTER
@ DOUBLE_COUNTER
Definition: animation-interface.h:91
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::AnimationInterface::WriteXmlRouting
void WriteXmlRouting(uint32_t id, std::string routingInfo)
Write XML routing function.
Definition: animation-interface.cc:2546
ns3::AnimationInterface::UpdateNodeSize
void UpdateNodeSize(uint32_t nodeId, double width, double height)
Helper function to update the size of a node.
Definition: animation-interface.cc:344
NS_LOG_UNCOND
#define NS_LOG_UNCOND(msg)
Output the requested message unconditionally.
Definition: log-macros-enabled.h:269
ns3::AnimationInterface::m_f
FILE * m_f
File handle for output (0 if none)
Definition: animation-interface.h:588
ns3::AnimationInterface::m_queueDropCounterId
uint32_t m_queueDropCounterId
queue drop counter ID
Definition: animation-interface.h:624
list
#define list
Definition: openflow-interface.h:47
ns3::AnimationInterface::SetStopTime
void SetStopTime(Time t)
Specify the time at which capture should stop.
Definition: animation-interface.cc:226
ns3::AnimationInterface::CounterTypeToString
std::string CounterTypeToString(CounterType counterType)
Counter type to string function.
Definition: animation-interface.cc:1431
ns3::NetDevice::GetChannel
virtual Ptr< Channel > GetChannel(void) const =0
ns3::AnimationInterface::m_wifiPhyCountersPollInterval
Time m_wifiPhyCountersPollInterval
wifi Phy counters poll interval
Definition: animation-interface.h:611
ns3::AnimationInterface::WriteIpv4Addresses
void WriteIpv4Addresses()
Write IPv4 Addresses function.
Definition: animation-interface.cc:1906
ns3::AnimationInterface::TrackWifiMacCounters
void TrackWifiMacCounters()
Track wifi MAC counters function.
Definition: animation-interface.cc:2177
ns3::AnimationInterface::m_currentPktCount
uint64_t m_currentPktCount
current packet count
Definition: animation-interface.h:653
ns3::AnimByteTag::GetTypeId
static TypeId GetTypeId(void)
Get Type Id.
Definition: animation-interface.cc:2858
ns3::AnimationInterface::UAN
@ UAN
Definition: animation-interface.h:509
ns3::AnimationInterface::WriteLinkProperties
void WriteLinkProperties()
Write link properties function.
Definition: animation-interface.cc:1944
ns3::AnimationInterface::WriteXmlIpv4Addresses
void WriteXmlIpv4Addresses(uint32_t nodeId, std::vector< std::string > ipv4Addresses)
Write XML Ipv4 addresses function.
Definition: animation-interface.cc:2514
ns3::AnimationInterface::m_nodeColors
NodeColorsMap m_nodeColors
node colors
Definition: animation-interface.h:649
ns3::MakeCallback
Callback< R, Ts... > MakeCallback(R(T::*memPtr)(Ts...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:1648
rgb::g
uint8_t g
green
Definition: colors-link-description.cc:36
ns3::AnimationInterface::m_ipv4L3ProtocolRxCounterId
uint32_t m_ipv4L3ProtocolRxCounterId
IPv4 L3 protocol receive counter ID.
Definition: animation-interface.h:619
ns3::AnimationInterface::GetNodeEnergyFraction
double GetNodeEnergyFraction(Ptr< const Node > node) const
Get node's energy fraction (This used only for testing)
Definition: animation-interface.cc:401
ns3::AnimationInterface::WifiMacTxDropTrace
void WifiMacTxDropTrace(std::string context, Ptr< const Packet > p)
wifi MAC transmit drop trace function
Definition: animation-interface.cc:680
test-ns3.result
result
Definition: test-ns3.py:1659
ns3::AnimationInterface::m_wifiMacRxDropCounterId
uint32_t m_wifiMacRxDropCounterId
wifi MAC receive drop counter ID
Definition: animation-interface.h:629
ns3::AnimationInterface::GetNodeFromContext
Ptr< Node > GetNodeFromContext(const std::string &context) const
Get node from context.
Definition: animation-interface.cc:578
ns3::Ipv4::GetRoutingProtocol
virtual Ptr< Ipv4RoutingProtocol > GetRoutingProtocol(void) const =0
Get the routing protocol to be used by this Ipv4 stack.
ns3::AnimationInterface::m_nodeWifiMacRxDrop
NodeCounterMap64 m_nodeWifiMacRxDrop
node wifi MAC receive drop
Definition: animation-interface.h:669
ns3::AnimationInterface::Ipv4RxTrace
void Ipv4RxTrace(std::string context, Ptr< const Packet > p, Ptr< Ipv4 > ipv4, uint32_t interfaceIndex)
IPv4 receive trace function.
Definition: animation-interface.cc:736
ns3::NodeList::End
static Iterator End(void)
Definition: node-list.cc:235
ns3::AnimationInterface::m_wifiMacTxCounterId
uint32_t m_wifiMacTxCounterId
wifi MAC transmit counter ID
Definition: animation-interface.h:626
ns3::NodeContainer::Iterator
std::vector< Ptr< Node > >::const_iterator Iterator
Node container iterator.
Definition: node-container.h:42
ns3::AnimationInterface::AnimPacketInfo::m_lbTx
double m_lbTx
lb transmit
Definition: animation-interface.h:430
ns3::TypeId::GetName
std::string GetName(void) const
Get the name.
Definition: type-id.cc:976
uint32_t
ns3::AnimationInterface::Ipv4TxTrace
void Ipv4TxTrace(std::string context, Ptr< const Packet > p, Ptr< Ipv4 > ipv4, uint32_t interfaceIndex)
IPv4 transmit trace function.
Definition: animation-interface.cc:729
ns3::AnimationInterface::m_pendingWimaxPackets
AnimUidPacketInfoMap m_pendingWimaxPackets
pending wimax packets
Definition: animation-interface.h:635
ns3::AnimationInterface::GetElementsFromContext
const std::vector< std::string > GetElementsFromContext(const std::string &context) const
Get elements from context.
Definition: animation-interface.cc:562
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:273
ns3::AnimationInterface::m_enablePacketMetadata
bool m_enablePacketMetadata
enable packet metadata
Definition: animation-interface.h:595
ns3::AnimationInterface::Ipv4RouteTrackElement
Ipv4RouteTrackElement structure.
Definition: animation-interface.h:494
ns3::AnimationInterface::ResetAnimWriteCallback
void ResetAnimWriteCallback()
Reset the write callback function.
Definition: animation-interface.cc:284
ns3::AnimationInterface::WIFI
@ WIFI
Definition: animation-interface.h:511
ns3::AnimationInterface::AnimPacketInfo::m_lbRx
double m_lbRx
lb receive
Definition: animation-interface.h:432
rgb::r
uint8_t r
red
Definition: colors-link-description.cc:35
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1244
ns3::AnimationInterface::m_nodeIpv4Drop
NodeCounterMap64 m_nodeIpv4Drop
node IPv4 drop
Definition: animation-interface.h:660
ns3::AnimationInterface::UanPhyGenRxTrace
void UanPhyGenRxTrace(std::string context, Ptr< const Packet >)
UAN Phy gen receive trace function.
Definition: animation-interface.cc:864
ns3::AnimationInterface::AnimPacketInfo::m_fbRx
double m_fbRx
fb receive
Definition: animation-interface.h:431
ns3::AnimationInterface::NodeIdIpv4Pair
std::pair< uint32_t, std::string > NodeIdIpv4Pair
NodeIdIpv4Pair typedef.
Definition: animation-interface.h:532
ns3::AnimationInterface::ConnectLteEnb
void ConnectLteEnb(Ptr< Node > n, Ptr< LteEnbNetDevice > nd, uint32_t devIndex)
Connect LTE ENB function.
Definition: animation-interface.cc:1550
ns3::Object::GetInstanceTypeId
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
Definition: object.cc:79
f
double f(double x, void *params)
Definition: 80211b.c:70
ns3::AnimationInterface::AnimPacketInfo::AnimPacketInfo
AnimPacketInfo()
Definition: animation-interface.cc:2910
ns3::AnimationInterface::LrWpanMacRxTrace
void LrWpanMacRxTrace(std::string context, Ptr< const Packet > p)
LR-WPAN MAC receive trace function.
Definition: animation-interface.cc:715
ns3::AnimationInterface::m_resources
std::vector< std::string > m_resources
resources
Definition: animation-interface.h:656
ns3::AnimationInterface::m_ipv6ToNodeIdMap
std::map< std::string, uint32_t > m_ipv6ToNodeIdMap
IPv6 to node ID map.
Definition: animation-interface.h:645
sample-rng-plot.x
list x
Definition: sample-rng-plot.py:34
ns3::AnimationInterface::m_nodeLrWpanMacTxDrop
NodeCounterMap64 m_nodeLrWpanMacTxDrop
node LR-WPAN MAC transmit drop
Definition: animation-interface.h:673
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::AnimationInterface::m_pendingLrWpanPackets
AnimUidPacketInfoMap m_pendingLrWpanPackets
pending LR-WPAN packets
Definition: animation-interface.h:636
ns3::Simulator::IsFinished
static bool IsFinished(void)
Check if the simulation should finish.
Definition: simulator.cc:165
ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition: mobility-model.h:40
ns3::AnimationInterface::m_wifiPhyRxDropCounterId
uint32_t m_wifiPhyRxDropCounterId
wifi Phy receive drop counter ID
Definition: animation-interface.h:632
ns3::AnimationInterface::GetMacAddress
std::string GetMacAddress(Ptr< NetDevice > nd)
Get MAC address function.
Definition: animation-interface.cc:1785
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:39
ns3::AnimationInterface::WriteXmlUpdateNodeCounter
void WriteXmlUpdateNodeCounter(uint32_t counterId, uint32_t nodeId, double value)
Write XML update node counter function.
Definition: animation-interface.cc:2704
ns3::AnimationInterface::LTE
@ LTE
Definition: animation-interface.h:510
ns3::AnimationInterface::WifiPhyRxBeginTrace
void WifiPhyRxBeginTrace(std::string context, Ptr< const Packet > p, RxPowerWattPerChannelBand rxPowersW)
wifi Phy receive begin trace function
Definition: animation-interface.cc:911
ns3::AnimationInterface::m_nodeQueueDrop
NodeCounterMap64 m_nodeQueueDrop
node queue drop
Definition: animation-interface.h:665
ns3::ByteTagIterator::HasNext
bool HasNext(void) const
Definition: packet.cc:65
ns3::Ipv4InterfaceAddress::GetLocal
Ipv4Address GetLocal(void) const
Get the local address.
Definition: ipv4-interface-address.cc:74
ns3::AnimByteTag::Print
virtual void Print(std::ostream &os) const
Print tag info.
Definition: animation-interface.cc:2893
ns3::Ipv6
Access to the IPv6 forwarding table, interfaces, and configuration.
Definition: ipv6.h:82
ns3::AnimationInterface::WriteXmlUpdateNodeImage
void WriteXmlUpdateNodeImage(uint32_t nodeId, uint32_t resourceId)
Write XML update node image function.
Definition: animation-interface.cc:2641
ns3::AnimationInterface::GetTracePktCount
uint64_t GetTracePktCount()
Get trace file packet count (This used only for testing)
Definition: animation-interface.cc:1461
ns3::AnimationInterface::WifiMacRxTrace
void WifiMacRxTrace(std::string context, Ptr< const Packet > p)
wifi MAC receive trace function
Definition: animation-interface.cc:687
ns3::NodeContainer::End
Iterator End(void) const
Get an iterator which indicates past-the-last Node in the container.
Definition: node-container.cc:82
ns3::Packet::Print
void Print(std::ostream &os) const
Print the packet contents.
Definition: packet.cc:434
ns3::RxPowerWattPerChannelBand
std::map< WifiSpectrumBand, double > RxPowerWattPerChannelBand
A map of the received power (Watts) for each band.
Definition: phy-entity.h:75
ns3::AnimationInterface::m_queueDequeueCounterId
uint32_t m_queueDequeueCounterId
queue dequeue counter ID
Definition: animation-interface.h:623
ns3::AnimationInterface::AddToIpv4AddressNodeIdTable
void AddToIpv4AddressNodeIdTable(std::string ipv4Address, uint32_t nodeId)
Add to IPv4 address node ID table function.
Definition: animation-interface.cc:1513
ns3::AnimationInterface::AnimXmlElement::AnimXmlElement
AnimXmlElement(std::string tagName, bool emptyElement=true)
Constructor.
Definition: animation-interface.cc:2741
ns3::AnimationInterface::WifiPhyTxBeginTrace
void WifiPhyTxBeginTrace(std::string context, WifiConstPsduMap psduMap, WifiTxVector txVector, double txPowerW)
wifi Phy transmit PSDU begin trace function
Definition: animation-interface.cc:871
ns3::AnimationInterface::AnimPacketInfo
AnimPacketInfo class.
Definition: animation-interface.h:410
ns3::AnimationInterface::m_nodeEnergyFraction
EnergyFractionMap m_nodeEnergyFraction
node energy fraction
Definition: animation-interface.h:652
ns3::AnimationInterface::m_queueCountersStopTime
Time m_queueCountersStopTime
queue counters stop time
Definition: animation-interface.h:606
ns3::AnimationInterface::m_nodeWifiMacRx
NodeCounterMap64 m_nodeWifiMacRx
node wifi MAC receive
Definition: animation-interface.h:668
ns3::AnimationInterface::WavePhyTxBeginTrace
void WavePhyTxBeginTrace(std::string context, Ptr< const Packet > p)
WAVE Phy transmit begin trace function.
Definition: animation-interface.cc:1029
ns3::AnimationInterface::m_ipv4L3ProtocolCountersPollInterval
Time m_ipv4L3ProtocolCountersPollInterval
IPv4 L3 protocol counters poll interval.
Definition: animation-interface.h:605
ns3::AnimationInterface::m_nodeLocation
std::map< uint32_t, Vector > m_nodeLocation
node location
Definition: animation-interface.h:642
ns3::AnimationInterface::LrWpanMacTxDropTrace
void LrWpanMacTxDropTrace(std::string context, Ptr< const Packet > p)
LR-WPAN MAC transmit drop trace function.
Definition: animation-interface.cc:708
ns3::AnimationInterface::m_nodeQueueDequeue
NodeCounterMap64 m_nodeQueueDequeue
node queue dequeue
Definition: animation-interface.h:664
ns3::AnimationInterface::CsmaPhyTxBeginTrace
void CsmaPhyTxBeginTrace(std::string context, Ptr< const Packet > p)
CSMA Phy transmit begin trace function.
Definition: animation-interface.cc:1167
ns3::AnimationInterface::WriteXmlPRef
void WriteXmlPRef(uint64_t animUid, uint32_t fId, double fbTx, std::string metaInfo="")
Write XMLP Ref function.
Definition: animation-interface.cc:2579
ns3::AnimationInterface::OutputWirelessPacketTxInfo
void OutputWirelessPacketTxInfo(Ptr< const Packet > p, AnimPacketInfo &pktInfo, uint64_t animUid)
Output wireless packet transmit info.
Definition: animation-interface.cc:1250
ns3::AnimationInterface::AddToIpv6AddressNodeIdTable
void AddToIpv6AddressNodeIdTable(std::string ipv6Address, uint32_t nodeId)
Add to IPv6 address node ID table function.
Definition: animation-interface.cc:1531
ns3::AnimationInterface::GetIpv4Address
std::string GetIpv4Address(Ptr< NetDevice > nd)
Get IPv4 address.
Definition: animation-interface.cc:1794
ns3::AnimationInterface::WimaxTxTrace
void WimaxTxTrace(std::string context, Ptr< const Packet > p, const Mac48Address &m)
WIMax transmit trace function.
Definition: animation-interface.cc:1074
ns3::AnimationInterface::m_pendingUanPackets
AnimUidPacketInfoMap m_pendingUanPackets
pending UAN packets
Definition: animation-interface.h:639
ns3::AnimationInterface::MobilityCourseChangeTrace
void MobilityCourseChangeTrace(Ptr< const MobilityModel > mob)
Mobility course change trace function.
Definition: animation-interface.cc:409
ns3::AnimationInterface::NodeSize::width
double width
width
Definition: animation-interface.h:521
ns3::AnimationInterface::m_pendingLtePackets
AnimUidPacketInfoMap m_pendingLtePackets
pending LTE packets
Definition: animation-interface.h:637
ns3::AnimationInterface::IsInTimeWindow
bool IsInTimeWindow()
Is in time window function.
Definition: animation-interface.cc:2091
ns3::AnimationInterface::WriteXmlNonP2pLinkProperties
void WriteXmlNonP2pLinkProperties(uint32_t id, std::string ipAddress, std::string channelType)
Write XML non P2P link properties function.
Definition: animation-interface.cc:2728
ns3::AnimationInterface::CsmaPhyRxEndTrace
void CsmaPhyRxEndTrace(std::string context, Ptr< const Packet > p)
CSMA Phy receive end trace function.
Definition: animation-interface.cc:1208
ns3::ByteTagIterator
Iterator over the set of byte tags in a packet.
Definition: packet.h:55
ns3::AnimationInterface::GetPosition
Vector GetPosition(Ptr< Node > n)
Get position function.
Definition: animation-interface.cc:1774
ns3::Packet::FindFirstMatchingByteTag
bool FindFirstMatchingByteTag(Tag &tag) const
Finds the first tag matching the parameter Tag type.
Definition: packet.cc:939
ns3::AnimationInterface::OutputCsmaPacket
void OutputCsmaPacket(Ptr< const Packet > p, AnimPacketInfo &pktInfo)
Output CSMA packet function.
Definition: animation-interface.cc:1274
ns3::TagBuffer
read and write tag data
Definition: tag-buffer.h:52
ns3::AnimationInterface::AnimationInterface
AnimationInterface(const std::string filename)
Constructor.
Definition: animation-interface.cc:75
ns3::AnimationInterface::UpdateNodeImage
void UpdateNodeImage(uint32_t nodeId, uint32_t resourceId)
Helper function to update the image of a node.
Definition: animation-interface.cc:313
ns3::AnimationInterface::WriteXmlAnim
void WriteXmlAnim(bool routing=false)
Write XML anim function.
Definition: animation-interface.cc:2431
ns3::AnimationInterface::UpdateNodeDescription
void UpdateNodeDescription(Ptr< Node > n, std::string descr)
Helper function to update the description for a given node.
Definition: animation-interface.cc:384
ns3::AnimByteTag::Set
void Set(uint64_t AnimUid)
Set global Uid in tag.
Definition: animation-interface.cc:2899
ns3::AnimationInterface::SetMobilityPollInterval
void SetMobilityPollInterval(Time t)
Set mobility poll interval:WARNING: setting a low interval can cause slowness.
Definition: animation-interface.cc:290
ns3::Ipv4Header::SetDestination
void SetDestination(Ipv4Address destination)
Definition: ipv4-header.cc:298
ns3::AnimationInterface::AnimPacketInfo::m_txNodeId
uint32_t m_txNodeId
node ID
Definition: animation-interface.h:428
ns3::LrWpanNetDevice::GetMac
Ptr< LrWpanMac > GetMac(void) const
Get the MAC used by this NetDevice.
Definition: lr-wpan-net-device.cc:192
ns3::AnimationInterface::TrackWifiPhyCounters
void TrackWifiPhyCounters()
Track wifi phy counters function.
Definition: animation-interface.cc:2196
ns3::AnimationInterface::Ipv4DropTrace
void Ipv4DropTrace(std::string context, const Ipv4Header &ipv4Header, Ptr< const Packet > p, Ipv4L3Protocol::DropReason dropReason, Ptr< Ipv4 > ipv4, uint32_t interfaceIndex)
IPv4 drop trace function.
Definition: animation-interface.cc:743
ns3::WifiMacHeader::GetAddr2
Mac48Address GetAddr2(void) const
Return the address in the Address 2 field.
Definition: wifi-mac-header.cc:430
ns3::AnimationInterface::WriteXmlUpdateNodePosition
void WriteXmlUpdateNodePosition(uint32_t nodeId, double x, double y)
Write XML update node position function.
Definition: animation-interface.cc:2664
ns3::AnimationInterface::Rgb
RGB structure.
Definition: animation-interface.h:444
ns3::AnimationInterface::TrackIpv4RoutePaths
void TrackIpv4RoutePaths()
Track IPv4 route paths function.
Definition: animation-interface.cc:2237
NETANIM_VERSION
#define NETANIM_VERSION
Definition: animation-interface.h:53
ns3::AnimationInterface::SetStartTime
void SetStartTime(Time t)
Specify the time at which capture should start.
Definition: animation-interface.cc:220
ns3::AnimationInterface::WriteIpv6Addresses
void WriteIpv6Addresses()
Write IPv6 Addresses function.
Definition: animation-interface.cc:1925
ns3::AnimationInterface::AddNodeCounter
uint32_t AddNodeCounter(std::string counterName, CounterType counterType)
Setup a node counter.
Definition: animation-interface.cc:238
ns3::AnimationInterface::GenericWirelessTxTrace
void GenericWirelessTxTrace(std::string context, Ptr< const Packet > p, ProtocolType protocolType)
Generic wireless transmit trace function.
Definition: animation-interface.cc:807
ns3::AnimationInterface::m_startTime
Time m_startTime
start time
Definition: animation-interface.h:596
ns3::AnimationInterface::m_wifiMacCountersStopTime
Time m_wifiMacCountersStopTime
wifi MAC counters stop time
Definition: animation-interface.h:608
ns3::AnimationInterface::WriteNodeEnergies
void WriteNodeEnergies()
Write node energies function.
Definition: animation-interface.cc:2077
ns3::AnimationInterface::LRWPAN
@ LRWPAN
Definition: animation-interface.h:514
ns3::AnimationInterface::AnimXmlElement::AddAttribute
void AddAttribute(std::string attribute, T value, bool xmlEscape=false)
Add attribute function.
Definition: animation-interface.cc:2749
ns3::AnimationInterface::UanPhyGenTxTrace
void UanPhyGenTxTrace(std::string context, Ptr< const Packet >)
UAN Phy gen transmit trace function.
Definition: animation-interface.cc:857
ns3::MobilityModel::GetPosition
Vector GetPosition(void) const
Definition: mobility-model.cc:64
ns3::AnimationInterface::WifiMacTxTrace
void WifiMacTxTrace(std::string context, Ptr< const Packet > p)
wifi MAC transmit trace function
Definition: animation-interface.cc:673
ns3::Packet::AddByteTag
void AddByteTag(const Tag &tag) const
Tag each byte included in this packet with a new byte tag.
Definition: packet.cc:912
ns3::AnimationInterface::m_mobilityPollInterval
Time m_mobilityPollInterval
mobility poll interval
Definition: animation-interface.h:590
ns3::UniformRandomVariable::GetValue
double GetValue(double min, double max)
Get the next random value, as a double in the specified range .
Definition: random-variable-stream.cc:181
ns3::Socket::ERROR_NOROUTETOHOST
@ ERROR_NOROUTETOHOST
Definition: socket.h:93
ns3::AnimationInterface::LrWpanMacRxDropTrace
void LrWpanMacRxDropTrace(std::string context, Ptr< const Packet > p)
LR-WPAN MAC receive drop trace function.
Definition: animation-interface.cc:722
ns3::AnimationInterface::m_ipv4RouteTrackElements
std::vector< Ipv4RouteTrackElement > m_ipv4RouteTrackElements
IPv route track elements.
Definition: animation-interface.h:654
ns3::TagBuffer::ReadU64
uint64_t ReadU64(void)
Definition: tag-buffer.cc:134
ns3::AnimationInterface::~AnimationInterface
~AnimationInterface()
Destructor for the animator interface.
Definition: animation-interface.cc:97
ns3::AnimationInterface::DevTxTrace
void DevTxTrace(std::string context, Ptr< const Packet > p, Ptr< NetDevice > tx, Ptr< NetDevice > rx, Time txTime, Time rxTime)
Device transmit trace function.
Definition: animation-interface.cc:779
ns3::AnimationInterface::RemainingEnergyTrace
void RemainingEnergyTrace(std::string context, double previousEnergy, double currentEnergy)
Remaining energy trace function.
Definition: animation-interface.cc:638
ns3::AnimationInterface::NodeHasMoved
bool NodeHasMoved(Ptr< Node > n, Vector newLocation)
Node has moved function.
Definition: animation-interface.cc:428
ns3::NodeList::GetNode
static Ptr< Node > GetNode(uint32_t n)
Definition: node-list.cc:241
ns3::AnimationInterface::m_nodeCounters
std::vector< std::string > m_nodeCounters
node counters
Definition: animation-interface.h:657
CHECK_STARTED_INTIMEWINDOW
#define CHECK_STARTED_INTIMEWINDOW
Definition: animation-interface.h:54
ns3::Time::GetSeconds
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:379
sample-rng-plot.n
n
Definition: sample-rng-plot.py:37
ns3::AnimationInterface::Ipv4RouteTrackElement::destination
std::string destination
destination
Definition: animation-interface.h:495
ns3::AnimationInterface::LteSpectrumPhyRxStart
void LteSpectrumPhyRxStart(std::string context, Ptr< const PacketBurst > pb)
LTE Spectrum Phy receive start function.
Definition: animation-interface.cc:1133
third.mobility
mobility
Definition: third.py:108
ns3::TagBuffer::WriteU64
void WriteU64(uint64_t v)
Definition: tag-buffer.cc:102
ns3::AnimationInterface::AddByteTag
void AddByteTag(uint64_t animUid, Ptr< const Packet > p)
Add byte tag function.
Definition: animation-interface.cc:630
ns3::AnimationInterface::ProtocolTypeToString
std::string ProtocolTypeToString(ProtocolType protocolType)
Protocol type to string function.
Definition: animation-interface.cc:1384
ns3::AnimationInterface::WriteNodes
void WriteNodes()
Write nodes function.
Definition: animation-interface.cc:2037
ns3::WifiNetDevice::GetMac
Ptr< WifiMac > GetMac(void) const
Definition: wifi-net-device.cc:215
ns3::AnimationInterface::m_ipv4ToNodeIdMap
std::map< std::string, uint32_t > m_ipv4ToNodeIdMap
IPv4 to node ID map.
Definition: animation-interface.h:644
ns3::AnimationInterface::m_routingF
FILE * m_routingF
File handle for routing table output (0 if None);.
Definition: animation-interface.h:589
NS_ABORT_MSG
#define NS_ABORT_MSG(msg)
Unconditional abnormal program termination with a message.
Definition: abort.h:50
ns3::AnimByteTag::Serialize
virtual void Serialize(TagBuffer i) const
Serialize function.
Definition: animation-interface.cc:2881
ns3::AnimationInterface::LteTxTrace
void LteTxTrace(std::string context, Ptr< const Packet > p, const Mac48Address &m)
LTE transmit trace function.
Definition: animation-interface.cc:1089