add tests and fixups

model/leo-mock-channel.cc

@@ -62,12 +62,17 @@ LeoMockChannel::TransmitStart (Ptr<const Packet> p,
           NS_LOG_ERROR ("unable to find satellite with address " << dst);
           return false;
         }
-      NS_LOG_DEBUG ("BOOOOM " << srcDev->GetAddress () << " -> " << dst);
       return Deliver (p, srcDev, it->second, txTime);
     }
   else
     // space to ground delivers to everything within the beam
     {
+      DeviceIndex::iterator it = m_groundDevices.find (dst);
+      if (it == m_groundDevices.end ())
+        {
+          NS_LOG_ERROR ("unable to find satellite with address " << dst);
+          return false;
+        }
       for (DeviceIndex::iterator it = m_groundDevices.begin ();
            it != m_groundDevices.end ();
            it++)

model/leo-propagation-loss-model.cc

@@ -0,0 +1,51 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+
+#include "leo-propagation-loss-model.h"
+
+namespace ns3 {
+
+NS_LOG_COMPONENT_DEFINE ("LeoPropagationLossModel");
+
+NS_OBJECT_ENSURE_REGISTERED (LeoPropagationLossModel);
+
+TypeId
+LeoPropagationLossModel::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::LeoPropagationLossModel")
+    .SetParent<PropagationLossModel> ()
+    .SetGroupName ("Leo")
+    .AddConstructor<LeoPropagationLossModel> ()
+  ;
+  return tid;
+}
+
+LeoPropagationLossModel::LeoPropagationLossModel ()
+{
+}
+
+LeoPropagationLossModel::~LeoPropagationLossModel ()
+{
+}
+
+double
+LeoPropagationLossModel::DoCalcRxPower (double txPowerDbm,
+                                           Ptr<MobilityModel> a,
+                                           Ptr<MobilityModel> b) const
+{
+  //Vector aPos = a->GetPosition ();
+  //Vector bPos = b->GetPosition ();
+
+  // TODO perform line-earth intersection (ray tracing)
+
+  double rxc = 0;//-m_variable->GetValue ();
+  NS_LOG_DEBUG ("attenuation coefficient="<<rxc<<"Db");
+  return txPowerDbm + rxc;
+}
+
+int64_t
+LeoPropagationLossModel::DoAssignStreams (int64_t stream)
+{
+  return 0;
+}
+
+};

model/leo-propagation-loss-model.h

@@ -0,0 +1,40 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+
+#ifndef LEO_PROPAGATION_LOSS_MODEL_H
+#define LEO_PROPAGATION_LOSS_MODEL_H
+
+#include "leo-mobility-model.h"
+#include <ns3/object.h>
+#include <ns3/propagation-loss-model.h>
+
+namespace ns3 {
+
+class LeoPropagationLossModel : public PropagationLossModel
+{
+public:
+  static TypeId GetTypeId (void);
+  LeoPropagationLossModel ();
+  virtual ~LeoPropagationLossModel ();
+private:
+  /**
+   * Returns the Rx Power taking into account only the particular
+   * PropagationLossModel.
+   *
+   * \param txPowerDbm current transmission power (in dBm)
+   * \param a the mobility model of the source
+   * \param b the mobility model of the destination
+   * \returns the reception power after adding/multiplying propagation loss (in dBm)
+   */
+  virtual double DoCalcRxPower (double txPowerDbm,
+                                Ptr<MobilityModel> a,
+                                Ptr<MobilityModel> b) const;
+  /**
+   * Subclasses must implement this; those not using random variables
+   * can return zero
+   */
+  virtual int64_t DoAssignStreams (int64_t stream);
+};
+
+}
+
+#endif /* SATELLITE_LEO_PROPAGATION_LOSS_MODEL_H */

test/leo-mock-channel-test-suite.cc

@@ -0,0 +1,219 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+
+#include "ns3/core-module.h"
+#include "ns3/network-module.h"
+#include "ns3/internet-module.h"
+#include "ns3/applications-module.h"
+#include "ns3/node-container.h"
+
+#include "ns3/leo-module.h"
+#include "ns3/test.h"
+
+using namespace ns3;
+
+class LeoMockChannelTransmitUnknownTestCase : public TestCase
+{
+public:
+  LeoMockChannelTransmitUnknownTestCase ();
+  virtual ~LeoMockChannelTransmitUnknownTestCase ();
+
+private:
+  virtual void DoRun (void);
+};
+
+LeoMockChannelTransmitUnknownTestCase::LeoMockChannelTransmitUnknownTestCase ()
+  : TestCase ("Test transmission to unkown destination")
+{
+}
+
+LeoMockChannelTransmitUnknownTestCase::~LeoMockChannelTransmitUnknownTestCase ()
+{
+}
+
+void
+LeoMockChannelTransmitUnknownTestCase::DoRun (void)
+{
+  Ptr<LeoMockChannel> channel = CreateObject<LeoMockChannel> ();
+  Packet *packet = new Packet ();
+  Ptr<Packet> p = Ptr<Packet>(packet);
+  Ptr<LeoMockNetDevice> dev = CreateObject<LeoMockNetDevice> ();
+  dev->SetDeviceType (LeoMockNetDevice::GND);
+  int32_t srcId = channel->Attach (dev);
+  Address destAddr;
+  Time txTime;
+  channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel"));
+  channel->SetAttribute ("PropagationLoss", StringValue ("ns3::LeoPropagationLossModel"));
+  dev->SetAttribute ("MobilityModel", StringValue ("ns3::ConstantPositionMobilityModel"));
+  bool result = channel->TransmitStart (p, srcId, destAddr, txTime);
+
+  NS_TEST_ASSERT_MSG_EQ (result, false, "Unknown destination fails to deliver");
+}
+
+class LeoMockChannelTransmitKnownTestCase : public TestCase
+{
+public:
+  LeoMockChannelTransmitKnownTestCase ();
+  virtual ~LeoMockChannelTransmitKnownTestCase ();
+
+private:
+  virtual void DoRun (void);
+};
+
+LeoMockChannelTransmitKnownTestCase::LeoMockChannelTransmitKnownTestCase ()
+  : TestCase ("Test transmission to known destination")
+{
+}
+
+LeoMockChannelTransmitKnownTestCase::~LeoMockChannelTransmitKnownTestCase ()
+{
+}
+
+void
+LeoMockChannelTransmitKnownTestCase::DoRun (void)
+{
+  Ptr<LeoMockChannel> channel = CreateObject<LeoMockChannel> ();
+  channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel"));
+  channel->SetAttribute ("PropagationLoss", StringValue ("ns3::LeoPropagationLossModel"));
+
+  Packet *packet = new Packet ();
+  Ptr<Packet> p = Ptr<Packet>(packet);
+
+  Ptr<Node> srcNode = CreateObject<Node> ();
+  Ptr<LeoMockNetDevice> srcDev = CreateObject<LeoMockNetDevice> ();
+  srcDev->SetNode (srcNode);
+  srcDev->SetAttribute ("MobilityModel", StringValue ("ns3::ConstantPositionMobilityModel"));
+  srcDev->SetDeviceType (LeoMockNetDevice::GND);
+  int32_t srcId = channel->Attach (srcDev);
+
+  Ptr<Node> dstNode = CreateObject<Node> ();
+  Ptr<LeoMockNetDevice> dstDev = CreateObject<LeoMockNetDevice> ();
+  dstDev->SetNode (dstNode);
+  dstDev->SetAttribute ("MobilityModel", StringValue ("ns3::LeoMobilityModel"));
+  dstDev->SetDeviceType (LeoMockNetDevice::SAT);
+  channel->Attach (dstDev);
+
+  Address destAddr = dstDev->GetAddress ();
+  Time txTime;
+  bool result = channel->TransmitStart (p, srcId, destAddr, txTime);
+
+  NS_TEST_ASSERT_MSG_EQ (result, true, "Known destination delivers");
+}
+
+class LeoMockChannelTransmitSpaceGroundTestCase : public TestCase
+{
+public:
+  LeoMockChannelTransmitSpaceGroundTestCase ();
+  virtual ~LeoMockChannelTransmitSpaceGroundTestCase ();
+
+private:
+  virtual void DoRun (void);
+};
+
+LeoMockChannelTransmitSpaceGroundTestCase::LeoMockChannelTransmitSpaceGroundTestCase ()
+  : TestCase ("Test transmission to known destination")
+{
+}
+
+LeoMockChannelTransmitSpaceGroundTestCase::~LeoMockChannelTransmitSpaceGroundTestCase ()
+{
+}
+
+void
+LeoMockChannelTransmitSpaceGroundTestCase::DoRun (void)
+{
+  Ptr<LeoMockChannel> channel = CreateObject<LeoMockChannel> ();
+  channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel"));
+  channel->SetAttribute ("PropagationLoss", StringValue ("ns3::LeoPropagationLossModel"));
+
+  Packet *packet = new Packet ();
+  Ptr<Packet> p = Ptr<Packet>(packet);
+
+  Ptr<Node> srcNode = CreateObject<Node> ();
+  Ptr<LeoMockNetDevice> srcDev = CreateObject<LeoMockNetDevice> ();
+  srcDev->SetNode (srcNode);
+  srcDev->SetAttribute ("MobilityModel", StringValue ("ns3::LeoMobilityModel"));
+  srcDev->SetDeviceType (LeoMockNetDevice::SAT);
+  int32_t srcId = channel->Attach (srcDev);
+
+  Ptr<Node> dstNode = CreateObject<Node> ();
+  Ptr<LeoMockNetDevice> dstDev = CreateObject<LeoMockNetDevice> ();
+  dstDev->SetNode (dstNode);
+  dstDev->SetAttribute ("MobilityModel", StringValue ("ns3::ConstantPositionMobilityModel"));
+  dstDev->SetDeviceType (LeoMockNetDevice::GND);
+  channel->Attach (dstDev);
+
+  Address destAddr = dstDev->GetAddress ();
+  Time txTime;
+  bool result = channel->TransmitStart (p, srcId, destAddr, txTime);
+
+  NS_TEST_ASSERT_MSG_EQ (result, true, "Space to ground destination delivers");
+}
+
+class LeoMockChannelTransmitSpaceSpaceTestCase : public TestCase
+{
+public:
+  LeoMockChannelTransmitSpaceSpaceTestCase ();
+  virtual ~LeoMockChannelTransmitSpaceSpaceTestCase ();
+
+private:
+  virtual void DoRun (void);
+};
+
+LeoMockChannelTransmitSpaceSpaceTestCase::LeoMockChannelTransmitSpaceSpaceTestCase ()
+  : TestCase ("Test transmission to known destination")
+{
+}
+
+LeoMockChannelTransmitSpaceSpaceTestCase::~LeoMockChannelTransmitSpaceSpaceTestCase ()
+{
+}
+
+void
+LeoMockChannelTransmitSpaceSpaceTestCase::DoRun (void)
+{
+  Ptr<LeoMockChannel> channel = CreateObject<LeoMockChannel> ();
+  channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel"));
+  channel->SetAttribute ("PropagationLoss", StringValue ("ns3::LeoPropagationLossModel"));
+
+  Packet *packet = new Packet ();
+  Ptr<Packet> p = Ptr<Packet>(packet);
+
+  Ptr<Node> srcNode = CreateObject<Node> ();
+  Ptr<LeoMockNetDevice> srcDev = CreateObject<LeoMockNetDevice> ();
+  srcDev->SetNode (srcNode);
+  srcDev->SetAttribute ("MobilityModel", StringValue ("ns3::LeoMobilityModel"));
+  srcDev->SetDeviceType (LeoMockNetDevice::SAT);
+  int32_t srcId = channel->Attach (srcDev);
+
+  Ptr<Node> dstNode = CreateObject<Node> ();
+  Ptr<LeoMockNetDevice> dstDev = CreateObject<LeoMockNetDevice> ();
+  dstDev->SetNode (dstNode);
+  dstDev->SetAttribute ("MobilityModel", StringValue ("ns3::LeoMobilityModel"));
+  dstDev->SetDeviceType (LeoMockNetDevice::SAT);
+  channel->Attach (dstDev);
+
+  Address destAddr = dstDev->GetAddress ();
+  Time txTime;
+  bool result = channel->TransmitStart (p, srcId, destAddr, txTime);
+
+  NS_TEST_ASSERT_MSG_EQ (result, false, "Space to space gets dropped");
+}
+
+class LeoMockChannelTestSuite : public TestSuite
+{
+public:
+  LeoMockChannelTestSuite ();
+};
+
+LeoMockChannelTestSuite::LeoMockChannelTestSuite ()
+  : TestSuite ("leo-mock-channel", UNIT)
+{
+  // TestDuration for TestCase can be QUICK, EXTENSIVE or TAKES_FOREVER
+  AddTestCase (new LeoMockChannelTransmitUnknownTestCase, TestCase::QUICK);
+  AddTestCase (new LeoMockChannelTransmitKnownTestCase, TestCase::QUICK);
+  AddTestCase (new LeoMockChannelTransmitSpaceGroundTestCase, TestCase::QUICK);
+  AddTestCase (new LeoMockChannelTransmitSpaceSpaceTestCase, TestCase::QUICK);
+}
+
+// Do not forget to allocate an instance of this TestSuite
+static LeoMockChannelTestSuite islMockChannelTestSuite;

test/leo-test-suite.cc

@@ -48,7 +48,6 @@ LeoTestCase1::DoRun (void)
   LeoHelper leo;
   leo.SetDeviceAttribute ("DataRate", StringValue ("10Mbps"));
   leo.SetChannelAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel"));
-  leo.SetChannelAttribute ("PropagationLoss", StringValue ("ns3::IslPropagationLossModel"));
   leo.SetDeviceAttribute ("MobilityModel", StringValue ("ns3::LeoMobilityModel"));
 
   NetDeviceContainer allDevices = leo.Install (satellites, gateways, terminals);

wscript

@@ -18,6 +18,7 @@ def build(bld):
         'model/leo-mock-channel.cc',
         'model/leo-mock-net-device.cc',
         'helper/leo-helper.cc',
+        'model/leo-propagation-loss-model.cc',
         'model/mock-net-device.cc',
         'model/mock-channel.cc',
         'helper/nd-cache-helper.cc',
@@ -28,6 +29,7 @@ def build(bld):
         'test/leo-test-suite.cc',
         'test/isl-test-suite.cc',
         'test/isl-mock-channel-test-suite.cc',
+        'test/leo-mock-channel-test-suite.cc',
         ]
 
     headers = bld(features='ns3header')
@@ -42,6 +44,7 @@ def build(bld):
         'model/leo-mock-channel.h',
         'model/leo-mock-net-device.h',
         'helper/leo-helper.h',
+        'model/leo-propagation-loss-model.h',
         'model/mock-net-device.h',
         'model/mock-channel.h',
         'helper/nd-cache-helper.h',