ns-3.24: comparison src/netanim/model/animation-interface.cc

equal deleted inserted replaced

-:ce0699130fc4
+:25b20434eba8
 #define PURGE_INTERVAL 5
 static bool initialized = false;
 std::map <uint32_t, std::string> AnimationInterface::nodeDescriptions;
 AnimationInterface::AnimationInterface ()
-: m_fHandle (STDOUT_FILENO), m_xml (false), mobilitypollinterval (Seconds(0.25)),
+: m_fHandle (STDOUT_FILENO), m_xml (false), m_mobilityPollInterval (Seconds(0.25)),
-usingSockets (false), mport (0), outputfilename (""),
+m_usingSockets (false), m_port (0), m_outputFileName (""),
-OutputFileSet (false), ServerPortSet (false), gAnimUid (0),randomPosition (true),
+m_outputFileSet (false), m_serverPortSet (false), gAnimUid (0),m_randomPosition (true),
 m_writeCallback (0), m_started (false),
-m_enablePacketMetadata (false), m_startTime (Seconds(0)), m_stopTime (Seconds(3600 * 1000))
+m_enablePacketMetadata (false), m_startTime (Seconds(0)), m_stopTime (Seconds(3600 * 1000)),
+m_maxPktsPerFile (MAX_PKTS_PER_TRACE_FILE)
 {
 initialized = true;
 StartAnimation ();
 }
-AnimationInterface::AnimationInterface (const std::string fn, bool usingXML)
+AnimationInterface::AnimationInterface (const std::string fn, uint64_t maxPktsPerFile, bool usingXML)
-: m_fHandle (STDOUT_FILENO), m_xml (usingXML), mobilitypollinterval (Seconds(0.25)),
+: m_fHandle (STDOUT_FILENO), m_xml (usingXML), m_mobilityPollInterval (Seconds(0.25)),
-usingSockets (false), mport (0), outputfilename (fn),
+m_usingSockets (false), m_port (0), m_outputFileName (fn),
-OutputFileSet (false), ServerPortSet (false), gAnimUid (0), randomPosition (true),
+m_outputFileSet (false), m_serverPortSet (false), gAnimUid (0), m_randomPosition (true),
 m_writeCallback (0), m_started (false),
-m_enablePacketMetadata (false), m_startTime (Seconds(0)), m_stopTime (Seconds(3600 * 1000))
+m_enablePacketMetadata (false), m_startTime (Seconds(0)), m_stopTime (Seconds(3600 * 1000)),
+m_maxPktsPerFile (maxPktsPerFile), m_originalFileName (fn)
 {
 initialized = true;
 StartAnimation ();
 }
 AnimationInterface::AnimationInterface (const uint16_t port, bool usingXML)
-: m_fHandle (STDOUT_FILENO), m_xml (usingXML), mobilitypollinterval (Seconds(0.25)),
+: m_fHandle (STDOUT_FILENO), m_xml (usingXML), m_mobilityPollInterval (Seconds(0.25)),
-usingSockets (true), mport (port), outputfilename (""),
+m_usingSockets (true), m_port (port), m_outputFileName (""),
-OutputFileSet (false), ServerPortSet (false), gAnimUid (0), randomPosition (true),
+m_outputFileSet (false), m_serverPortSet (false), gAnimUid (0), m_randomPosition (true),
 m_writeCallback (0), m_started (false),
-m_enablePacketMetadata (false), m_startTime (Seconds(0)), m_stopTime (Seconds(3600 * 1000))
+m_enablePacketMetadata (false), m_startTime (Seconds(0)), m_stopTime (Seconds(3600 * 1000)),
+m_maxPktsPerFile (MAX_PKTS_PER_TRACE_FILE)
 {
 initialized = true;
 StartAnimation ();
 }
 NS_LOG_INFO ("XML output set");
 m_xml = true;
 }
+void AnimationInterface::StartNewTraceFile ()
+{
+static int i = 0;
+std::ostringstream oss;
+oss << i;
+++m_currentPktCount;
+if (m_currentPktCount <= m_maxPktsPerFile)
+{
+return;
+}
+StopAnimation ();
+m_outputFileName = m_originalFileName + "-" + oss.str ();
+StartAnimation (true);
+++i;
+}
 void AnimationInterface::SetStartTime (Time t)
 {
 m_startTime = t;
 }
 m_stopTime = t;
 }
 bool AnimationInterface::SetOutputFile (const std::string& fn)
 {
-if (OutputFileSet)
+if (m_outputFileSet)
 {
 return true;
 }
 if (fn == "")
 {
 m_fHandle = STDOUT_FILENO;
-OutputFileSet = true;
+m_outputFileSet = true;
 return true;
 }
+NS_LOG_UNCOND (fn.c_str ());
 FILE* f = fopen (fn.c_str (), "w");
 if (!f)
 {
 NS_FATAL_ERROR ("Unable to open Animation output file");
 return false; // Can't open
 }
 m_fHandle = fileno (f); // Set the file handle
-usingSockets = false;
+m_usingSockets = false;
-outputfilename = fn;
+m_outputFileName = fn;
-OutputFileSet = true;
+m_outputFileSet = true;
 return true;
 }
 void AnimationInterface::EnablePacketMetadata (bool enable)
 {
 }
 bool AnimationInterface::SetServerPort (uint16_t port)
 {
 #if defined(HAVE_SYS_SOCKET_H) && defined(HAVE_NETINET_IN_H)
-if (ServerPortSet)
+if (m_serverPortSet)
 {
 return true;
 }
 int s = socket (AF_INET, SOCK_STREAM, 0);
 struct sockaddr_in addr;
 m_fHandle = accept (s, 0, 0);
 NS_LOG_INFO ("Got animator connection from remote");
 // set the linger socket option
 int t = 1;
 setsockopt (s, SOL_SOCKET, SO_LINGER, &t, sizeof(t));
-usingSockets = true;
+m_usingSockets = true;
-ServerPortSet = true;
+m_serverPortSet = true;
 return true;
 #endif
 return false; // never reached unless the above is disabled
 // which is done to support a platform like MinGW
 }
 bool AnimationInterface::WifiPacketIsPending (uint64_t AnimUid)
 {
-return (pendingWifiPackets.find (AnimUid) != pendingWifiPackets.end ());
+return (m_pendingWifiPackets.find (AnimUid) != m_pendingWifiPackets.end ());
 }
 bool AnimationInterface::CsmaPacketIsPending (uint64_t AnimUid)
 {
-return (pendingCsmaPackets.find (AnimUid) != pendingCsmaPackets.end ());
+return (m_pendingCsmaPackets.find (AnimUid) != m_pendingCsmaPackets.end ());
 }
 bool AnimationInterface::WimaxPacketIsPending (uint64_t AnimUid)
 {
-return (pendingWimaxPackets.find (AnimUid) != pendingWimaxPackets.end ());
+return (m_pendingWimaxPackets.find (AnimUid) != m_pendingWimaxPackets.end ());
 }
 bool AnimationInterface::LtePacketIsPending (uint64_t AnimUid)
 {
-return (pendingLtePackets.find (AnimUid) != pendingLtePackets.end ());
+return (m_pendingLtePackets.find (AnimUid) != m_pendingLtePackets.end ());
 }
 void AnimationInterface::SetMobilityPollInterval (Time t)
 {
-mobilitypollinterval = t;
+m_mobilityPollInterval = t;
 }
 void AnimationInterface::SetRandomPosition (bool setRandPos)
 {
-randomPosition = setRandPos;
+m_randomPosition = setRandPos;
 }
 Vector AnimationInterface::UpdatePosition (Ptr <Node> n)
 {
 Ptr<MobilityModel> loc = n->GetObject<MobilityModel> ();
 if (loc)
 {
-nodeLocation[n->GetId ()] = loc->GetPosition ();
+m_nodeLocation[n->GetId ()] = loc->GetPosition ();
 }
 else
 {
 NS_LOG_UNCOND ( "AnimationInterface WARNING:Node:" << n->GetId () << " Does not have a mobility model. Use SetConstantPosition if it is stationary");
 Vector deterministicVector (100,100,0);
-Vector randomVector (UniformVariable (0, topo_maxX-topo_minX).GetValue (), UniformVariable (0, topo_maxY-topo_minY).GetValue (), 0);
+Vector randomVector (UniformVariable (0, m_topoMaxX - m_topoMinX).GetValue (), UniformVariable (0, m_topoMaxY - m_topoMinY).GetValue (), 0);
-if (randomPosition)
+if (m_randomPosition)
 {
-nodeLocation[n->GetId ()] = randomVector;
+m_nodeLocation[n->GetId ()] = randomVector;
 }
 else
 {
-nodeLocation[n->GetId ()] = deterministicVector;
+m_nodeLocation[n->GetId ()] = deterministicVector;
 }
 }
-return nodeLocation[n->GetId ()];
+return m_nodeLocation[n->GetId ()];
 }
 Vector AnimationInterface::UpdatePosition (Ptr <Node> n, Vector v)
 {
-nodeLocation[n->GetId ()] = v;
+m_nodeLocation[n->GetId ()] = v;
 return v;
 }
 Vector AnimationInterface::GetPosition (Ptr <Node> n)
 {
 #ifdef NS_LOG
-if (nodeLocation.find (n->GetId()) == nodeLocation.end ())
+if (m_nodeLocation.find (n->GetId()) == m_nodeLocation.end ())
 {
 NS_FATAL_ERROR ("Node:" <<n->GetId() << " not found in Location table");
 }
 #endif
-return nodeLocation[n->GetId ()];
+return m_nodeLocation[n->GetId ()];
 }
 void AnimationInterface::PurgePendingWifi ()
 {
-if (pendingWifiPackets.empty ())
+if (m_pendingWifiPackets.empty ())
 return;
 std::vector <uint64_t> purgeList;
-for (std::map<uint64_t, AnimPacketInfo>::iterator i = pendingWifiPackets.begin ();
+for (std::map<uint64_t, AnimPacketInfo>::iterator i = m_pendingWifiPackets.begin ();
-i != pendingWifiPackets.end ();
+i != m_pendingWifiPackets.end ();
 ++i)
 {
 AnimPacketInfo pktInfo = i->second;
 double delta = (Simulator::Now ().GetSeconds () - pktInfo.m_fbTx);
 for (std::vector <uint64_t>::iterator i = purgeList.begin ();
 i != purgeList.end ();
 ++i)
 {
-pendingWifiPackets.erase (*i);
+m_pendingWifiPackets.erase (*i);
 }
 }
 void AnimationInterface::PurgePendingWimax ()
 {
-if (pendingWimaxPackets.empty ())
+if (m_pendingWimaxPackets.empty ())
 return;
 std::vector <uint64_t> purgeList;
-for (std::map<uint64_t, AnimPacketInfo>::iterator i = pendingWimaxPackets.begin ();
+for (std::map<uint64_t, AnimPacketInfo>::iterator i = m_pendingWimaxPackets.begin ();
-i != pendingWimaxPackets.end ();
+i != m_pendingWimaxPackets.end ();
 ++i)
 {
 AnimPacketInfo pktInfo = i->second;
 double delta = (Simulator::Now ().GetSeconds () - pktInfo.m_fbTx);
 for (std::vector <uint64_t>::iterator i = purgeList.begin ();
 i != purgeList.end ();
 ++i)
 {
-pendingWimaxPackets.erase (*i);
+m_pendingWimaxPackets.erase (*i);
 }
 }
 void AnimationInterface::PurgePendingLte ()
 {
-if (pendingLtePackets.empty ())
+if (m_pendingLtePackets.empty ())
 return;
 std::vector <uint64_t> purgeList;
-for (std::map<uint64_t, AnimPacketInfo>::iterator i = pendingLtePackets.begin ();
+for (std::map<uint64_t, AnimPacketInfo>::iterator i = m_pendingLtePackets.begin ();
-i != pendingLtePackets.end ();
+i != m_pendingLtePackets.end ();
 ++i)
 {
 AnimPacketInfo pktInfo = i->second;
 double delta = (Simulator::Now ().GetSeconds () - pktInfo.m_fbTx);
 for (std::vector <uint64_t>::iterator i = purgeList.begin ();
 i != purgeList.end ();
 ++i)
 {
-pendingLtePackets.erase (*i);
+m_pendingLtePackets.erase (*i);
 }
 }
 void AnimationInterface::PurgePendingCsma ()
 {
-if (pendingCsmaPackets.empty ())
+if (m_pendingCsmaPackets.empty ())
 return;
 std::vector <uint64_t> purgeList;
-for (std::map<uint64_t, AnimPacketInfo>::iterator i = pendingCsmaPackets.begin ();
+for (std::map<uint64_t, AnimPacketInfo>::iterator i = m_pendingCsmaPackets.begin ();
-i != pendingCsmaPackets.end ();
+i != m_pendingCsmaPackets.end ();
 ++i)
 {
 AnimPacketInfo pktInfo = i->second;
 double delta = (Simulator::Now ().GetSeconds () - pktInfo.m_fbTx);
 for (std::vector <uint64_t>::iterator i = purgeList.begin ();
 i != purgeList.end ();
 ++i)
 {
-pendingCsmaPackets.erase (*i);
+m_pendingCsmaPackets.erase (*i);
 }
 }
-void AnimationInterface::StartAnimation ()
+void AnimationInterface::StartAnimation (bool restart)
 {
+m_currentPktCount = 0;
 m_started = true;
-if (usingSockets)
+if (m_usingSockets)
 {
-SetServerPort (mport);
+SetServerPort (m_port);
 }
 else
 {
-SetOutputFile (outputfilename);
+SetOutputFile (m_outputFileName);
 }
 // Find the min/max x/y for the xml topology element
-topo_minX = -2;
+m_topoMinX = -2;
-topo_minY = -2;
+m_topoMinY = -2;
-topo_maxX = 2;
+m_topoMaxX = 2;
-topo_maxY = 2;
+m_topoMaxY = 2;
 for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
 {
 Ptr<Node> n = *i;
 NS_LOG_INFO ("Update Position for Node: " << n->GetId ());
 Vector v = UpdatePosition (n);
-topo_minX = std::min (topo_minX, v.x);
+m_topoMinX = std::min (m_topoMinX, v.x);
-topo_minY = std::min (topo_minY, v.y);
+m_topoMinY = std::min (m_topoMinY, v.y);
-topo_maxX = std::max (topo_maxX, v.x);
+m_topoMaxX = std::max (m_topoMaxX, v.x);
-topo_maxY = std::max (topo_maxY, v.y);
+m_topoMaxY = std::max (m_topoMaxY, v.y);
 }
 AddMargin ();
 if (m_xml)
 { // output the xml headers
 std::ostringstream oss;
 oss << GetXMLOpen_anim (0);
 oss << GetPreamble ();
-oss << GetXMLOpen_topology (topo_minX, topo_minY, topo_maxX, topo_maxY);
+oss << GetXMLOpen_topology (m_topoMinX, m_topoMinY, m_topoMaxX, m_topoMaxY);
 WriteN (m_fHandle, oss.str ());
 }
 NS_LOG_INFO ("Setting topology for "<<NodeList::GetNNodes ()<<" Nodes");
 // Dump the topology
 for (NodeList::Iterator i = NodeList::Begin (); i != NodeList::End (); ++i)
 {
 //NS_FATAL_ERROR ("Net animation currently only supports point-to-point links.");
 }
 }
 }
-if (m_xml)
+if (m_xml && !restart)
 {
 WriteN (m_fHandle, GetXMLClose ("topology"));
-Simulator::Schedule (mobilitypollinterval, &AnimationInterface::MobilityAutoCheck, this);
+Simulator::Schedule (m_mobilityPollInterval, &AnimationInterface::MobilityAutoCheck, this);
 }
+if (!restart)
 ConnectCallbacks ();
 }
 void AnimationInterface::ConnectCallbacks ()
 {
 // Connect the callbacks
 }
 if (m_fHandle != STDOUT_FILENO)
 {
 close (m_fHandle);
 }
-OutputFileSet = false;
+m_outputFileSet = false;
 m_fHandle = -1;
 }
 }
 int AnimationInterface::WriteN (int h, const std::string& st)
 // Private methods
 void AnimationInterface::AddMargin ()
 {
 // Compute width/height, and add a small margin
-double w = topo_maxX - topo_minX;
+double w = m_topoMaxX - m_topoMinX;
-double h = topo_maxY - topo_minY;
+double h = m_topoMaxY - m_topoMinY;
-topo_minX -= w * 0.05;
+m_topoMinX -= w * 0.05;
-topo_minY -= h * 0.05;
+m_topoMinY -= h * 0.05;
-topo_maxX = topo_minX + w * 1.5;
+m_topoMaxX = m_topoMinX + w * 1.5;
-topo_maxY = topo_minY + h * 1.5;
+m_topoMaxY = m_topoMinY + h * 1.5;
-NS_LOG_INFO ("Added Canvas Margin:" << topo_minX << "," <<
+NS_LOG_INFO ("Added Canvas Margin:" << m_topoMinX << "," <<
-topo_minY << "," << topo_maxX << "," << topo_maxY);
+m_topoMinY << "," << m_topoMaxX << "," << m_topoMaxY);
 }
 std::vector <Ptr <Node> >  AnimationInterface::RecalcTopoBounds ()
 {
 std::vector < Ptr <Node> > MovedNodes;
 return MovedNodes;
 }
 void AnimationInterface::RecalcTopoBounds (Vector v)
 {
-double oldminX = topo_minX;
+double oldminX = m_topoMinX;
-double oldminY = topo_minY;
+double oldminY = m_topoMinY;
-double oldmaxX = topo_maxX;
+double oldmaxX = m_topoMaxX;
-double oldmaxY = topo_maxY;
+double oldmaxY = m_topoMaxY;
-topo_minX = std::min (topo_minX, v.x);
+m_topoMinX = std::min (m_topoMinX, v.x);
-topo_minY = std::min (topo_minY, v.y);
+m_topoMinY = std::min (m_topoMinY, v.y);
-topo_maxX = std::max (topo_maxX, v.x);
+m_topoMaxX = std::max (m_topoMaxX, v.x);
-topo_maxY = std::max (topo_maxY, v.y);
+m_topoMaxY = std::max (m_topoMaxY, v.y);
-if ((topo_minX != oldminX) || (topo_minY != oldminY) ||
+if ((m_topoMinX != oldminX) || (m_topoMinY != oldminY) ||
-(topo_maxX != oldmaxX) || (topo_maxY != oldmaxY))
+(m_topoMaxX != oldmaxX) || (m_topoMaxY != oldmaxY))
 {
 AddMargin ();
 }
 }
 oss << GetXMLOpen_packet (0, tx->GetNode ()->GetId (), fbTx, lbTx);
 oss << GetXMLOpenClose_rx (0, rx->GetNode ()->GetId (), fbRx, lbRx);
 if (m_enablePacketMetadata)
 oss << GetXMLOpenClose_meta (GetPacketMetadata (p));
 oss << GetXMLClose ("packet");
+StartNewTraceFile ();
+++m_currentPktCount;
 }
 else
 {
 oss << std::setprecision (10);
 oss << now.GetSeconds () << " P "
 return n->GetDevice (atoi (elements[3].c_str ()));
 }
 void AnimationInterface::AddPendingWifiPacket (uint64_t AnimUid, AnimPacketInfo &pktinfo)
 {
-pendingWifiPackets[AnimUid] = pktinfo;
+m_pendingWifiPackets[AnimUid] = pktinfo;
 }
 void AnimationInterface::AddPendingWimaxPacket (uint64_t AnimUid, AnimPacketInfo &pktinfo)
 {
 NS_ASSERT (pktinfo.m_txnd);
-pendingWimaxPackets[AnimUid] = pktinfo;
+m_pendingWimaxPackets[AnimUid] = pktinfo;
 }
 void AnimationInterface::AddPendingLtePacket (uint64_t AnimUid, AnimPacketInfo &pktinfo)
 {
 NS_ASSERT (pktinfo.m_txnd);
-pendingLtePackets[AnimUid] = pktinfo;
+m_pendingLtePackets[AnimUid] = pktinfo;
 }
 void AnimationInterface::AddPendingCsmaPacket (uint64_t AnimUid, AnimPacketInfo &pktinfo)
 {
 NS_ASSERT (pktinfo.m_txnd);
-pendingCsmaPackets[AnimUid] = pktinfo;
+m_pendingCsmaPackets[AnimUid] = pktinfo;
 }
 uint64_t AnimationInterface::GetAnimUidFromPacket (Ptr <const Packet> p)
 {
 AnimByteTag tag;
 NS_ASSERT (ndev);
 // Erase pending wifi
 uint64_t AnimUid = GetAnimUidFromPacket (p);
 NS_LOG_INFO ("TxDropTrace for packet:" << AnimUid);
 NS_ASSERT (WifiPacketIsPending (AnimUid) == true);
-pendingWifiPackets.erase (pendingWifiPackets.find (AnimUid));
+m_pendingWifiPackets.erase (m_pendingWifiPackets.find (AnimUid));
 }
 void AnimationInterface::WifiPhyRxBeginTrace (std::string context,
 Ptr<const Packet> p)
 AnimPacketInfo pktinfo (0, Simulator::Now (), Simulator::Now (), UpdatePosition (txNode), m_macToNodeIdMap[oss.str ()]);
 AddPendingWifiPacket (AnimUid, pktinfo);
 NS_LOG_WARN ("WifiPhyRxBegin: unknown Uid, but we are adding a wifi packet");
 }
 // TODO: NS_ASSERT (WifiPacketIsPending (AnimUid) == true);
-pendingWifiPackets[AnimUid].ProcessRxBegin (ndev, Simulator::Now ());
+m_pendingWifiPackets[AnimUid].ProcessRxBegin (ndev, Simulator::Now ());
-pendingWifiPackets[AnimUid].ProcessRxEnd (ndev, Simulator::Now (), UpdatePosition (n));
+m_pendingWifiPackets[AnimUid].ProcessRxEnd (ndev, Simulator::Now (), UpdatePosition (n));
-OutputWirelessPacket (p, pendingWifiPackets[AnimUid], pendingWifiPackets[AnimUid].GetRxInfo (ndev));
+OutputWirelessPacket (p, m_pendingWifiPackets[AnimUid], m_pendingWifiPackets[AnimUid].GetRxInfo (ndev));
 }
 void AnimationInterface::WifiPhyRxEndTrace (std::string context,
 Ptr<const Packet> p)
 NS_LOG_WARN ("WifiPhyRxEndTrace: unknown Uid");
 AnimPacketInfo pktinfo (ndev, Simulator::Now (), Simulator::Now (), UpdatePosition (n));
 AddPendingWifiPacket (AnimUid, pktinfo);
 }
 // TODO: NS_ASSERT (WifiPacketIsPending (AnimUid) == true);
-AnimPacketInfo& pktInfo = pendingWifiPackets[AnimUid];
+AnimPacketInfo& pktInfo = m_pendingWifiPackets[AnimUid];
 pktInfo.ProcessRxEnd (ndev, Simulator::Now (), UpdatePosition (n));
 AnimRxInfo pktrxInfo = pktInfo.GetRxInfo (ndev);
 if (pktrxInfo.IsPhyRxComplete ())
 {
 NS_LOG_INFO ("MacRxTrace for packet:" << AnimUid << " complete");
 {
 NS_LOG_WARN ("WifiMacRxTrace: unknown Uid");
 return;
 }
 // TODO: NS_ASSERT (WifiPacketIsPending (AnimUid) == true);
-AnimPacketInfo& pktInfo = pendingWifiPackets[AnimUid];
+AnimPacketInfo& pktInfo = m_pendingWifiPackets[AnimUid];
 AnimRxInfo pktrxInfo = pktInfo.GetRxInfo (ndev);
 if (pktrxInfo.IsPhyRxComplete ())
 {
 NS_LOG_INFO ("MacRxTrace for packet:" << AnimUid << " complete");
 OutputWirelessPacket (p, pktInfo, pktrxInfo);
 Ptr <Node> n = ndev->GetNode ();
 NS_ASSERT (n);
 uint64_t AnimUid = GetAnimUidFromPacket (p);
 NS_LOG_INFO ("WimaxRxTrace for packet:" << AnimUid);
 NS_ASSERT (WimaxPacketIsPending (AnimUid) == true);
-AnimPacketInfo& pktInfo = pendingWimaxPackets[AnimUid];
+AnimPacketInfo& pktInfo = m_pendingWimaxPackets[AnimUid];
 pktInfo.ProcessRxBegin (ndev, Simulator::Now ());
 pktInfo.ProcessRxEnd (ndev, Simulator::Now () + Seconds (0.001), UpdatePosition (n));
 //TODO 0.001 is used until Wimax implements RxBegin and RxEnd traces
 AnimRxInfo pktrxInfo = pktInfo.GetRxInfo (ndev);
 OutputWirelessPacket (p, pktInfo, pktrxInfo);
 if (!LtePacketIsPending (AnimUid))
 {
 NS_LOG_WARN ("LteRxTrace: unknown Uid");
 return;
 }
-AnimPacketInfo& pktInfo = pendingLtePackets[AnimUid];
+AnimPacketInfo& pktInfo = m_pendingLtePackets[AnimUid];
 pktInfo.ProcessRxBegin (ndev, Simulator::Now ());
 pktInfo.ProcessRxEnd (ndev, Simulator::Now () + Seconds (0.001), UpdatePosition (n));
 //TODO 0.001 is used until Lte implements RxBegin and RxEnd traces
 AnimRxInfo pktrxInfo = pktInfo.GetRxInfo (ndev);
 OutputWirelessPacket (p, pktInfo, pktrxInfo);
 AnimPacketInfo pktinfo (ndev, Simulator::Now (), Simulator::Now (), UpdatePosition (n));
 AddPendingCsmaPacket (AnimUid, pktinfo);
 NS_LOG_WARN ("Unknown Uid, but adding Csma Packet anyway");
 }
 // TODO: NS_ASSERT (CsmaPacketIsPending (AnimUid) == true);
-AnimPacketInfo& pktInfo = pendingCsmaPackets[AnimUid];
+AnimPacketInfo& pktInfo = m_pendingCsmaPackets[AnimUid];
 pktInfo.m_lbTx = Simulator::Now ().GetSeconds ();
 }
 void AnimationInterface::CsmaPhyRxEndTrace (std::string context, Ptr<const Packet> p)
 {
 {
 NS_LOG_WARN ("CsmaPhyRxEndTrace: unknown Uid");
 return;
 }
 // TODO: NS_ASSERT (CsmaPacketIsPending (AnimUid) == true);
-AnimPacketInfo& pktInfo = pendingCsmaPackets[AnimUid];
+AnimPacketInfo& pktInfo = m_pendingCsmaPackets[AnimUid];
-pendingCsmaPackets[AnimUid].ProcessRxBegin (ndev, Simulator::Now ());
+m_pendingCsmaPackets[AnimUid].ProcessRxBegin (ndev, Simulator::Now ());
 pktInfo.ProcessRxEnd (ndev, Simulator::Now (), UpdatePosition (n));
 NS_LOG_INFO ("CsmaPhyRxEndTrace for packet:" << AnimUid);
 }
 {
 NS_LOG_WARN ("CsmaMacRxTrace: unknown Uid");
 return;
 }
 // TODO: NS_ASSERT (CsmaPacketIsPending (AnimUid) == true);
-AnimPacketInfo& pktInfo = pendingCsmaPackets[AnimUid];
+AnimPacketInfo& pktInfo = m_pendingCsmaPackets[AnimUid];
 AnimRxInfo pktrxInfo = pktInfo.GetRxInfo (ndev);
 if (pktrxInfo.IsPhyRxComplete ())
 {
 NS_LOG_INFO ("MacRxTrace for packet:" << AnimUid << " complete");
 OutputCsmaPacket (p, pktInfo, pktrxInfo);
 v = mobility->GetPosition ();
 }
 UpdatePosition (n,v);
 RecalcTopoBounds (v);
 std::ostringstream oss;
-oss << GetXMLOpen_topology (topo_minX,topo_minY,topo_maxX,topo_maxY);
+oss << GetXMLOpen_topology (m_topoMinX, m_topoMinY, m_topoMaxX, m_topoMaxY);
 oss << GetXMLOpenClose_node (0,n->GetId (),v.x,v.y);
 oss << GetXMLClose ("topology");
 WriteN (m_fHandle, oss.str ());
 WriteDummyPacket ();
 }
 {
 if (!m_started || !IsInTimeWindow ())
 return;
 std::vector <Ptr <Node> > MovedNodes = RecalcTopoBounds ();
 std::ostringstream oss;
-oss << GetXMLOpen_topology (topo_minX, topo_minY, topo_maxX, topo_maxY);
+oss << GetXMLOpen_topology (m_topoMinX, m_topoMinY, m_topoMaxX, m_topoMaxY);
 for (uint32_t i = 0; i < MovedNodes.size (); i++)
 {
 Ptr <Node> n = MovedNodes [i];
 NS_ASSERT (n);
 Vector v = GetPosition (n);
 {
 PurgePendingWifi ();
 PurgePendingWimax ();
 PurgePendingLte ();
 PurgePendingCsma ();
-Simulator::Schedule (mobilitypollinterval, &AnimationInterface::MobilityAutoCheck, this);
+Simulator::Schedule (m_mobilityPollInterval, &AnimationInterface::MobilityAutoCheck, this);
 }
 }
 std::string AnimationInterface::GetPacketMetadata (Ptr<const Packet> p)
 {
 std::ostringstream oss;
 p->Print (oss);
 return oss.str ();
 }
+uint64_t AnimationInterface::GetTracePktCount ()
+{
+return m_currentPktCount;
+}
 // Helper to output a wireless packet.
 // For now, only the XML interface is supported
 return s;
 }
 void AnimationInterface::OutputWirelessPacket (Ptr<const Packet> p, AnimPacketInfo &pktInfo, AnimRxInfo pktrxInfo)
 {
+StartNewTraceFile ();
 NS_ASSERT (m_xml);
 std::ostringstream oss;
 uint32_t nodeId =  0;
 if (pktInfo.m_txnd)
 nodeId = pktInfo.m_txnd->GetNode ()->GetId ();
 WriteN (m_fHandle, oss.str ());
 }
 void AnimationInterface::OutputCsmaPacket (Ptr<const Packet> p, AnimPacketInfo &pktInfo, AnimRxInfo pktrxInfo)
 {
+StartNewTraceFile ();
 NS_ASSERT (m_xml);
 std::ostringstream oss;
 NS_ASSERT (pktInfo.m_txnd);
 uint32_t nodeId = pktInfo.m_txnd->GetNode ()->GetId ();

changeset 8773	25b20434eba8
parent 7823	2a669a0c452e
child 8778	bf37816b37ad