class PropagationLossCachedEvaluatorTestCase : public TestCase

{

public:

  PropagationLossCachedEvaluatorTestCase ();

  virtual ~PropagationLossCachedEvaluatorTestCase ();

private:

  virtual bool DoRun (void);

};

PropagationLossCachedEvaluatorTestCase::PropagationLossCachedEvaluatorTestCase ()

  : TestCase ("Test PropagationLossCachedEvaluator")

{

}

PropagationLossCachedEvaluatorTestCase::~PropagationLossCachedEvaluatorTestCase ()

{

}

bool

PropagationLossCachedEvaluatorTestCase::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> ();

  PropagationLossCachedEvaluator 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 PropagationLossCachedEvaluatorTestCase);

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

void

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

{

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

  MobilityPair p = std::make_pair(ma, mb);

  std::map<MobilityPair, double>::iterator i = m_loss.find (p);

  if (i == m_loss.end ())

    {

      m_loss.insert (std::make_pair (p, loss));

    }

  else

    {

      i->second = loss;

    }

  if (symmetric)

    {

      SetLoss (mb, ma, loss, false);

    }

}

bool

MatrixPropagationLossModel::ContainsPair (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 (PropagationLossCachedEvaluator);

TypeId 

PropagationLossCachedEvaluator::GetTypeId (void)

{

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

    .SetParent<PropagationLossModel> ()

    .AddConstructor<PropagationLossCachedEvaluator> ()

    .AddAttribute ("Symmetric",

                   "Whether propagation loss is symmetric",

                   BooleanValue (false),

                   MakeBooleanAccessor (&PropagationLossCachedEvaluator::m_symmetric),

                   MakeBooleanChecker ())

    ;

  return tid;

}

PropagationLossCachedEvaluator::PropagationLossCachedEvaluator (void)

  : PropagationLossModel (), m_symmetric (false),

    m_cache (CreateObject<MatrixPropagationLossModel> ())

{}

void

PropagationLossCachedEvaluator::AddModel (Ptr<PropagationLossModel> next)

{

  NS_ASSERT (next != 0x0);

  next->SetNext (m_models);

  m_models = next;

}

void

PropagationLossCachedEvaluator::SetSymmetric (const bool b)

{

  m_symmetric = b;

}

bool

PropagationLossCachedEvaluator::GetSymmetric (void)

{

  return m_symmetric;

}

double 

PropagationLossCachedEvaluator::DoCalcRxPower (double txPowerDbm,

                                           Ptr<MobilityModel> a,

                                           Ptr<MobilityModel> b) const

{

  double rxc = 0.0;

  if (m_cache->ContainsPair (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 ContainsPair (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.

 */

class PropagationLossCachedEvaluator : public PropagationLossModel

{

public:

  static TypeId GetTypeId (void);

  PropagationLossCachedEvaluator (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:

  PropagationLossCachedEvaluator (const PropagationLossCachedEvaluator&);

  PropagationLossCachedEvaluator& operator =

    (const PropagationLossCachedEvaluator&);

  virtual double DoCalcRxPower (double txPowerDbm,

                                Ptr<MobilityModel>,

                                Ptr<MobilityModel>) const;

  bool m_symmetric;

  Ptr<PropagationLossModel> m_models;

  Ptr<MatrixPropagationLossModel> m_cache;

};