mobility-Centrality

from inherit_config_parser import InheritConfigParser

import configparser  # https://docs.python.org/2.7/library/configparser.html

from pymobility.models.mobility import gauss_markov, reference_point_group, \

    tvc, truncated_levy_walk, random_direction, random_waypoint, random_walk

import sys

from milanoMob import milano_mob

import code  # code.interact(local=dict(globals(), **locals()))

class ConfSettings(object):

    def __init__(self, settingsFile, sectionExp):

        self.SF = settingsFile

        self.SEC = sectionExp

        # return self.getSimulationParameters(settingsFile, sectionExp)

    def getSimulationParameters(self):

        settingsFile, sectionExp = self.SF, self.SEC

        retParameters = {}

        #settings = configparser.ConfigParser()

        #settings._interpolation = configparser.ExtendedInterpolation()

        settings = InheritConfigParser()

        settings.optionxform = str

        settings.read(settingsFile)

        mand = set([

            'mob_model', 'max_x', 'max_y', 'radius',

            'mobility_timer', 'duration'])

        opts = dict(settings.items(sectionExp))

        if (not mand.issubset(opts.keys())):

            sys.exit('You are missing a mandatory parameter!\n'

                     'These are required:\n' + ', '.join(mand))

        for option in opts:

            arg = settings.get(sectionExp, option)

            if option == 'duration':

                retParameters['duration'] = int(arg.strip('s'))

            elif option == 'mob_model':

                mobset = set(['RandoWalk', 'RandomWayPoint', 'RandomDirection', 'Milan',

                              'TruncatedLevyWalk', 'GaussMarkov', 'ReferencePointGroup', 'TimeVariantCommunity'])

                if arg not in mobset:

                    sys.exit(arg+' is not a mobility model supported!\n'

                             'These are supported:\n' + ', '.join(mobset))

                retParameters['mob_model'] = arg

            elif option == 'max_x':

                retParameters['max_x'] = int(arg)

            elif option == 'max_y':

                retParameters['max_y'] = int(arg)

            elif option == 'nodes_number':

                retParameters['nodes_number'] = int(arg)

            elif option == 'max_velocity':

                retParameters['max_velocity'] = float(arg)

            elif option == 'min_velocity':

                retParameters['min_velocity'] = float(arg)

            elif option == 'max_wait_time':

                retParameters['max_wait_time'] = float(arg)

            elif option == 'radius':

                retParameters['radius'] = float(arg)

            elif option == 'mobility_timer':

                retParameters['mobility_timer'] = float(arg.strip('s'))

            elif option == 'nodes_x_group':

                retParameters['nodes_x_group'] = int(arg)

            elif option == 'groups_number':

                retParameters['groups_number'] = int(arg)

            else:

                print 'Unparsed ', option, '=', settings.get(sectionExp, option)

        return retParameters

    def configMobility(self, params):

        userMobi = params['mob_model']

        supportedModels = ["RandomWayPoint", "TimeVariantCommunity", "Milan"]

        if userMobi not in supportedModels:

            print userMobi + " is not supported now!\n" \

                "This moility models are currently supported:"

            print ", ".join(supportedModels)

            sys.exit(1)

        else:

            if userMobi == "RandomWayPoint":

                if not set(['max_x', 'max_y', 'nodes_number', 'max_velocity']).issubset(params.keys()):

                    print "You miss some params to configure RandomWayPoint"

                    sys.exit(1)

                else:

                    N = params['nodes_number']

                    max_x, max_y = params['max_x'], params['max_y']

                    min_v, max_v = params['min_velocity'], params['max_velocity']

                    max_wt = params['max_wait_time']

                    rw = random_waypoint(N, dimensions=(

                        max_x, max_y), velocity=(min_v, max_v), wt_max=max_wt)

                    return rw

            elif userMobi == "Milan":

                return milano_mob()

            elif userMobi == "TimeVariantCommunity":

                '''

    Time-variant Community Mobility Model, discussed in the paper

        Wei-jen Hsu, Thrasyvoulos Spyropoulos, Konstantinos Psounis, and Ahmed Helmy, 

        "Modeling Time-variant User Mobility in Wireless Mobile Networks," INFOCOM 2007, May 2007.

    This is a variant of the original definition, in the following way:

    - Communities don't have a specific area, but a reference point where the 

       community members aggregate around.

    - The community reference points are not static, but follow a random direction model.

    - You can define a list of epoch stages, each value is the duration of the stage.

       For each stage a different aggregation value is used (from the aggregation parameter).

    - Aggregation values should be doubles between 0 and 1.

       For aggregation 0, there's no attraction point and the nodes move in a random walk model.

       For aggregation near 1, the nodes move closer to the community reference point.

    Required arguments:

      *nr_nodes*:

        list of integers, the number of nodes in each group.

      *dimensions*:

        Tuple of Integers, the x and y dimensions of the simulation area.

    keyword arguments:

      *velocity*:

        Tuple of Doubles, the minimum and maximum values for community velocities.

      *aggregation*:

        List of Doubles, parameters (between 0 and 1) used to aggregate the nodes around the community center.

        Usually between 0 and 1, the more this value approximates to 1,

        the nodes will be more aggregated and closer to the group center.

        With aggregation 0, the nodes are randomly distributed in the simulation area.

        With aggregation near 1, the nodes are closer to the group center.

      *epoch*:

        List of Integers, the number of steps each epoch stage lasts.

    '''

                if not set(['max_x', 'max_y', 'nodes_x_group', 'min_velocity',

                            'max_velocity', 'groups_number']).issubset(params.keys()):

                    print "You miss some params to configure TimeVariantCommunity"

                    sys.exit(1)

                else:

                    NxG = params['nodes_x_group']

                    NG = params['groups_number']

                    max_x, max_y = params['max_x'], params['max_y']

                    min_v, max_v = params['min_velocity'], params['max_velocity']

                    groups = [NxG for _ in range(NG)]

                    nr_nodes = sum(groups)

                    tvcm = tvc(groups, dimensions=(100, 100), velocity=(min_v, max_v),

                               aggregation=[0.5, 0.], epoch=[100, 100])

                    return tvcm