class PropagationLossCacheTestCase : public TestCase

{

public:

  PropagationLossCacheTestCase ();

  virtual ~PropagationLossCacheTestCase ();

private:

  virtual bool DoRun (void);

};

PropagationLossCacheTestCase::PropagationLossCacheTestCase ()

  : TestCase ("Test PropagationLossCache")

{

}

PropagationLossCacheTestCase::~PropagationLossCacheTestCase ()

{

}

bool

PropagationLossCacheTestCase::DoRun (void)

{

  Ptr<Node> n[3];

  Ptr<MobilityModel> m[3];

  for (int i = 0; i < 3; ++i)

    {

      n[i] = CreateObject<Node> ();

      m[i] = CreateObject<ConstantPositionMobilityModel> ();

      m[i]->SetPosition (Vector (i, i, i));

      n[i]->AggregateObject (m[i]);

    }

  Ptr<LogDistancePropagationLossModel> ref =

    CreateObject<LogDistancePropagationLossModel> ();

  PropagationLossCache cache;

  cache.AddModel (ref);

  NS_TEST_ASSERT_MSG_EQ (cache.CalcRxPower (0, m[0], m[1]), ref->CalcRxPower (0, m[0], m[1]), "cache 0 -> 1 incorrect");

  NS_TEST_ASSERT_MSG_EQ (cache.CalcRxPower (0, m[1], m[0]), ref->CalcRxPower (0, m[1], m[0]), "cache 1 -> 0 incorrect");

  NS_TEST_ASSERT_MSG_EQ (cache.CalcRxPower (0, m[0], m[2]), ref->CalcRxPower (0, m[0], m[2]), "cache 0 -> 2 incorrect");

  NS_TEST_ASSERT_MSG_EQ (cache.CalcRxPower (0, m[2], m[0]), ref->CalcRxPower (0, m[2], m[0]), "cache 2 -> 0 incorrect");

  NS_TEST_ASSERT_MSG_EQ (cache.CalcRxPower (0, m[1], m[2]), ref->CalcRxPower (0, m[1], m[2]), "cache 1 -> 2 incorrect");

  NS_TEST_ASSERT_MSG_EQ (cache.CalcRxPower (0, m[2], m[1]), ref->CalcRxPower (0, m[2], m[1]), "cache 2 -> 1 incorrect");

  NS_TEST_ASSERT_MSG_EQ (cache.CalcRxPower (10, m[2], m[1]), ref->CalcRxPower (10, m[2], m[1]), "attenuation not applied to txPowerDbm");

  m[0]->SetPosition (Vector (10,10,10));

  NS_TEST_EXPECT_MSG_NE (cache.CalcRxPower (0, m[0], m[1]), ref->CalcRxPower (0, m[0], m[1]), "cache not used");

  Simulator::Destroy ();

  return GetErrorStatus ();

}

  AddTestCase (new PropagationLossCacheTestCase);

 *                Quincy Tse <quincy.tse@nicta.com.au> for cached

#include "ns3/pointer.h"

  SetLoss (ma, mb, loss, symmetric);

}

void

MatrixPropagationLossModel::SetLoss (Ptr<MobilityModel> ma, Ptr<MobilityModel> mb, double loss, bool symmetric)

{

  NS_ASSERT (ma != 0 && mb != 0);

bool

MatrixPropagationLossModel::IsLossSet (Ptr<MobilityModel> a,

                                       Ptr<MobilityModel> b) const

{

  std::map<MobilityPair, double>::const_iterator i = m_loss.find (std::make_pair (a, b));

  return (i != m_loss.end ());

}

NS_OBJECT_ENSURE_REGISTERED (PropagationLossCache);

TypeId 

PropagationLossCache::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::PropagationLossCache")

    .SetParent<PropagationLossModel> ()

    .AddConstructor<PropagationLossCache> ()

    .AddAttribute ("Symmetric",

                   "Whether propagation loss is symmetric",

                   BooleanValue (false),

                   MakeBooleanAccessor (&PropagationLossCache::m_symmetric),

                   MakeBooleanChecker ())

    .AddAttribute ("CachedModels",

                   "The list of models to be cached",

                   PointerValue (),

                   MakePointerAccessor (&PropagationLossCache::m_models),

                   MakePointerChecker<PropagationLossModel> ())

    ;

  return tid;

}

PropagationLossCache::PropagationLossCache (void)

  : PropagationLossModel (), m_symmetric (false),

    m_cache (CreateObject<MatrixPropagationLossModel> ())

{}

void

PropagationLossCache::AddModel (Ptr<PropagationLossModel> next)

{

  NS_ASSERT (next != 0x0);

  next->SetNext (m_models);

  m_models = next;

}

void

PropagationLossCache::SetSymmetric (const bool b)

{

  m_symmetric = b;

}

bool

PropagationLossCache::GetSymmetric (void)

{

  return m_symmetric;

}

double 

PropagationLossCache::DoCalcRxPower (double txPowerDbm,

                                           Ptr<MobilityModel> a,

                                           Ptr<MobilityModel> b) const

{

  double rxc = 0.0;

  if (m_cache->IsLossSet (a, b))

    {

      NS_LOG_DEBUG ("cache hit.");

      rxc = m_cache->CalcRxPower (0, a, b);

    }

  else

    {

      NS_LOG_DEBUG ("cache miss.");

      rxc = m_models->CalcRxPower (0, a, b); // assumes models independent of power

      m_cache->SetLoss (a, b, -rxc, m_symmetric);

    }

  NS_LOG_DEBUG ("attenuation coefficent="<<rxc<<"Db");

  return txPowerDbm + rxc;

}

// ------------------------------------------------------------------------- //

 *                Quincy Tse <quincy.tse@nicta.com.au> for buffered

  /**

   * \brief Set loss (in dB, positive) between pair of nodes.

   * 

   * \param a           Source node's MobilityModel

   * \param b           Destination node's MobilityModel

   * \param loss        a -> b path loss, positive in dB

   * \param symmetric   If true (default), both a->b and b->a paths will be affected

   */ 

  void SetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double loss, bool symmetric = true);

  /// Whether matrix contains the node-pair

  bool IsLossSet (Ptr<MobilityModel> a, Ptr<MobilityModel> b) const;

/**

 * \brief A cached evaluator for propagation loss models.

 *

 * This model calculates the reception power only as required and caches

 * the results for later use. It wraps around models whose values do not

 * change throughout the simulation (eg. log-distance pathloss, given

 * nodes are stationary. Results from the wrapped model chain are cached

 * in a MatrixPropagationLossModel. The wrapped models MUST be independent

 * of the input signal strength.

 *

 * Typical use:

 * <code>

 * // ...

 * PropagationLossCacheHelper cacheHelper;

 * cacheHelper.AddPropagationLoss ("ns3::SomeCachableLossModel",

 *        "Attribute", someValue);

 * cacheHelper.AddPropagationLoss ("ns3::AnotherCachableLossModel",

 *        "Attribute", someValue);

 *

 * WifiChannelHelper wifiChannel; // initialised elsewhere

 * wifiChannel.AddPropagationLoss ("ns3::PropagationLossCache",

 *        "CachedModels",

 *        PointerValue (cacheHelper.GetCachedModels ()));

 * wifiChannel.AddPropagationLoss ("ns3::OtherNonCachedLossModel");

 * // ...

 * </code>

 */

class PropagationLossCache : public PropagationLossModel

{

public:

  static TypeId GetTypeId (void);

  PropagationLossCache (void);

  /**

   * \brief Add a model to the wrapped chain.

   *

   * \param next the model to be added.

   */

  void AddModel (Ptr<PropagationLossModel> next);

  void SetSymmetric (const bool sym);

  bool GetSymmetric (void);

private:

  PropagationLossCache (const PropagationLossCache&);

  PropagationLossCache& operator =

    (const PropagationLossCache&);

  virtual double DoCalcRxPower (double txPowerDbm,

                                Ptr<MobilityModel>,

                                Ptr<MobilityModel>) const;

  bool m_symmetric;

  Ptr<PropagationLossModel> m_models;

  Ptr<MatrixPropagationLossModel> m_cache;

};

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 NICTA

 *

 * 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: Quincy Tse <quincy.tse@nicta.com.au>

 */

#include "propagation-loss-cache-helper.h"

#include "ns3/propagation-loss-model.h"

#include "ns3/log.h"

NS_LOG_COMPONENT_DEFINE ("PropagationLossCacheHelper");

namespace ns3 {

PropagationLossCacheHelper::PropagationLossCacheHelper (void)

{}

void

PropagationLossCacheHelper::AddPropagationLoss (std::string type,

            std::string n0, const AttributeValue &v0,

            std::string n1, const AttributeValue &v1,

            std::string n2, const AttributeValue &v2,

            std::string n3, const AttributeValue &v3,

            std::string n4, const AttributeValue &v4,

            std::string n5, const AttributeValue &v5,

            std::string n6, const AttributeValue &v6,

            std::string n7, const AttributeValue &v7)

{

  ObjectFactory factory;

  factory.SetTypeId (type);

  factory.Set (n0, v0);

  factory.Set (n1, v1);

  factory.Set (n2, v2);

  factory.Set (n3, v3);

  factory.Set (n4, v4);

  factory.Set (n5, v5);

  factory.Set (n6, v6);

  factory.Set (n7, v7);

  m_propagationLoss.push_back (factory);

}

inline void

PropagationLossCacheHelper::SetSymmetric (bool symmetric)

{

  m_symmetric = symmetric;

}

Ptr<PropagationLossCache>

PropagationLossCacheHelper::Create (void) const

{

  Ptr<PropagationLossCache> cache = CreateObject<PropagationLossCache> ();

  cache->SetSymmetric (m_symmetric);

  for (std::vector<ObjectFactory>::const_iterator it = m_propagationLoss.begin ();

       it != m_propagationLoss.end (); ++it)

    {

      Ptr<PropagationLossModel> cur = (*it).Create<PropagationLossModel> ();

      cache->AddModel (cur);

    }

  return cache;

}

Ptr<PropagationLossModel>

PropagationLossCacheHelper::GetCachedModels (void) const

{

  Ptr<PropagationLossModel> prev = 0;

  for (std::vector<ObjectFactory>::const_iterator it = m_propagationLoss.begin ();

       it != m_propagationLoss.end (); ++it)

    {

      Ptr<PropagationLossModel> curr = (*it).Create<PropagationLossModel> ();

      curr->SetNext (prev);

      prev = curr;

    }

  return prev;

}

}

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2010 NICTA

 *

 * 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: Quincy Tse <quincy.tse@nicta.com.au>

 */

#ifndef PROPAGATION_LOSS_CACHE_HELPER_H

#define PROPAGATION_LOSS_CACHE_HELPER_H

#include "ns3/propagation-loss-model.h"

#include "ns3/object-factory.h"

namespace ns3 {

/**

 * \brief Manage and create propagation loss cache objects.

 *

 * The intent of this class is to make it easy to create and confiruge a

 * PropagationLossCache object .

 */

class PropagationLossCacheHelper

{

public:

  /**

   * Create a cache helper without any parameter set.

   */

  PropagationLossCacheHelper (void);

  /**

   * \param name the name of the model to add

   * \param n0 the name of the attribute to set

   * \param v0 the value of the attribute to set

   * \param n1 the name of the attribute to set

   * \param v1 the value of the attribute to set

   * \param n2 the name of the attribute to set

   * \param v2 the value of the attribute to set

   * \param n3 the name of the attribute to set

   * \param v3 the value of the attribute to set

   * \param n4 the name of the attribute to set

   * \param v4 the value of the attribute to set

   * \param n5 the name of the attribute to set

   * \param v5 the value of the attribute to set

   * \param n6 the name of the attribute to set

   * \param v6 the value of the attribute to set

   * \param n7 the name of the attribute to set

   * \param v7 the value of the attribute to set

   *

   * Add a propagation loss model to the set of currently-configured loss models.

   * This method is additive to allow you to cache multiple propagation loss

   * models.

   */

  void AddPropagationLoss (std::string name,

			   std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),

			   std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),

			   std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),

			   std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),

			   std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),

			   std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),

			   std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),

			   std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue ());

  /**

   * Sets whether the cache is symmetrical.

   */

  void SetSymmetric (bool symmetric);

  /**

   * \returns a new cache

   *

   * Create a cache based on the configuration parameters set previously.

   */

  Ptr<PropagationLossCache> Create (void) const;

  /**

   * \returns a Ptr to the head of a PropagationLossModel list

   *

   * Create the propagation loss models and line them in a chain.

   */

  Ptr<PropagationLossModel> GetCachedModels (void) const;

private:

  std::vector<ObjectFactory> m_propagationLoss;

  bool m_symmetric;

};

}

#endif

        'propagation-loss-cache-helper.cc',

        'propagation-loss-cache-helper.h',