mobility-Centrality

import graph_tool.centrality as gtc

import warnings

import util.EventScheduler as ES

from tqdm import tqdm  # https://pypi.org/project/tqdm/#usage

from util.UnitDiskGraph import UnitDiskGraph

from util.ConfPars import ConfSettings

import pandas as pd

from multiprocessing import Pool

import random

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

import networkx as nx

import util.MyUtil as myu

import util.nx2gt as nx2gt

from time import sleep

import matplotlib.pyplot as plt

plt.ion()

def f(params):

    pos, radius = params['pos'], params['radius']

    # Build new UnitDiskGraph

    G, nxG = UnitDiskGraph(pos, radius).getGraph()

    params['nxG'] = nxG

    ws = G.edge_properties["weight"]

    vp, ep = gtc.betweenness(G, norm=False, weight=ws)

    btwd = {i: vp.a[i] for i in range(len(vp.a))}

    params['btw'] = btwd

    return params

class Simulator(object):

    def __init__(self, settingsFile, sectionExp, outPath, num_workers=1, gui=False):

        self.gui = gui

        self.num_workers = num_workers

        self.sched = ES.EventScheduler()  # scheduler

        config = ConfSettings(settingsFile, sectionExp)

        self.params = config.getSimulationParameters()

        self.expName = sectionExp

        self.mob = config.configMobility(self.params)

        self.OP = outPath

        NN = self.params['nodes_number']

        self.statsFiles = {}

        for i in range(NN):

            f = open(outPath+"/stats"+'%08d' % i+".csv", 'a+')

            self.statsFiles[i] = f

            f.write("Time,BC\n")

    def batch_tasks(self, sched, mobi, num_workers=5):

        # prepare next num_workers tasks

        tasks = []

        for i in range(num_workers):

            event = sched.pop_event()

            # Get new coordinates

            positions = next(mobi)

            tasks.append({'pos': positions, 'radius': self.params['radius'], 'time': sched.elapsed_time(

            ), 'tag': sched.processed_events()})

            # schedule next DV

            jitter = [-1, 1][random.randrange(2)]*random.uniform(0, 0.866)

            sched.schedule_event(1.0 + jitter, "move!")

        p = Pool(num_workers)

        res = p.map(f, tasks)

        p.close()

        return res

    def runSimulation(self):

        warnings.filterwarnings("ignore", module="matplotlib")

        sched = self.sched

        self.sched.schedule_event(0, "move!")

        print "\nRunning " + self.expName + "..."

        with tqdm(total=self.params['duration']) as pbar:

            while(sched.processed_events() < self.params['duration']):

                prev = sched.processed_events()

                # Process a batch of tasks

                results = self.batch_tasks(

                    self.sched, self.mob, num_workers=self.num_workers)

                current = sched.processed_events()

                pbar.update(current-prev)

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

                # Log results to disk

                for res in results:

                    self.logBTW(res['btw'], res['tag'])

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

                if self.gui and self.num_workers == 1:

                    res = results[0]

                    self.draw(res['nxG'], res['pos'], res['btw'])

        # Main Loop End Here

        for f in self.statsFiles:

            self.statsFiles[f].close()

        return

    def logBTW(self, btw, tag):

        tag = '%08d' % tag

        for n, bc in btw.items():

            self.statsFiles[n].write(tag+","+str(bc)+"\n")

    def draw(self, G, pos, measures=None):

        xmax = self.params['max_x']

        ymax = self.params['max_y']

        myu.draw(G, pos, xmax, ymax, measures)