/**

 * \ingroup mobility

 * \brief Allocate positions on a rectangular 2d grid.

 */

class DiskGridPositionAllocator : public PositionAllocator

{

public:

  /**

   * Register this type with the TypeId system.

   * \return the object TypeId

   */

  static TypeId GetTypeId (void);

  DiskGridPositionAllocator ();

  virtual ~DiskGridPositionAllocator ();

  /** 

   * \param rho the radius of the disc

   */

  void SetRho (double rho);

  /** 

   * \param x the X coordinate of the center of the disc

   */

  void SetX (double x);

  /** 

   * \param y the Y coordinate of the center of the disc

   */

  void SetY (double y);

  /** 

   * \param intervals the number of subintervals into which the horizontal

   * radius should be divided

   */

  void SetIntervals (uint32_t intervals);

  /** 

   * \return the radius of the disc

   */

  double GetRho () const;

  /** 

   * \return the X coordinate of the center of the disc

   */

  double GetX () const;

  /** 

   * \return the Y coordinate of the center of the disc

   */

  double GetY () const;

  /** 

   * \return the number of subintervals into which the horizontal

   * radius should be divided

   */

  uint32_t GetIntervals () const;

  /** 

   * \return the number of points in the grid

   */

  uint32_t GetN () const;

  virtual Vector GetNext (void) const;

  virtual int64_t AssignStreams (int64_t stream);

private:

  /**

   * \brief calculates the positions

   */

  void CalculatePositions ();

private:

  std::vector<Vector> m_positions;  //!< vector of positions

  mutable std::vector<Vector>::const_iterator m_current; //!< vector iterator

  double m_x; //!< x coordinate of center of disc

  double m_y; //!< y coordinate of center of disc

  double m_rho; //!< value of the radius of the disc

  uint32_t m_intervals; //!< number of subintervals

  uint32_t m_count; //!< number of points

};

NS_OBJECT_ENSURE_REGISTERED (DiskGridPositionAllocator);

TypeId

DiskGridPositionAllocator::GetTypeId (void)

{

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

    .SetParent<PositionAllocator> ()

    .SetGroupName ("Mobility")

    .AddConstructor<DiskGridPositionAllocator> ()

  ;

  return tid;

}

DiskGridPositionAllocator::DiskGridPositionAllocator ()

  : m_x (0),

    m_y (0),

    m_rho (0),

    m_intervals (0),

    m_count (0)

{

}

DiskGridPositionAllocator::~DiskGridPositionAllocator ()

{

}

void

DiskGridPositionAllocator::SetRho (double rho)

{

  m_rho = rho;

  CalculatePositions ();

}

void

DiskGridPositionAllocator::SetX (double x)

{

  m_x = x;

  CalculatePositions ();

}

void

DiskGridPositionAllocator::SetY (double y)

{

  m_y = y;

  CalculatePositions ();

}

void

DiskGridPositionAllocator::SetIntervals (uint32_t intervals)

{

  m_intervals = intervals;

  CalculatePositions ();

}

double

DiskGridPositionAllocator::GetRho () const

{

  return m_rho;

}

double

DiskGridPositionAllocator::GetX () const

{

  return m_x;

}

double

DiskGridPositionAllocator::GetY () const

{

  return m_y;

}

uint32_t

DiskGridPositionAllocator::GetIntervals () const

{

  return m_intervals;

}

int64_t

DiskGridPositionAllocator::AssignStreams (int64_t stream)

{

  return 0;

}

Vector

DiskGridPositionAllocator::GetNext (void) const

{

  static uint32_t count = m_count;

  NS_ASSERT (count > 0);

  Vector v = *m_current;

  m_current++;

  count--;

  return v;

}

uint32_t

DiskGridPositionAllocator::GetN () const

{

  return m_count;

}

void

DiskGridPositionAllocator::CalculatePositions ()

{

  uint32_t i;

  double x;

  double y;

  if(m_intervals == 0 || m_rho == 0)

    return;

  m_positions.clear ();

  m_count = 0;

  for ( uint32_t j = 0; j <= m_intervals; j++ )

  {

    i = 0;

    x = m_x;

    y = m_y + m_rho * ( double ) ( 2 * j ) / ( double ) ( 2 * m_intervals + 1 );

    m_positions.push_back (Vector (x, y, 0));

    m_count++;

    if ( 0 < j )

    {

      m_positions.push_back (Vector (x, (2.0 * m_y - y), 0));

      m_count++;

    }

    while (true)

    {

      i = i + 1;

      x = m_x + m_rho * ( double ) ( 2 * i ) / ( double ) ( 2 * m_intervals + 1 );

      if ( m_rho * m_rho < pow ( x - m_x, 2 ) + pow ( y - m_y, 2 ) )

      {

        break;

      }

      m_positions.push_back (Vector (x, y, 0));

      m_positions.push_back (Vector ((2.0 * m_x - x), y, 0));

      m_count += 2;

      if ( 0 < j )

      {

        m_positions.push_back (Vector (x, (2.0 * m_y - y), 0));

        m_positions.push_back (Vector ((2.0 * m_x - x), (2.0 * m_y - y), 0));

        m_count += 2;

      }

    }

  }

  m_current = m_positions.begin ();

}