*         Michele Polese <michele.polese@gmail.com> for the OutdoorPositionAllocator class

NS_OBJECT_ENSURE_REGISTERED (OutdoorPositionAllocator);

OutdoorPositionAllocator::OutdoorPositionAllocator ()

{

  m_maxAttempts = 1000;

}

TypeId

OutdoorPositionAllocator::GetTypeId (void)

{

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

    .SetParent<PositionAllocator> ()

    .SetGroupName ("Buildings")

    .AddConstructor<OutdoorPositionAllocator> ()

    .AddAttribute ("X",

                   "A random variable which represents the x coordinate of a position in a random box.",

                   StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=1.0]"),

                   MakePointerAccessor (&OutdoorPositionAllocator::m_x),

                   MakePointerChecker<RandomVariableStream> ())

    .AddAttribute ("Y",

                   "A random variable which represents the y coordinate of a position in a random box.",

                   StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=1.0]"),

                   MakePointerAccessor (&OutdoorPositionAllocator::m_y),

                   MakePointerChecker<RandomVariableStream> ())

    .AddAttribute ("Z",

                   "A random variable which represents the z coordinate of a position in a random box.",

                   StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=1.0]"),

                   MakePointerAccessor (&OutdoorPositionAllocator::m_z),

                   MakePointerChecker<RandomVariableStream> ())

    .AddAttribute ("MaxAttempts",

                   "Maximum number of attempts for the rejection sampling before giving up.",

                   UintegerValue (1000),

                   MakeUintegerAccessor (&OutdoorPositionAllocator::m_maxAttempts),

                   MakeUintegerChecker<uint32_t> ())

  ;

  return tid;

}

void

OutdoorPositionAllocator::SetX (Ptr<RandomVariableStream> x)

{

  m_x = x;

}

void

OutdoorPositionAllocator::SetY (Ptr<RandomVariableStream> y)

{

  m_y = y;

}

void

OutdoorPositionAllocator::SetZ (Ptr<RandomVariableStream> z)

{

  m_z = z;

}

Vector

OutdoorPositionAllocator::GetNext () const

{

  NS_ABORT_MSG_IF (BuildingList::GetNBuildings () == 0, "no building found");

  bool outdoor = false;

  uint32_t attempts = 0;

  Vector position = Vector (0,0,0);

  while (!outdoor && attempts < m_maxAttempts)

    {

      // get a random position

      double x = m_x->GetValue ();

      double y = m_y->GetValue ();

      double z = m_z->GetValue ();

      position = Vector (x, y, z);

      NS_LOG_INFO ("Position " << position);

      bool inside = false;

      for (BuildingList::Iterator bit = BuildingList::Begin (); bit != BuildingList::End (); ++bit)

        {

          if ((*bit)->IsInside (position))

            {

              NS_LOG_INFO ("Position " << position << " is inside the building with boundaries "

                                       << (*bit)->GetBoundaries ().xMin << " " << (*bit)->GetBoundaries ().xMax << " "

                                       << (*bit)->GetBoundaries ().yMin << " " << (*bit)->GetBoundaries ().yMax << " "

                                       << (*bit)->GetBoundaries ().zMin << " " << (*bit)->GetBoundaries ().zMax);

              inside = true;

              break;

            }

        }

      if (inside)

        {

          NS_LOG_INFO ("Inside a building, attemp " << attempts << " out of " << m_maxAttempts);

          attempts++;

        }

      else

        {

          NS_LOG_INFO ("Outdoor position found " << position);

          outdoor = true;

        }

    }

  NS_ABORT_MSG_IF (attempts >= m_maxAttempts, "Too many attempts, give up");

  NS_ABORT_MSG_IF (!outdoor, "Still indoor, give up");

  return position;

}

int64_t

OutdoorPositionAllocator::AssignStreams (int64_t stream)

{

  m_x->SetStream (stream);

  m_y->SetStream (stream + 1);

  m_z->SetStream (stream + 2);

  return 3;

}

 *         Michele Polese <michele.polese@gmail.com> for the OutdoorPositionAllocator class

/**

 * \ingroup buildings

 * \brief allocate outdoor positions

 *

 * Allocate positions outside of existing buildings using rejection sampling.

 * This class extracts a random position in a box defined by the three RandomVariableStreams

 * for the X, Y and Z dimensions (similarly to RandomBoxPositionAllocator), until

 * a position which is outdoor with respect to all the buildings in the scenario is found,

 * or a maximum number of attempts is reached.

 * The RandomVariableStream and the maximum number of attempts can be set using attributes.

 * If the maximum number of attempts is reached, then the simulation aborts.

 */

class OutdoorPositionAllocator : public PositionAllocator

{

public:

  OutdoorPositionAllocator ();

  // inherited from Object

  static TypeId GetTypeId (void);

  // inherited from PositionAllocator

  virtual Vector GetNext (void) const;

  /**

   * \brief Set the random variable stream object that generates x-positions

   * \param x pointer to a RandomVariableStream object

   */

  void SetX (Ptr<RandomVariableStream> x);

  /**

   * \brief Set the random variable stream object that generates y-positions

   * \param y pointer to a RandomVariableStream object

   */

  void SetY (Ptr<RandomVariableStream> y);

  /**

   * \brief Set the random variable stream object that generates z-positions

   * \param z pointer to a RandomVariableStream object

   */

  void SetZ (Ptr<RandomVariableStream> z);

  /**

   * Assign a fixed random variable stream number to the random variables

   * used by this model.  Return the number of streams (possibly zero) that

   * have been assigned.

   *

   * \param stream first stream index to use

   * \return the number of stream indices assigned by this model

   */

  int64_t AssignStreams (int64_t stream);

private:

  Ptr<RandomVariableStream> m_x; //!< pointer to x's random variable stream

  Ptr<RandomVariableStream> m_y; //!< pointer to y's random variable stream

  Ptr<RandomVariableStream> m_z; //!< pointer to z's random variable stream

  uint32_t m_maxAttempts; //!< maximum number of attempts before giving up

};