animation-interface.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: George F. Riley<riley@ece.gatech.edu>
 * Author: John Abraham <john.abraham@gatech.edu>
 * Contributions: Eugene Kalishenko <ydginster@gmail.com> (Open Source and Linux Laboratory http://dev.osll.ru/)
 */

// Interface between ns3 and the network animator

#ifndef ANIMATION_INTERFACE__H
#define ANIMATION_INTERFACE__H

#include <string>
#include <cstdio>
#include <map>
#include "ns3/ptr.h"
#include "ns3/net-device.h"
#include "ns3/node-container.h"
#include "ns3/nstime.h"
#include "ns3/log.h"
#include "ns3/node-list.h"
#include "ns3/random-variable-stream.h"
#include "ns3/simulator.h"
#include "ns3/config.h"
#include "ns3/animation-interface-helper.h"
#include "ns3/mac48-address.h"
#include "ns3/lte-ue-net-device.h"
#include "ns3/lte-enb-net-device.h"
#include "ns3/uan-phy-gen.h"
#include "ns3/rectangle.h"

namespace ns3 {

#define MAX_PKTS_PER_TRACE_FILE 100000
struct Rgb;
typedef struct 
{
  uint32_t fromNode;
  uint32_t toNode;
} P2pLinkNodeIdPair;

typedef struct
{
  std::string fromNodeDescription;
  std::string toNodeDescription;
  std::string linkDescription;
} LinkProperties;

struct LinkPairCompare
{
  bool operator () (P2pLinkNodeIdPair first, P2pLinkNodeIdPair second) const
    {
      //Check if they are the same node pairs but flipped
      if (  ((first.fromNode == second.fromNode) && (first.toNode == second.toNode)) ||
            ((first.fromNode == second.toNode) && (first.toNode == second.fromNode)) )
        {
          return false;
        }
      std::ostringstream oss1;
      oss1 << first.fromNode << first.toNode;
      std::ostringstream oss2;
      oss2 << second.fromNode << second.toNode;
      return oss1.str () < oss2.str ();
    }
   
};

struct Ipv4RouteTrackElement {
  std::string destination;
  uint32_t fromNodeId;
};


typedef struct {
  uint32_t nodeId;
  std::string nextHop;
  
} Ipv4RoutePathElement;

class AnimationInterface
{
public:

  AnimationInterface (const std::string filename, 
    uint64_t maxPktsPerFile = MAX_PKTS_PER_TRACE_FILE, 
    bool usingXML = true);

  ~AnimationInterface ();

  AnimationInterface & EnableIpv4RouteTracking (std::string fileName, Time startTime, Time stopTime, Time pollInterval = Seconds (5));

  AnimationInterface & EnableIpv4RouteTracking (std::string fileName, Time startTime, Time stopTime, NodeContainer nc, Time pollInterval = Seconds (5));

  static bool IsInitialized (void);

  void SetStartTime (Time t);

  void SetStopTime (Time t);

  void SetMobilityPollInterval (Time t);

  void SetRandomPosition (bool setRandPos);

  typedef void (*AnimWriteCallback) (const char * str);

  void SetAnimWriteCallback (AnimWriteCallback cb);

  void ResetAnimWriteCallback ();

  static void SetConstantPosition (Ptr <Node> n, double x, double y, double z=0);

  static void SetBoundary (double minX, double minY, double maxX, double maxY);

  static void SetNodeDescription (Ptr <Node> n, std::string descr);

  void UpdateNodeDescription (Ptr <Node> n, std::string descr);

  void UpdateNodeDescription (uint32_t nodeId, std::string descr);

  void ShowNode (uint32_t nodeId, bool show = true);

  void ShowNode (Ptr <Node> n, bool show = true);

  static void SetNodeDescription (NodeContainer nc, std::string descr);

  static void SetNodeColor (Ptr <Node> n, uint8_t r, uint8_t g, uint8_t b);


  void UpdateNodeColor (Ptr <Node> n, uint8_t r, uint8_t g, uint8_t b);

  void UpdateNodeColor (uint32_t nodeId, uint8_t r, uint8_t g, uint8_t b);


  static void SetNodeColor (NodeContainer nc, uint8_t r, uint8_t g, uint8_t b);

  static void SetLinkDescription (uint32_t fromNode, uint32_t toNode, 
                                  std::string linkDescription,
                                  std::string fromNodeDescription = "",
                                  std::string toNodeDescription = "");

  static void SetLinkDescription (Ptr <Node> fromNode, Ptr <Node> toNode,
                                  std::string linkDescription,
                                  std::string fromNodeDescription = "",
                                  std::string toNodeDescription = "");


  void UpdateLinkDescription (uint32_t fromNode, uint32_t toNode,
                              std::string linkDescription);

  void UpdateLinkDescription (Ptr <Node> fromNode, Ptr <Node> toNode,
                              std::string linkDescription);

  AnimationInterface & AddSourceDestination (uint32_t fromNodeId, std::string destinationIpv4Address);

  bool IsStarted (void);

  void EnablePacketMetadata (bool enable);

  uint64_t GetTracePktCount ();

  double GetNodeEnergyFraction (Ptr <const Node> node) const;

  int64_t AssignStreams (int64_t stream);

private:
  FILE * m_f; // File handle for output (0 if none)
  FILE * m_routingF; // File handle for routing table output (0 if None);
  // Write specified amount of data to the specified handle
  int WriteN (const char*, uint32_t, FILE * f);
  bool m_xml;      // True if xml format desired
  Time m_mobilityPollInterval;
  std::string m_outputFileName;
  bool m_outputFileSet;
  uint64_t gAnimUid ;    // Packet unique identifier used by Animtion
  bool m_randomPosition;
  AnimWriteCallback m_writeCallback;
  bool m_started;
  bool m_enablePacketMetadata; 
  Time m_startTime;
  Time m_stopTime;
  uint64_t m_maxPktsPerFile;
  std::string m_originalFileName;
  Time m_routingStopTime;
  std::string m_routingFileName;
  Time m_routingPollInterval;
  NodeContainer m_routingNc;
  
  void TrackIpv4Route ();
  void TrackIpv4RoutePaths ();
  std::string GetIpv4RoutingTable (Ptr <Node> n);

  bool SetOutputFile (const std::string& fn);
  bool SetRoutingOutputFile (const std::string& fn);

  void SetXMLOutput ();

  void StartAnimation (bool restart = false);

  void StopAnimation (bool onlyAnimation = false);

  void DevTxTrace (std::string context,
                   Ptr<const Packet> p,
                   Ptr<NetDevice> tx,
                   Ptr<NetDevice> rx,
                   Time txTime,
                   Time rxTime);
  void WifiPhyTxBeginTrace (std::string context,
                            Ptr<const Packet> p);
  void WifiPhyTxEndTrace (std::string context,
                          Ptr<const Packet> p);
  void WifiPhyTxDropTrace (std::string context,
                           Ptr<const Packet> p);
  void WifiPhyRxBeginTrace (std::string context,
                            Ptr<const Packet> p);
  void WifiPhyRxEndTrace (std::string context,
                          Ptr<const Packet> p);
  void WifiMacRxTrace (std::string context,
                       Ptr<const Packet> p);
  void WifiPhyRxDropTrace (std::string context,
                           Ptr<const Packet> p);
  void WimaxTxTrace (std::string context,
                     Ptr<const Packet> p,
             const Mac48Address &);
  void WimaxRxTrace (std::string context,
                     Ptr<const Packet> p,
                     const Mac48Address &);
  void CsmaPhyTxBeginTrace (std::string context,
                            Ptr<const Packet> p);
  void CsmaPhyTxEndTrace (std::string context,
                            Ptr<const Packet> p);
  void CsmaPhyRxEndTrace (std::string context,
                          Ptr<const Packet> p);
  void CsmaMacRxTrace (std::string context,
                       Ptr<const Packet> p);

  void LteTxTrace (std::string context,
                      Ptr<const Packet> p,
                      const Mac48Address &);

  void LteRxTrace (std::string context,
                      Ptr<const Packet> p,
                      const Mac48Address &);

  void LteSpectrumPhyTxStart (std::string context,
                      Ptr<const PacketBurst> pb);
  void LteSpectrumPhyRxStart (std::string context,
                      Ptr<const PacketBurst> pb);

  void UanPhyGenTxTrace (std::string context,
                         Ptr<const Packet>);
  void UanPhyGenRxTrace (std::string context,
                         Ptr<const Packet>);

  void RemainingEnergyTrace (std::string context, double previousEnergy, double currentEnergy);

  void MobilityCourseChangeTrace (Ptr <const MobilityModel> mob);

  // Write a string to the specified handle;
  int  WriteN (const std::string&, FILE * f);

  void OutputWirelessPacket (Ptr<const Packet> p, AnimPacketInfo& pktInfo, AnimRxInfo pktrxInfo);
  void OutputCsmaPacket (Ptr<const Packet> p, AnimPacketInfo& pktInfo, AnimRxInfo pktrxInfo);
  void MobilityAutoCheck ();
  

  std::map<uint64_t, AnimPacketInfo> m_pendingWifiPackets;
  void AddPendingWifiPacket (uint64_t AnimUid, AnimPacketInfo&);
  bool WifiPacketIsPending (uint64_t AnimUid); 

  std::map<uint64_t, AnimPacketInfo> m_pendingWimaxPackets;
  void AddPendingWimaxPacket (uint64_t AnimUid, AnimPacketInfo&);
  bool WimaxPacketIsPending (uint64_t AnimUid); 

  std::map<uint64_t, AnimPacketInfo> m_pendingLtePackets;
  void AddPendingLtePacket (uint64_t AnimUid, AnimPacketInfo&);
  bool LtePacketIsPending (uint64_t AnimUid);

  std::map<uint64_t, AnimPacketInfo> m_pendingCsmaPackets;
  void AddPendingCsmaPacket (uint64_t AnimUid, AnimPacketInfo&);
  bool CsmaPacketIsPending (uint64_t AnimUid);

  std::map<uint64_t, AnimPacketInfo> m_pendingUanPackets;
  void AddPendingUanPacket (uint64_t AnimUid, AnimPacketInfo&);
  bool UanPacketIsPending (uint64_t AnimUid);

  uint64_t GetAnimUidFromPacket (Ptr <const Packet>);

  std::map<uint32_t, Vector> m_nodeLocation;
  Vector GetPosition (Ptr <Node> n);
  Vector UpdatePosition (Ptr <Node> n);
  Vector UpdatePosition (Ptr <Node> n, Vector v);
  void WriteDummyPacket ();
  bool NodeHasMoved (Ptr <Node> n, Vector newLocation);

  void PurgePendingWifi ();
  void PurgePendingWimax ();
  void PurgePendingLte ();
  void PurgePendingCsma ();

  // Recalculate topology bounds
  void RecalcTopoBounds (Vector v);
  std::vector < Ptr <Node> > RecalcTopoBounds ();

  void ConnectCallbacks ();
  void ConnectLte ();
  void ConnectLteUe (Ptr <Node> n, Ptr <LteUeNetDevice> nd, uint32_t devIndex);
  void ConnectLteEnb (Ptr <Node> n, Ptr <LteEnbNetDevice> nd, uint32_t devIndex);

  
  std::map <std::string, uint32_t> m_macToNodeIdMap;
  std::map <std::string, uint32_t> m_ipv4ToNodeIdMap;
  void AddToIpv4AddressNodeIdTable (std::string, uint32_t);
  std::vector <Ipv4RouteTrackElement> m_ipv4RouteTrackElements;
  typedef std::vector <Ipv4RoutePathElement> Ipv4RoutePathElements;
  void RecursiveIpv4RoutePathSearch (std::string fromIpv4, std::string toIpv4, Ipv4RoutePathElements &);
  void WriteRoutePath (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements);
  bool IsInTimeWindow ();

  // Path helper
  const std::vector<std::string> GetElementsFromContext (const std::string& context) const;
  Ptr <Node> GetNodeFromContext (const std::string& context) const;
  Ptr <NetDevice> GetNetDeviceFromContext (std::string context);

  typedef std::map <uint32_t, double> EnergyFractionMap;

  static std::map <uint32_t, Rgb> nodeColors;
  static std::map <uint32_t, std::string> nodeDescriptions;
  static std::map <P2pLinkNodeIdPair, LinkProperties, LinkPairCompare> linkProperties;
  EnergyFractionMap m_nodeEnergyFraction;
  uint64_t m_currentPktCount;

  void StartNewTraceFile ();

  std::string GetMacAddress (Ptr <NetDevice> nd);
  std::string GetIpv4Address (Ptr <NetDevice> nd);
  void WriteNonP2pLinkProperties (uint32_t id, std::string ipv4Address, std::string channelType);

  void WriteNodeUpdate (uint32_t nodeId);

  std::string GetNetAnimVersion ();

  // XML helpers
  std::string GetPreamble (void);
  // Topology element dimensions
  double m_topoMinX;
  double m_topoMinY;
  double m_topoMaxX;
  double m_topoMaxY;
  static Rectangle * userBoundary;

  std::string GetPacketMetadata (Ptr<const Packet> p);

  std::string GetXMLOpen_anim (uint32_t lp);
  std::string GetXMLOpen_topology (double minX, double minY, double maxX, double maxY);
  std::string GetXMLOpenClose_node (uint32_t lp, uint32_t id, double locX, double locY);
  std::string GetXMLOpenClose_node (uint32_t lp, uint32_t id, double locX, double locY, struct Rgb rgb);
  std::string GetXMLOpenClose_nodeupdate (uint32_t id, bool visible = true);
  std::string GetXMLOpenClose_link (uint32_t fromLp, uint32_t fromId, uint32_t toLp, uint32_t toId);
  std::string GetXMLOpenClose_linkupdate (uint32_t fromId, uint32_t toId, std::string);
  std::string GetXMLOpen_packet (uint32_t fromLp, uint32_t fromId, double fbTx, double lbTx, std::string auxInfo = "");
  std::string GetXMLOpenClose_p (std::string pktType, uint32_t fId, double fbTx, double lbTx, uint32_t tId, double fbRx, double lbRx,
                                 std::string metaInfo = "", std::string auxInfo = "");
  std::string GetXMLOpenClose_rx (uint32_t toLp, uint32_t toId, double fbRx, double lbRx);
  std::string GetXMLOpen_wpacket (uint32_t fromLp, uint32_t fromId, double fbTx, double lbTx, double range);
  std::string GetXMLClose (std::string name) {return "</" + name + ">\n"; }
  std::string GetXMLOpenClose_meta (std::string metaInfo);
  std::string GetXMLOpenClose_NonP2pLinkProperties (uint32_t id, std::string ipv4Address, std::string channelType);
  std::string GetXMLOpenClose_routing (uint32_t id, std::string routingInfo);
  std::string GetXMLOpenClose_rp (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements);

  void AppendXMLNodeDescription (std::ostream& ostream, uint32_t id) const;
  void AppendXMLNodeColor (std::ostream& ostream, const Rgb& color) const;
  void AppendXMLRemainingEnergy (std::ostream& ostream, uint32_t id) const;

  Ptr<UniformRandomVariable> m_uniformRandomVariable;  
};

struct Rgb 
{
  uint8_t r;
  uint8_t g;
  uint8_t b;
};

class AnimByteTag : public Tag
{
public:

  static TypeId GetTypeId (void);
  
  virtual TypeId GetInstanceTypeId (void) const;

  virtual uint32_t GetSerializedSize (void) const;

  virtual void Serialize (TagBuffer i) const;

  virtual void Deserialize (TagBuffer i);

  virtual void Print (std::ostream &os) const;

  void Set (uint64_t AnimUid);

  uint64_t Get (void) const;

private:
  uint64_t m_AnimUid;
};

}
#endif