4 files changed, 320 insertions, 0 deletions

diff --git a/Metrics/Metrics-Calculation/metrics_plot/utils/DistributionMetrics.py b/Metrics/Metrics-Calculation/metrics_plot/utils/DistributionMetrics.py
new file mode 100644
index 00000000..cf532bc5
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/utils/DistributionMetrics.py
@@ -0,0 +1,53 @@
+from scipy import stats
+from scipy.spatial import distance
+
+def ks_distance(samples1, samples2):
+    value, p = stats.ks_2samp(samples1, samples2)
+    return (value, p)
+
+def manual_ks(pdf1, pdf2):
+    result = 0
+    sum1 = 0
+    sum2 = 0
+    for(a, b) in zip(pdf1, pdf2):
+        sum1 += a
+        sum2 += b
+        result = max(result, abs(sum1-sum2))
+    return result
+
+def js_distance(samples1, samples2):
+    map1 = fromSamples(samples1)
+    map2 = fromSamples(samples2)
+    allKeys = set(map1.keys()) | set(map2.keys())
+    dist1 = distributionFromMap(map1, allKeys)
+    dist2 = distributionFromMap(map2, allKeys)
+    return distance.jensenshannon(dist1, dist2, 2)
+
+def euclidean_distance(samples1, samples2):
+    map1 = fromSamples(samples1)
+    map2 = fromSamples(samples2)
+    allKeys = set(map1.keys()) | set(map2.keys())
+    dist1 = distributionFromMap(map1, allKeys)
+    dist2 = distributionFromMap(map2, allKeys)
+    distance = 0
+    for i in range(len(dist2)):
+        distance += pow(dist1[i] - dist2[i], 2)
+    return pow(distance, 0.5)
+
+def fromSamples(samples):
+    m = {}
+    length = len(samples)
+    for sample in samples:
+        value = m.get(sample, 0)
+        m[sample] = value + 1
+    for key in list(m.keys()):
+        m[key] /= length
+    return m
+
+def distributionFromMap(m, allKeys):
+    dist = []
+    for key in allKeys:
+        value = m.get(key, 0)
+        dist.append(value)
+    return dist
+
diff --git a/Metrics/Metrics-Calculation/metrics_plot/utils/GraphType.py b/Metrics/Metrics-Calculation/metrics_plot/utils/GraphType.py
new file mode 100644
index 00000000..48d96ccc
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/utils/GraphType.py
@@ -0,0 +1,46 @@
+import readCSV as reader
+import constants
+import numpy as np
+
+# graph stats for a collection of graphs
+class GraphCollection:
+    
+    # init with path contrain files and number of files to read reader is imported from (readCSV)
+    def __init__(self, path, number, name, shouldShuffle = True):
+        self.out_ds = []
+        self.nas = []
+        self.mpcs = []
+        self.nts = []
+        self.name = name
+        self.tccs = []
+        self.violations = []
+        models = reader.readmultiplefiles(path, number, shouldShuffle)
+        print(len(models))
+        self.size = len(models)
+        for i in range(len(models)):
+            contents, out_d, na, mpc = reader.getmetrics(models[i])
+            self.out_ds.append(out_d)
+            self.nas.append(na)
+            self.mpcs.append(mpc)
+            if(constants.Node_TYPE_KEY in contents):
+                self.nts.append(contents[constants.Node_TYPE_KEY])
+            if(constants.TCC_VALUE in contents):
+                self.tccs.append(contents[constants.TCC_VALUE])
+            if(constants.VIOLATION in contents):
+                self.violations.append(contents[constants.VIOLATION][0])
+
+#Graph stat for one graph
+class GraphStat:
+    # init with teh file name of the stat
+    def __init__(self, filename):
+        contents, self.out_d, self.na, self.mpc = reader.getmetrics(filename)
+        self.numNodes = np.array(contents[constants.NUMBER_NODES])
+        if constants.STATE_ID in contents:
+            self.id = (contents[constants.STATE_ID])[0]
+        if constants.Node_TYPE_KEY in contents:
+            self.nodeTypeStat = contents[constants.Node_TYPE_KEY]
+        if constants.VIOLATION in contents:
+            self.violations = int(contents[constants.VIOLATION][0])
+        if(constants.TCC_VALUE_KEY in contents):
+            self.tcc = contents[constants.TCC_VALUE_KEY]
+
diff --git a/Metrics/Metrics-Calculation/metrics_plot/utils/constants.py b/Metrics/Metrics-Calculation/metrics_plot/utils/constants.py
new file mode 100644
index 00000000..e30cc583
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/utils/constants.py
@@ -0,0 +1,35 @@
+NUMBER_EDGE_TYPES = 'Number of Edge types'
+
+NUMBER_NODES = 'Number Of Nodes'
+
+OUT_DEGREE_COUNT = 'OutDegreeCount'
+
+OUT_DEGREE_VALUE = 'OutDegreeValue'
+
+NA_COUNT = 'NACount'
+
+NA_VALUE = 'NAValue'
+
+MPC_VALUE = 'MPCValue'
+
+MPC_COUNT = 'MPCCount'
+
+METAMODEL = 'Meta Mode'
+
+STATE_ID = 'State Id'
+
+NODE_TYPE = 'Node Type'
+
+Node_TYPE_KEY = 'NodeType'
+
+HUMAN_OUT_D_REP = '../input/humanOutput/R_2015225_run_1.csv'
+
+HUMAN_MPC_REP = '../input/humanOutput/R_2016324_run_1.csv'
+
+HUMAN_NA_REP = '../input/humanOutput/R_2017419_run_1.csv'
+
+VIOLATION = 'violations'
+
+TCC_VALUE= 'TCCValue'
+
+TCC_COUNT = 'TCCCount'
diff --git a/Metrics/Metrics-Calculation/metrics_plot/utils/readCSV.py b/Metrics/Metrics-Calculation/metrics_plot/utils/readCSV.py
new file mode 100644
index 00000000..a56caf45
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/utils/readCSV.py
@@ -0,0 +1,186 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy import stats
+import glob
+import random
+import constants
+
+#
+# read csvfile returns outdegree, node activity, mpc
+# as matrix with the first row of values and second row of count
+#
+def readcsvfile(filename):
+    
+    contents = {}
+    with open(filename) as f:
+        data = list(f)
+        f.close()
+        for i, line in enumerate(data):
+            arr = line.replace('\n', '').split(',')
+            # if there is no element in the line, continue
+            if len(line) < 0: continue
+            # else check for contents
+            # if it is MPC then use float
+            if arr[0] == constants.MPC_VALUE:
+                contents[constants.MPC_VALUE] = list(map(float, arr[1:]))
+            # meta models are string
+            elif(arr[0] == constants.METAMODEL):
+                contents[constants.METAMODEL] = arr[1:]
+            # Node types
+            elif(arr[0] == constants.NODE_TYPE):
+                types = data[i+1].replace('\n', '').split(',')
+                numbers = data[i+2].replace('\n', '').split(',')
+                #convert number to floats
+                numbers = [float(n) for n in numbers]
+                contents[constants.Node_TYPE_KEY] = {t : n for t, n in zip(types, numbers)}
+            elif(arr[0] == constants.TCC_VALUE):
+                contents[constants.TCC_VALUE] = list(map(float, arr[1:]))
+            # NA and OD are integers, and store other information as string
+            else:
+                try:
+                    contents[arr[0]] = list(map(int, arr[1:]))
+                except:
+                    contents[arr[0]] = arr[1:]
+    return contents
+
+def checkAndReshape(arr):
+    if len(arr.shape) < 2:
+        arr = np.reshape(arr, (arr.shape[0],1))
+    return arr
+
+def readTrajectory(filename):
+    state_codes = []
+    with open(filename) as f:
+        for i, line in enumerate(f):
+            if(line == ''): continue
+            state_codes.append(int(line))
+    return state_codes
+#
+# take a matrix as input
+# return the sample array
+#
+def getsample(dataMatrix):
+    data = []
+    value = dataMatrix[0, :]
+    count = dataMatrix[1, :]
+    for i, v in enumerate(value):
+        for x in range(0, int(count[i])):
+            data.append(v)
+    return data
+
+def reproduceSample(values, counts):
+    arr = np.array([values, counts])
+    return getsample(arr)
+
+#
+# take an array of filenames as input
+# return the samples of outdegree, na, mpc
+#
+def getmetrics(filename):
+    contents = readcsvfile(filename)
+    outdegree_sample = reproduceSample(contents[constants.OUT_DEGREE_VALUE], contents[constants.OUT_DEGREE_COUNT])
+    na_sample = reproduceSample(contents[constants.NA_VALUE], contents[constants.NA_COUNT])
+    mpc_sample = reproduceSample(contents[constants.MPC_VALUE], contents[constants.MPC_COUNT])
+
+    if(constants.TCC_VALUE in contents):
+        contents[constants.TCC_VALUE] = reproduceSample(contents[constants.TCC_VALUE], contents[constants.TCC_COUNT])
+
+    return contents,outdegree_sample, na_sample, mpc_sample
+
+#
+# read number of files in the given path RANDOMLY
+#
+def readmultiplefiles(dirName, maxNumberOfFiles, shouldShuffle = True):
+    list_of_files = glob.glob(dirName + '*.csv')  # create the list of file
+    if shouldShuffle: 
+        random.shuffle(list_of_files)
+    #if the number of files is out of bound then just give the whole list
+    file_names =  list_of_files[:maxNumberOfFiles]
+    # print(file_names)
+    return file_names
+
+
+def plotlines(x, y, ax):
+    l1, = ax.plot(x, y)
+
+
+def testgetsamplesfromfiles():
+    files = readmultiplefiles('../statistics/viatraOutput/', 2)
+    for file in files:
+        getmetrics(file)
+
+def probability(data):
+    sum = np.sum(data)
+    probabilityList = []
+    for d in data:
+        p = d/sum
+        probabilityList.append(p)
+    a = np.array(probabilityList)
+    return a
+
+
+def cumulativeProbability(p):
+    cdf = np.cumsum(p)
+    return cdf
+
+
+def plot():
+    fig, ax = plt.subplots()
+    fig, ax1 = plt.subplots()
+    fig, ax2 = plt.subplots()
+    fig, ax3 = plt.subplots()
+    fig, ax4 = plt.subplots()
+    fig, ax5 = plt.subplots()
+    list_of_files = readmultiplefiles('../statistics/iatraOutput/')
+    for file_name in list_of_files:
+        contents = readcsvfile(file_name)
+        outdegree = [contents[constants.OUT_DEGREE_VALUE], contents[constants.OUT_DEGREE_COUNT]]
+        na = [contents[constants.NA_VALUE], contents[constants.NA_COUNT]]
+        mpc = [contents[constants.MPC_VALUE], contents[constants.MPC_COUNT]]
+        outV = outdegree[0, :]
+        outC = outdegree[1, :]
+        outP = probability(outC)
+        outCumP = cumulativeProbability(outP)
+        plotlines(outV, outP, ax)
+        naV = na[0, :]
+        naC = na[1, :]
+        naP = probability(naC)
+        naCumP = cumulativeProbability(naP)
+        plotlines(naV, naP, ax1)
+        mpcV = mpc[0, :]
+        mpcC = mpc[1, :]
+        mpcP = probability(mpcC)
+        mpcCumP = cumulativeProbability(mpcP)
+        plotlines(mpcV, mpcP, ax2)
+        plotlines(outV, outCumP, ax3)
+        plotlines(naV, naCumP, ax4)
+        plotlines(mpcV, mpcCumP, ax5)
+    ax.set_xlabel('ourdegree')
+    ax.set_ylabel('pdf')
+    ax.grid()
+
+    ax1.set_xlabel('node activity')
+    ax1.set_ylabel('pdf')
+    ax1.grid()
+
+    ax2.set_xlabel('multiplex participation coefficient')
+    ax2.set_ylabel('pdf')
+    ax2.grid()
+
+    ax3.set_xlabel('ourdegree')
+    ax3.set_ylabel('cdf')
+    ax3.grid()
+
+    ax4.set_xlabel('node activity')
+    ax4.set_ylabel('cdf')
+    ax4.grid()
+
+    ax5.set_xlabel('multiplex participation coefficient')
+    ax5.set_ylabel('cdf')
+    ax5.grid()
+
+    plt.show()
+
+
+# plot()
+