NS_OBJECT_ENSURE_REGISTERED (UniformDiscPositionAllocator);

TypeId

UniformDiscPositionAllocator::GetTypeId (void)

{

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

    .SetParent<PositionAllocator> ()

    .SetGroupName ("Mobility")

    .AddConstructor<UniformDiscPositionAllocator> ()

    .AddAttribute ("rho",

                   "The radius of the disc",

                   DoubleValue (0.0),

                   MakeDoubleAccessor (&UniformDiscPositionAllocator::m_rho),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("X",

                   "The x coordinate of the center of the  disc.",

                   DoubleValue (0.0),

                   MakeDoubleAccessor (&UniformDiscPositionAllocator::m_x),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("Y",

                   "The y coordinate of the center of the  disc.",

                   DoubleValue (0.0),

                   MakeDoubleAccessor (&UniformDiscPositionAllocator::m_y),

                   MakeDoubleChecker<double> ())

    ;

  return tid;

}   

UniformDiscPositionAllocator::UniformDiscPositionAllocator ()

{}

UniformDiscPositionAllocator::~UniformDiscPositionAllocator ()

{}

void 

UniformDiscPositionAllocator::SetRho (double rho)

{

  m_rho = rho;

}

void 

UniformDiscPositionAllocator::SetX (double x)

{

  m_x = x;

}

void 

UniformDiscPositionAllocator::SetY (double y)

{

  m_y = y;

}

Vector

UniformDiscPositionAllocator::GetNext (void) const

{

  UniformVariable r (-m_rho, m_rho);

  double x,y;

  do

    {

      x = r.GetValue ();

      y = r.GetValue ();

    }

  while (sqrt(x*x + y*y) > m_rho);

  x += m_x;

  y += m_y;

  NS_LOG_DEBUG ("Disc position x=" << x << ", y=" << y);

  return Vector (x, y, 0.0);

}

/**

 * \brief allocate positions which are uniformly distributed within a

 * disc of a given radius.  Note that this is NOT equivalent to using

 * a RandomDiscPositionAllocator with a uniformly-distributed rho.

 */

class UniformDiscPositionAllocator : public PositionAllocator

{

public:

  static TypeId GetTypeId (void);

  UniformDiscPositionAllocator ();

  virtual ~UniformDiscPositionAllocator ();

  void SetRho (double rho);

  void SetX (double x);

  void SetY (double y);

  virtual Vector GetNext (void) const;

private:

  double m_rho;

  double m_x;

  double m_y;

};