Example #1
0
    def __init__(self, area, time, initial_coordinates, pause_time=0.0):
        """
        *Parameters*:
            - **area**: an object representing the simulation area;
            - **time**: a simulation time object of the
              :class:`sim2net._time.Time` class;
            - **initial_coordinates** (`list`): initial coordinates of all
              nodes; each element of this parameter should be a tuple of two
              coordinates: horizontal and vertical (respectively) of type
              `float`;
            - **pause_time** (`float`): a maximum value of the pause time in
              the *simulation time* units (default: `0.0`, see also:
              :mod:`sim2net._time`).

        *Raises*:
            - **ValueError**: raised when the given value of the *area*, *time*
              or *initial_coordinates* parameter is `None` or when the given
              value of the *pause_time* parameter is less that zero.

        (At the beginning, nodes' destination points are set to be equal to its
        initial coordinates passed by the *initial_coordinates* parameter.)
        """
        if area is None:
            raise ValueError('Parameter "area": a simulation area object' \
                             ' expected but "None" value given!')
        if time is None:
            raise ValueError('Parameter "time": a time abstraction object' \
                             ' expected but "None" value given!')
        if initial_coordinates is None:
            raise ValueError('Parameter "initial_coordinates": identifiers' \
                             ' of nodes expected but "None" value given!')
        Mobility.__init__(self, RandomDirection.__name__)
        self._area = area
        self._time = time
        self._destinations = dict()
        check_argument_type(RandomDirection.__name__, 'initial_coordinates',
                            list, initial_coordinates, self.logger)
        check_argument_type(RandomDirection.__name__, 'pause_time', float,
                            pause_time, self.logger)
        if pause_time < 0.0:
            raise ValueError('Parameter "pause_time": a value of the pause' \
                             ' time cannot be less that zero but %f given!' \
                             % float(pause_time))
        self._pause_time = float(pause_time)
        # { node id:
        #     { 'destination':  (horizontal coordinate, vertical coordinate),
        #       'pause time' :  time } }
        for node_id in range(0, len(initial_coordinates)):
            self._destinations[node_id] = dict()
            self._destinations[node_id]['destination'] = \
                initial_coordinates[node_id]
            self._destinations[node_id]['pause time'] = None
        self.logger.debug('Destination points has been initialized for %d' \
                          ' nodes' % len(self._destinations))
    def __init__(self, area, time, initial_coordinates, pause_time=0.0):
        """
        *Parameters*:
            - **area**: an object representing the simulation area;
            - **time**: a simulation time object of the
              :class:`sim2net._time.Time` class;
            - **initial_coordinates** (`list`): initial coordinates of all
              nodes; each element of this parameter should be a tuple of two
              coordinates: horizontal and vertical (respectively) of type
              `float`;
            - **pause_time** (`float`): a maximum value of the pause time in
              the *simulation time* units (default: `0.0`, see also:
              :mod:`sim2net._time`).

        *Raises*:
            - **ValueError**: raised when the given value of the *area*, *time*
              or *initial_coordinates* parameter is `None` or when the given
              value of the *pause_time* parameter is less that zero.

        (At the beginning, nodes' destination points are set to be equal to its
        initial coordinates passed by the *initial_coordinates* parameter.)
        """
        if area is None:
            raise ValueError('Parameter "area": a simulation area object' \
                             ' expected but "None" value given!')
        if time is None:
            raise ValueError('Parameter "time": a time abstraction object' \
                             ' expected but "None" value given!')
        if initial_coordinates is None:
            raise ValueError('Parameter "initial_coordinates": identifiers' \
                             ' of nodes expected but "None" value given!')
        Mobility.__init__(self, RandomDirection.__name__)
        self._area = area
        self._time = time
        self._destinations = dict()
        check_argument_type(RandomDirection.__name__, 'initial_coordinates',
                            list, initial_coordinates, self.logger)
        check_argument_type(RandomDirection.__name__, 'pause_time', float,
                            pause_time, self.logger)
        if pause_time < 0.0:
            raise ValueError('Parameter "pause_time": a value of the pause' \
                             ' time cannot be less that zero but %f given!' \
                             % float(pause_time))
        self._pause_time = float(pause_time)
        # { node id:
        #     { 'destination':  (horizontal coordinate, vertical coordinate),
        #       'pause time' :  time } }
        for node_id in range(0, len(initial_coordinates)):
            self._destinations[node_id] = dict()
            self._destinations[node_id]['destination'] = \
                initial_coordinates[node_id]
            self._destinations[node_id]['pause time'] = None
        self.logger.debug('Destination points has been initialized for %d' \
                          ' nodes' % len(self._destinations))
Example #3
0
    def __init__(self, area, time, initial_coordinates, initial_speed, **kwargs):
        """
        *Parameters*:
            - **area**: an object representing the simulation area;
            - **time**: a simulation time object of the
              :class:`sim2net._time.Time` class;
            - **initial_coordinates** (`list`): initial coordinates of all
              nodes; each element of this parameter should be a tuple of two
              coordinates: horizontal and vertical (respectively) of type
              `float`;
            - **initial_speed** (`float`): a value of the initial speed that is
              assigned to each node at the beginning of the simulation;
            - **kwargs** (`dict`): a dictionary of (optional) keyword
              parameters related to the Gauss-Markov mobility model; the
              following parameters are accepted:

              **alpha** (`float`)
                  The tuning parameter :math:`0\\leqslant\\alpha\\leqslant 1`
                  used to vary the randomness of movements (default: `0.75`).

              **direction_deviation** (`float`)
                  Constant representing the standard deviation of direction
                  random variable :math:`d_x` (it defaults to
                  :math:`\\frac{\\pi}{2}`).

              **direction_margin** (`float`)
                  Constant used to change direction mean :math:`\\overline{d}`
                  to ensure that nodes do not remain near a border of the
                  simulation area for a long period of time (it defaults to
                  `0.15`, or `15%` of the simulation area width/height, and
                  cannot be less than zero and greater than one; see:
                  :meth:`_GaussMarkov__velocity_recalculation`).

              **direction_mean** (`float`)
                  Constant representing mean value :math:`\\overline{d}` of
                  direction (it defaults to :math:`\\frac{\\pi}{6}`).  The same
                  value is used as mean of direction random variable
                  :math:`d_x`.

              **recalculation_interval** (`int`)
                  Velocity (i.e. speed and direction) recalculation time
                  interval (it defaults to the *simulation frequency*; see:
                  :mod:`sim2net._time`).  It determines how often, counting in
                  simulation steps, new values of velocity are recalculated.

        *Raises*:
            - **ValueError**: raised when the given value of the *area*,
              *time*, *initial_coordinates* or *initial_speed* parameter is
              `None`; or when the given value of the keyword parameter *alpha*
              is less than zero or greater that one; or when the given value of
              the (optional) keyword parameter *direction_margin* is less than
              zero or greater than one.

        *Example*:

        .. doctest::
            :options: +SKIP

            >>> gm = GaussMarkov(area, time, coordinates, 10.0, alpha=0.35)

        """
        if area is None:
            raise ValueError('Parameter "area": a simulation area object' ' expected but "None" value given!')
        if time is None:
            raise ValueError('Parameter "time": a time abstraction object' ' expected but "None" value given!')
        if initial_coordinates is None:
            raise ValueError(
                'Parameter "initial_coordinates": identifiers' ' of nodes expected but "None" value given!'
            )
        if initial_speed is None:
            raise ValueError(
                'Parameter "initial_speed": a value of the'
                ' initial speed of nodes expected but "None"'
                " value given!"
            )
        Mobility.__init__(self, GaussMarkov.__name__)
        self.__area = area
        self.__time = time
        check_argument_type(GaussMarkov.__name__, "initial_coordinates", list, initial_coordinates, self.logger)
        check_argument_type(GaussMarkov.__name__, "initial_speed", float, initial_speed, self.logger)
        if "alpha" in kwargs:
            check_argument_type(GaussMarkov.__name__, "alpha", float, kwargs["alpha"], self.logger)
            if kwargs["alpha"] < 0.0 or kwargs["alpha"] > 1.0:
                raise ValueError(
                    'Keyword parameter "alpha": a value of the'
                    ' "alpha" parameter cannot be less than'
                    " zero and greater than one but %f given!" % float(kwargs["alpha"])
                )
        if "direction_deviation" in kwargs:
            check_argument_type(
                GaussMarkov.__name__, "direction_deviation", float, kwargs["direction_deviation"], self.logger
            )
        if "direction_margin" in kwargs:
            check_argument_type(
                GaussMarkov.__name__, "direction_margin", float, kwargs["direction_margin"], self.logger
            )
            if kwargs["direction_margin"] < 0.0 or kwargs["direction_margin"] > 1.0:
                raise ValueError(
                    'Keyword parameter "direction_margin": a'
                    " value of the direction margin cannot be"
                    " less than zero and greater than one but"
                    " %f given!" % float(kwargs["direction_margin"])
                )
        if "direction_mean" in kwargs:
            check_argument_type(GaussMarkov.__name__, "direction_mean", float, kwargs["direction_mean"], self.logger)
        if "recalculation_interval" in kwargs:
            check_argument_type(
                GaussMarkov.__name__, "recalculation_interval", int, kwargs["recalculation_interval"], self.logger
            )
        self.__alpha = float(kwargs.get("alpha", GaussMarkov.__DEFAULT_ALPHA))
        self.__direction_deviation = float(kwargs.get("direction_deviation", GaussMarkov.__DEFAULT_DIRECTION_DEVIATION))
        self.__direction_margin = float(kwargs.get("direction_margin", GaussMarkov.__DEFAULT_DIRECTION_MARGIN))
        self.__direction_mean = float(kwargs.get("direction_mean", GaussMarkov.__DEFAULT_DIRECTION_MEAN))
        self.__recalculation_interval = int(kwargs.get("recalculation_interval", self.__time.simulation_frequency))
        # 1.0 - alpha:
        self.__gauss_markov_factor_one = 1.0 - self.__alpha
        # sqrt((1.0 - alpha^2)):
        self.__gauss_markov_factor_two = sqrt(1.0 - (pow(self.__alpha, 2.0)))
        # area width * direction margin:
        self.__width_left = self.__area.width * self.__direction_margin
        # area width - (area width * direction margin):
        self.__width_right = self.__area.width - self.__width_left
        # area height * direction margin:
        self.__height_bottom = self.__area.height * self.__direction_margin
        # area height - (area height * direction margin):
        self.__height_top = self.__area.height - self.__height_bottom
        # { node id:
        #     { 'speed':      current speed),
        #       'direction':  current direction } }
        self.__velocities = dict()
        for node_id in range(0, len(initial_coordinates)):
            self.__velocities[node_id] = dict()
            self.__velocities[node_id]["speed"] = float(initial_speed)
            self.__velocities[node_id]["direction"] = self.__get_new_direction()
        self.logger.debug("Speed and direction values has been initialized" " for %d nodes" % len(self.__velocities))
Example #4
0
    def __init__(self,
                 area,
                 time,
                 initial_coordinates,
                 pause_time=0.0,
                 area_factor=0.25):
        """
        *Parameters*:
            - **area**: an object representing the simulation area;
            - **time**: a simulation time object of the
              :class:`sim2net._time.Time` class;
            - **initial_coordinates** (`list`): initial coordinates of all
              nodes; each element of this parameter should be a tuple of two
              coordinates: horizontal and vertical (respectively) of type
              `float`;
            - **pause_time** (`float`): a maximum value of the pause time in
              the *simulation time* units (default: `0.0`, see also:
              :mod:`sim2net._time`);
            - **area_factor** (`float`): a factor used to determine the width
              and height of the free roam area around the reference point
              (default: `0.25`).

        *Raises*:
            - **ValueError**: raised when the given value of the *area*, *time*
              or *initial_coordinates* parameter is `None`; or when the given
              value of the *pause_time* parameter is less that zero; or when
              the given value of the *area_factor* parameter is less than zero
              or greater than one.

        (At the beginning, nodes' destination points are set to be equal to its
        initial coordinates passed by the *initial_coordinates* parameter.)
        """
        if area is None:
            raise ValueError('Parameter "area": a simulation area object' \
                             ' expected but "None" value given!')
        if time is None:
            raise ValueError('Parameter "time": a time abstraction object' \
                             ' expected but "None" value given!')
        if initial_coordinates is None:
            raise ValueError('Parameter "initial_coordinates": identifiers' \
                             ' of nodes expected but "None" value given!')
        Mobility.__init__(self, NomadicCommunity.__name__)
        check_argument_type(RandomWaypoint.__name__, 'initial_coordinates',
                            list, initial_coordinates, self.logger)
        check_argument_type(RandomWaypoint.__name__, 'pause_time', float,
                            pause_time, self.logger)
        if pause_time < 0.0:
            raise ValueError('Parameter "pause_time": a value of the pause' \
                             ' time cannot be less that zero but %f given!' \
                             % float(pause_time))
        self._pause_time = float(pause_time)
        check_argument_type(RandomWaypoint.__name__, 'area_factor', float,
                            area_factor, self.logger)
        if area_factor < 0.0 or area_factor > 1.0:
            raise ValueError('Parameter "area_factor": a value of the factor' \
                             ' used to compute the free roam area of nodes' \
                             ' cannot be less than zero or greater than one' \
                             ' but %f given!' % float(area_factor))
        self.__area_factor = float(area_factor)
        self._area = area
        self._time = time
        self.__reference_point = \
            (self.random_generator.uniform(self._area.ORIGIN[0],
                                           self._area.width),
             self.random_generator.uniform(self._area.ORIGIN[1],
                                           self._area.height))
        self.__relocation_time = None
        # { node id:
        #     { 'destination':  (horizontal coordinate, vertical coordinate),
        #       'pause time' :  time } }
        #       'on site'    :  True/False } }
        self._destinations = dict()
        for node_id in range(0, len(initial_coordinates)):
            self._destinations[node_id] = dict()
            self._destinations[node_id]['destination'] = \
                initial_coordinates[node_id]
            self._destinations[node_id]['pause time'] = None
            self._destinations[node_id]['on site'] = False
        self.logger.debug('Destination points has been initialized for %d' \
                          ' nodes with the initial reference point at (%f,' \
                          ' %f)' % (len(self._destinations),
                                    self.__reference_point[0],
                                    self.__reference_point[1]))
Example #5
0
    def __init__(self, area, time, initial_coordinates, initial_speed,
                 **kwargs):
        """
        *Parameters*:
            - **area**: an object representing the simulation area;
            - **time**: a simulation time object of the
              :class:`sim2net._time.Time` class;
            - **initial_coordinates** (`list`): initial coordinates of all
              nodes; each element of this parameter should be a tuple of two
              coordinates: horizontal and vertical (respectively) of type
              `float`;
            - **initial_speed** (`float`): a value of the initial speed that is
              assigned to each node at the beginning of the simulation;
            - **kwargs** (`dict`): a dictionary of (optional) keyword
              parameters related to the Gauss-Markov mobility model; the
              following parameters are accepted:

              **alpha** (`float`)
                  The tuning parameter :math:`0\\leqslant\\alpha\\leqslant 1`
                  used to vary the randomness of movements (default: `0.75`).

              **direction_deviation** (`float`)
                  Constant representing the standard deviation of direction
                  random variable :math:`d_x` (it defaults to
                  :math:`\\frac{\\pi}{2}`).

              **direction_margin** (`float`)
                  Constant used to change direction mean :math:`\\overline{d}`
                  to ensure that nodes do not remain near a border of the
                  simulation area for a long period of time (it defaults to
                  `0.15`, or `15%` of the simulation area width/height, and
                  cannot be less than zero and greater than one; see:
                  :meth:`_GaussMarkov__velocity_recalculation`).

              **direction_mean** (`float`)
                  Constant representing mean value :math:`\\overline{d}` of
                  direction (it defaults to :math:`\\frac{\\pi}{6}`).  The same
                  value is used as mean of direction random variable
                  :math:`d_x`.

              **recalculation_interval** (`int`)
                  Velocity (i.e. speed and direction) recalculation time
                  interval (it defaults to the *simulation frequency*; see:
                  :mod:`sim2net._time`).  It determines how often, counting in
                  simulation steps, new values of velocity are recalculated.

        *Raises*:
            - **ValueError**: raised when the given value of the *area*,
              *time*, *initial_coordinates* or *initial_speed* parameter is
              `None`; or when the given value of the keyword parameter *alpha*
              is less than zero or greater that one; or when the given value of
              the (optional) keyword parameter *direction_margin* is less than
              zero or greater than one.

        *Example*:

        .. doctest::
            :options: +SKIP

            >>> gm = GaussMarkov(area, time, coordinates, 10.0, alpha=0.35)

        """
        if area is None:
            raise ValueError('Parameter "area": a simulation area object' \
                             ' expected but "None" value given!')
        if time is None:
            raise ValueError('Parameter "time": a time abstraction object' \
                             ' expected but "None" value given!')
        if initial_coordinates is None:
            raise ValueError('Parameter "initial_coordinates": identifiers' \
                             ' of nodes expected but "None" value given!')
        if initial_speed is None:
            raise ValueError('Parameter "initial_speed": a value of the' \
                             ' initial speed of nodes expected but "None"' \
                             ' value given!')
        Mobility.__init__(self, GaussMarkov.__name__)
        self.__area = area
        self.__time = time
        check_argument_type(GaussMarkov.__name__, 'initial_coordinates', list,
                            initial_coordinates, self.logger)
        check_argument_type(GaussMarkov.__name__, 'initial_speed', float,
                            initial_speed, self.logger)
        if 'alpha' in kwargs:
            check_argument_type(GaussMarkov.__name__, 'alpha', float,
                                kwargs['alpha'], self.logger)
            if kwargs['alpha'] < 0.0 or kwargs['alpha'] > 1.0:
                raise ValueError('Keyword parameter "alpha": a value of the' \
                                 ' "alpha" parameter cannot be less than' \
                                 ' zero and greater than one but %f given!' \
                                 % float(kwargs['alpha']))
        if 'direction_deviation' in kwargs:
            check_argument_type(GaussMarkov.__name__, 'direction_deviation',
                                float, kwargs['direction_deviation'],
                                self.logger)
        if 'direction_margin' in kwargs:
            check_argument_type(GaussMarkov.__name__, 'direction_margin',
                                float, kwargs['direction_margin'], self.logger)
            if kwargs['direction_margin'] < 0.0 \
               or kwargs['direction_margin'] > 1.0:
                raise ValueError('Keyword parameter "direction_margin": a' \
                                 ' value of the direction margin cannot be' \
                                 ' less than zero and greater than one but' \
                                 ' %f given!' \
                                 % float(kwargs['direction_margin']))
        if 'direction_mean' in kwargs:
            check_argument_type(GaussMarkov.__name__, 'direction_mean', float,
                                kwargs['direction_mean'], self.logger)
        if 'recalculation_interval' in kwargs:
            check_argument_type(GaussMarkov.__name__, 'recalculation_interval',
                                int, kwargs['recalculation_interval'],
                                self.logger)
        self.__alpha = float(kwargs.get('alpha', GaussMarkov.__DEFAULT_ALPHA))
        self.__direction_deviation = \
            float(kwargs.get('direction_deviation',
                             GaussMarkov.__DEFAULT_DIRECTION_DEVIATION))
        self.__direction_margin = \
            float(kwargs.get('direction_margin',
                             GaussMarkov.__DEFAULT_DIRECTION_MARGIN))
        self.__direction_mean = \
            float(kwargs.get('direction_mean',
                             GaussMarkov.__DEFAULT_DIRECTION_MEAN))
        self.__recalculation_interval = \
            int(kwargs.get('recalculation_interval',
                           self.__time.simulation_frequency))
        # 1.0 - alpha:
        self.__gauss_markov_factor_one = 1.0 - self.__alpha
        # sqrt((1.0 - alpha^2)):
        self.__gauss_markov_factor_two = sqrt(1.0 - (pow(self.__alpha, 2.0)))
        # area width * direction margin:
        self.__width_left = self.__area.width * self.__direction_margin
        # area width - (area width * direction margin):
        self.__width_right = self.__area.width - self.__width_left
        # area height * direction margin:
        self.__height_bottom = self.__area.height * self.__direction_margin
        # area height - (area height * direction margin):
        self.__height_top = self.__area.height - self.__height_bottom
        # { node id:
        #     { 'speed':      current speed),
        #       'direction':  current direction } }
        self.__velocities = dict()
        for node_id in range(0, len(initial_coordinates)):
            self.__velocities[node_id] = dict()
            self.__velocities[node_id]['speed'] = float(initial_speed)
            self.__velocities[node_id]['direction'] = \
                self.__get_new_direction()
        self.logger.debug('Speed and direction values has been initialized' \
                          ' for %d nodes' % len(self.__velocities))
Example #6
0
    def __init__(self, area, time, initial_coordinates, pause_time=0.0,
                 area_factor=0.25):
        """
        *Parameters*:
            - **area**: an object representing the simulation area;
            - **time**: a simulation time object of the
              :class:`sim2net._time.Time` class;
            - **initial_coordinates** (`list`): initial coordinates of all
              nodes; each element of this parameter should be a tuple of two
              coordinates: horizontal and vertical (respectively) of type
              `float`;
            - **pause_time** (`float`): a maximum value of the pause time in
              the *simulation time* units (default: `0.0`, see also:
              :mod:`sim2net._time`);
            - **area_factor** (`float`): a factor used to determine the width
              and height of the free roam area around the reference point
              (default: `0.25`).

        *Raises*:
            - **ValueError**: raised when the given value of the *area*, *time*
              or *initial_coordinates* parameter is `None`; or when the given
              value of the *pause_time* parameter is less that zero; or when
              the given value of the *area_factor* parameter is less than zero
              or greater than one.

        (At the beginning, nodes' destination points are set to be equal to its
        initial coordinates passed by the *initial_coordinates* parameter.)
        """
        if area is None:
            raise ValueError('Parameter "area": a simulation area object' \
                             ' expected but "None" value given!')
        if time is None:
            raise ValueError('Parameter "time": a time abstraction object' \
                             ' expected but "None" value given!')
        if initial_coordinates is None:
            raise ValueError('Parameter "initial_coordinates": identifiers' \
                             ' of nodes expected but "None" value given!')
        Mobility.__init__(self, NomadicCommunity.__name__)
        check_argument_type(RandomWaypoint.__name__, 'initial_coordinates',
                            list, initial_coordinates, self.logger)
        check_argument_type(RandomWaypoint.__name__, 'pause_time', float,
                            pause_time, self.logger)
        if pause_time < 0.0:
            raise ValueError('Parameter "pause_time": a value of the pause' \
                             ' time cannot be less that zero but %f given!' \
                             % float(pause_time))
        self._pause_time = float(pause_time)
        check_argument_type(RandomWaypoint.__name__, 'area_factor', float,
                            area_factor, self.logger)
        if area_factor < 0.0 or area_factor > 1.0:
            raise ValueError('Parameter "area_factor": a value of the factor' \
                             ' used to compute the free roam area of nodes' \
                             ' cannot be less than zero or greater than one' \
                             ' but %f given!' % float(area_factor))
        self.__area_factor = float(area_factor)
        self._area = area
        self._time = time
        self.__reference_point = \
            (self.random_generator.uniform(self._area.ORIGIN[0],
                                           self._area.width),
             self.random_generator.uniform(self._area.ORIGIN[1],
                                           self._area.height))
        self.__relocation_time = None
        # { node id:
        #     { 'destination':  (horizontal coordinate, vertical coordinate),
        #       'pause time' :  time } }
        #       'on site'    :  True/False } }
        self._destinations = dict()
        for node_id in range(0, len(initial_coordinates)):
            self._destinations[node_id] = dict()
            self._destinations[node_id]['destination'] = \
                initial_coordinates[node_id]
            self._destinations[node_id]['pause time'] = None
            self._destinations[node_id]['on site'] = False
        self.logger.debug('Destination points has been initialized for %d' \
                          ' nodes with the initial reference point at (%f,' \
                          ' %f)' % (len(self._destinations),
                                    self.__reference_point[0],
                                    self.__reference_point[1]))