mobility-Centrality

import pandas as pd

from pprint import pprint

import numpy as np

import glob

import matplotlib

import matplotlib.pyplot as plt

folder = sys.argv[1]

interval = 100

    interval = int(sys.argv[2])

nick = folder.split('/')[-2].split('_')[0]+"_"

os.chdir(folder)

print "Loading data from", folder, "..."

    # print snap

print "Processing and plotting..."

if not os.path.exists("plots"+nick):

    os.makedirs("plots"+nick)

os.chdir("plots"+nick)

initialCentrality = {}

for n in nodes:

y = n0.values

'''

    os.makedirs("BCreal")

os.chdir("BCreal")

for i in range(0, len(y)-interval, interval):

    plt.plot(range(i, i+interval, 1), y[i:i+interval])

    plt.ylim(min(y), max(y))

    plt.xlabel("Time [s]")

    plt.ylabel("Betweenness Centrality (NON-norm)")

    plt.clf()

os.chdir("./..")

# BC Heatmaps for consecutive time-frames

print "BC Heatmaps for consecutive time-frames"

if not os.path.exists("TimeFramesHeatmaps"):

    os.makedirs("TimeFramesHeatmaps")

os.chdir("TimeFramesHeatmaps")

sns.set(font_scale=0.5)

for i in range(0, len(y)-interval, interval):

    #yticks=range(0, len(dfn),5)

    #ax.set_xticks(range(i, i+interval))

    plt.xlabel("Time [sec]")

    plt.ylabel("Nodes")

    plt.yticks(rotation=0)

    plt.clf()

os.chdir("./..")

sns.set(font_scale=1)

def coreNodesAtTime(t, perc):

    srtd_BC = sorted(BCd.items(), key=operator.itemgetter(1), reverse=True)

    upto = int(len(srtd_BC) * (perc/100.0))

    coreDict = {k: v for k, v in srtd_BC[:upto]}

    coreRank = {}

    for i in range(upto):

        coreRank[srtd_BC[i][0]] = i

    return coreDict, coreRank, coreNodes

print "CoreResistence..."

'''dfCoreResist = pd.DataFrame()

for t in range(len(dfn.iloc[0])):

    activeMap[n] = flag

    coreResistMap[0][n] = flag

    coreNodes = coreNodesAtTime(t, 20)[2]

    old_Actives = [k for k, v in activeMap.items() if v]

    # rimuovi chi non e' piu' nella top20

    for n in old_Actives:

        if n not in coreNodes:

            resistings[n] = False

    coreResistMap.append(resistings)

cmap1 = LinearSegmentedColormap.from_list('mycmap1', ['white', 'blue'], 2)

plt.ylabel("Nodes")

plt.xlabel("Time")

plt.savefig(nick+"coreResistMap-EntryTOP10LeavingTOP20.pdf", format='pdf')

plt.clf()

def activeIntervals(v):

    retval = []

    current = 0

                prev = False

    return retval

nodes2interval = {}

for n in nodes:

    nodes2interval[n] = activeIntervals(resDF.iloc[n])

np.mean(allint)

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

plt.xlabel("Intervals of Persistence in the core [sec]")

plt.ylabel("Normalized Frequency")

plt.clf()

f.write(str(pd.DataFrame(allint).describe()))

        NN = self.params['nodes_number']

        self.statsFiles = {}

        for i in range(NN):

            self.statsFiles[i] = f

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

dfn = pd.DataFrame()  # rows=nodes columns=BC at column-index time-instant

print "Loading data from", folder, "..."

    # print snap

initialCentrality = {}

for n in nodes:

sorted_x = sorted(initialCentrality.items(),

dfACF = pd.DataFrame()  # rows=Time-Lags, columns = nodes

print "Processing data..."

for node in nodes:

    dfACF = pd.concat([dfACF, nodeACF], axis=1)

if not os.path.exists("plots"+nick):

    os.makedirs("plots"+nick)

os.chdir("plots"+nick)

# Plotting

# Mean AutoCorrelation and Rank-Correlation

# lags=20

x = range(0, lags)

meanACF = []

rankCorr = []

weightedRankCorr = []

for i in x:

    meanACF.append(np.mean(dfACF.iloc[i]))

plt.plot(x, meanACF, lw="1.5", label='Mean Autocorrelation')

plt.plot(x, rankCorr, lw="1.5", label='Rank-Correlation (with rank at t_0)')

plt.ylabel('Corr coeff: [ACF, Spearman rho]')

plt.xlabel('Time-lags / Time')

plt.grid()

plt.xlim(0, lags)

plt.savefig(nick+"autoCorrMean-RankSpearman.pdf", format='pdf')

plt.clf()

'''

plt.clf()

X, Y, Z = [], [], []

for node in srtNodes:

    for lag in range(lags):

        X.append(lag)

        Y.append(node)

        Z.append(list(dfACF.iloc[lag])[node])

        MAX_WT = 0.

        # Random Waypoint model

            MAX_X, MAX_Y), velocity=(MIN_V, MAX_V), wt_max=MAX_WT)

        # Reference Point Group model

        # In tutto 150 nodi = 10x(5+4+3) + 15x(2)

        # 10 gruppi X 5

        nr_nodes = sum(groups)

        rpg5 = reference_point_group(

            groups, dimensions=(MAX_X, MAX_Y), aggregation=0.5)

        # 10 gruppi X 4

        nr_nodes = sum(groups)

        rpg4 = reference_point_group(

            groups, dimensions=(MAX_X, MAX_Y), aggregation=0.5)

        # 10 gruppi X 3

        nr_nodes = sum(groups)

        rpg3 = reference_point_group(

            groups, dimensions=(MAX_X, MAX_Y), aggregation=0.5)

        # 15 gruppi X 2

        nr_nodes = sum(groups)

        rpg2 = reference_point_group(

            groups, dimensions=(MAX_X, MAX_Y), aggregation=0.5)