63 files changed, 3183 insertions, 0 deletions

diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.classpath b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.classpath
new file mode 100644
index 00000000..f4f8357b
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.classpath
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+        <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+        <classpathentry kind="src" path="src"/>
+        <classpathentry kind="src" path="xtend-gen"/>
+        <classpathentry kind="lib" path="C:/Users/chenp/eclipse-workspace/VIATRA-Generator/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/lib/commons-math3-3.6.1.jar"/>
+        <classpathentry kind="lib" path="C:/Users/chenp/eclipse-workspace/VIATRA-Generator/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/lib/commons-math3-3.6.1-javadoc.jar"/>
+        <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.gitignore b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.gitignore
new file mode 100644
index 00000000..317e68e2
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.gitignore
@@ -0,0 +1,6 @@
+/bin/
+bin/
+testInput/
+testOutput/
+xtend-gen/
+*.csv
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.project b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.project
new file mode 100644
index 00000000..5154dea0
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.project
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+        <name>ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator</name>
+        <comment></comment>
+        <projects>
+        </projects>
+        <buildSpec>
+                <buildCommand>
+                        <name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+                <buildCommand>
+                        <name>org.eclipse.jdt.core.javabuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+                <buildCommand>
+                        <name>org.eclipse.pde.ManifestBuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+                <buildCommand>
+                        <name>org.eclipse.pde.SchemaBuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+        </buildSpec>
+        <natures>
+                <nature>org.eclipse.pde.PluginNature</nature>
+                <nature>org.eclipse.jdt.core.javanature</nature>
+                <nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+        </natures>
+</projectDescription>
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.settings/org.eclipse.jdt.core.prefs b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 00000000..0c68a61d
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,7 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/Inputs/.gitignore b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/Inputs/.gitignore
new file mode 100644
index 00000000..17126b28
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/Inputs/.gitignore
@@ -0,0 +1,4 @@
+# ignore everything in this folder except for this folder it self
+
+*
+!.gitignore
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/META-INF/MANIFEST.MF b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/META-INF/MANIFEST.MF
new file mode 100644
index 00000000..da19e07c
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/META-INF/MANIFEST.MF
@@ -0,0 +1,18 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Graph_metrics_calculation
+Bundle-SymbolicName: ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator
+Bundle-Version: 1.0.0.qualifier
+Automatic-Module-Name: graph_metrics_calculation
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Require-Bundle: com.google.guava,
+ org.eclipse.xtext.xbase.lib,
+ org.eclipse.xtend.lib,
+ org.eclipse.xtend.lib.macro,
+ org.eclipse.emf.ecore;bundle-version="2.17.0",
+ org.eclipse.emf.ecore.xmi;bundle-version="2.15.0",
+ hu.bme.mit.inf.dslreasoner.viatra2logic;bundle-version="1.0.0",
+ hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph;bundle-version="1.0.0",
+ hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage;bundle-version="1.0.0",
+ org.eclipse.viatra.dse;bundle-version="0.21.2"
+Export-Package: ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/build.properties b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/build.properties
new file mode 100644
index 00000000..34d2e4d2
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/build.properties
@@ -0,0 +1,4 @@
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Domain.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Domain.xtend
new file mode 100644
index 00000000..8351e96b
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Domain.xtend
@@ -0,0 +1,5 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
+
+enum Domain{
+        Yakinduum
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Main.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Main.xtend
new file mode 100644
index 00000000..cf871ead
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Main.xtend
@@ -0,0 +1,72 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.EMFGraph
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.CsvFileWriter
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.GraphReader
+import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.impl.YakindummPackageImpl
+import java.util.ArrayList
+
+//import yakindumm2.impl.Yakindumm2PackageImpl
+
+class Main {
+        static class RWInformation{
+                public var String inputFolder;
+                public var String outputFolder;
+                public var int numRuns;
+                
+                new(String inputFolder, String outputFolder, int numRuns){
+                        this.inputFolder = inputFolder;
+                        this.outputFolder = outputFolder;
+                        this.numRuns = numRuns;
+                }
+        }
+        
+        def static void main(String[] args){
+                //init model
+                YakindummPackageImpl.eINSTANCE.eClass;
+//              Yakindumm2PackageImpl.eINSTANCE.eClass;
+                //val infos = initData();                                                                       
+                                                                                
+                println("Start Reading Models...");
+                var reader = new GraphReader(YakindummPackageImpl.eINSTANCE);
+//              for(info : infos){
+//                      calculateAllModels(info.inputFolder, info.outputFolder,info.numRuns, reader);
+//              }
+                
+                //human input has different package declaration
+//              reader = new GraphReader(Yakindumm2PackageImpl.eINSTANCE);
+                val human = new RWInformation("inputs/Random/", "outputs/", 1);
+                calculateAllModels(human.inputFolder, human.outputFolder,human.numRuns, reader);
+                
+                
+                println("finished");
+        }
+        
+        static def initData(){
+                val infos = new ArrayList<RWInformation>();
+                infos.add(new RWInformation("inputs/alloyInput/models/", "../plot/statistics/alloyOutput/", 20));
+                infos.add(new RWInformation("inputs/randomInput/models/", "../plot/statistics/randomOutput/", 20));
+                infos.add(new RWInformation("inputs/viatraInput30/", "../plot/statistics/viatraOutput30/", 20));
+                infos.add(new RWInformation("inputs/viatraInput100/", "../plot/statistics/viatraOutput100/", 10));
+                return infos;
+        }
+        
+        static def calculateAllModels(String inputFolder, String outputFolder, int numRuns, GraphReader reader){
+                for(var i = 1; i <= numRuns; i++){
+                        val models = new ArrayList<EMFGraph>();
+                        models.addAll(reader.readModels(inputFolder + "run" + i));
+                        for(model : models){
+                                calculateAndOutputMetrics(model, YakindummPackageImpl.eNAME, outputFolder+model.name+"_run_"+i+".csv");
+                        }
+                }
+                println("output results Ended for: " + outputFolder);
+                
+                
+        }
+        
+        static def calculateAndOutputMetrics(EMFGraph model, String metaModel, String fileName){
+                //println("evaluating for " + model.name);
+                model.metaModel = metaModel;
+                CsvFileWriter.write(model.evaluateAllMetrics(), fileName);
+        }
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetric.xtend
new file mode 100644
index 00000000..cdd06027
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetric.xtend
@@ -0,0 +1,124 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.KSDistance
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.PartialInterpretationGraph
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.CsvFileWriter
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MultiplexParticipationCoefficientMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeActivityMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.PrintWriter
+import java.util.ArrayList
+import java.util.List
+import org.eclipse.emf.ecore.util.EcoreUtil
+import org.eclipse.viatra.dse.api.Solution
+
+class PartialInterpretationMetric {
+        var static state = 0;
+        var static KSDistance ks;
+        
+        def static void initPaths(){
+                new File("debug/metric/").mkdir();
+                new File("debug/metric/trajectories/").mkdir();
+                ks = new KSDistance(Domain.Yakinduum);
+        }
+        
+        def static MetricDistanceGroup calculateMetricDistance(PartialInterpretation partial){
+                val metrics = new ArrayList<Metric>();
+                metrics.add(new OutDegreeMetric());
+                metrics.add(new NodeActivityMetric());
+                metrics.add(new MultiplexParticipationCoefficientMetric());
+                
+                val metricCalculator = new PartialInterpretationGraph(partial, metrics, null);          
+                var metricSamples = metricCalculator.evaluateAllMetricsToSamples();
+                
+                var mpc = ks.mpcDistance(metricSamples.mpcSamples);
+                var na = ks.naDistance(metricSamples.naSamples);
+                var outDegree = ks.outDegreeDistance(metricSamples.outDegreeSamples);
+                
+                return new MetricDistanceGroup(mpc, na, outDegree);
+        }
+        
+        // calculate the metrics for a state
+        def static void calculateMetric(PartialInterpretation partial, String path, String currentStateId, Integer counter){
+                val metrics = new ArrayList<Metric>();
+                metrics.add(new OutDegreeMetric());
+                metrics.add(new NodeActivityMetric());
+                metrics.add(new MultiplexParticipationCoefficientMetric());
+                
+                //make dir since the folder can be none existing
+                new File(path).mkdir();
+                val filename = path + "/state_"+currentStateId+"-"+counter+".csv";
+                state++;
+                val metricCalculator = new PartialInterpretationGraph(partial, metrics, currentStateId);
+                
+                CsvFileWriter.write(metricCalculator.evaluateAllMetrics(), filename);
+        }
+        
+        def static void outputTrajectories(PartialInterpretation empty, List<Solution>  solutions){     
+                for(solution : solutions){
+                        //need to copy the empty solution because the transition directly worked on the graph
+                        val emptySolutionCopy = EcoreUtil.copy(empty)
+                        val trajectory = solution.shortestTrajectory;
+                        trajectory.modelWithEditingDomain = emptySolutionCopy
+                        
+                        // state codes that will record the trajectory
+                        val stateCodes = newArrayList()
+                        
+                        var counter = 0
+                        //transform and record the state codes for each state
+                        while(trajectory.doNextTransformation){
+                                //println(trajectory.stateCoder.createStateCode)
+                                val stateId = trajectory.stateCoder.createStateCode.toString
+                                val interpretation = trajectory.getModel();
+                                //calculate metrics of current state
+                                calculateMetric(interpretation as PartialInterpretation, "debug/metric/output", stateId, counter)
+                                stateCodes.add(stateId)
+                                counter++
+                        }
+                        
+                        
+                        //output the trajectory
+                        try{
+                                new File("debug/metric/trajectories/").mkdir();
+                                val path = "debug/metric/trajectories/trajectory"+trajectory.stateCoder.createStateCode.toString+".csv"
+                                val PrintWriter writer = new PrintWriter(new File(path))
+                                val output = new StringBuilder
+                                for(stateCode : stateCodes){
+                                        output.append(stateCode+'\n')
+                                }
+                                writer.write(output.toString())
+                                writer.close()
+                        }catch(FileNotFoundException e) {
+                                e.printStackTrace()
+                        }
+                }                       
+        }
+}
+
+class MetricDistanceGroup{
+        var double mpcDistance;
+        var double naDistance;
+        var double outDegreeDistance;
+        
+        new(double mpcDistance, double naDistance, double outDegreeDistance){
+                this.mpcDistance = mpcDistance;
+                this.naDistance = naDistance;
+                this.outDegreeDistance = outDegreeDistance;
+        }
+        
+        def double getMPCDistance(){
+                return this.mpcDistance
+        }
+        
+        def double getNADistance(){
+                return this.naDistance
+        }
+        
+        def double getOutDegreeDistance(){
+                return this.outDegreeDistance
+        }
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/KSDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/KSDistance.xtend
new file mode 100644
index 00000000..1fb21529
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/KSDistance.xtend
@@ -0,0 +1,47 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app.Domain
+import java.util.List
+import org.apache.commons.math3.stat.inference.KolmogorovSmirnovTest
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.RepMetricsReader
+
+class KSDistance {
+        var static ksTester = new KolmogorovSmirnovTest();
+        var double[] mpcSamples;
+        var double[] naSamples;
+        var double[] outDegreeSamples;
+        
+        new(Domain d){
+                var metrics = RepMetricsReader.read(d);
+                mpcSamples = metrics.mpcSamples;
+                naSamples = metrics.naSamples.stream.mapToDouble([it]).toArray();
+                outDegreeSamples = metrics.outDegreeSamples.stream.mapToDouble([it]).toArray();
+        }
+        
+        def double mpcDistance(List<Double> samples){
+                // map list to array
+                var arr = samples.stream.mapToDouble([it]).toArray();
+                
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(arr.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(mpcSamples, arr);
+        }
+        
+        def double naDistance(List<Double> samples){
+                // map list to array
+                var arr = samples.stream.mapToDouble([it]).toArray();
+                
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(arr.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(naSamples as double[], arr);
+        }
+        
+        def double outDegreeDistance(List<Double> samples){
+                // map list to array
+                var arr = samples.stream.mapToDouble([it]).toArray();
+                
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(arr.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(outDegreeSamples, arr);
+        }
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.xtend
new file mode 100644
index 00000000..5c161f4b
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.xtend
@@ -0,0 +1,106 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
+import java.util.ArrayList
+import java.util.List
+import org.eclipse.emf.common.util.EList
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.EReference
+
+class EMFGraph extends Graph{   
+        def void init (EObject root, List<Metric> metrics, String name, List<String> referenceTypes){
+                val otherContents = root.eAllContents.toList();
+                otherContents.add(root);
+                init(otherContents, metrics, name, referenceTypes);
+        }
+        
+        /**
+         * init the graph with all nodes and reference types in the meta model
+         * @param objects: objects in the instance model (exclude root)
+         * @param metrics: metrics to be evaluated
+         * @param name: name of the instance model
+         * @param ReferenceTypes: reference types defined in the meta model
+         */
+        def void init(List<EObject> objects, List<Metric> metrics, String name, List<String> referenceTypes){
+                objects.forEach[it|
+                        statistic.addNode(it);
+                ]
+                
+                referenceTypes.forEach[it|
+                        statistic.addType(it);
+                ];
+                
+                objects.forEach[source|
+                        source.eClass.EAllReferences.forEach[r|
+                                //add the type first (if it is not added already)
+                                //many references
+                                if(r.isMany){
+                                        source.getNeighbours(r).forEach[target|
+                                                addEdge(source, target, r);
+                                        ]
+                                }else{
+                                        //single references
+                                        val target = source.eGet(r) as EObject;
+                                        addEdge(source, target, r);
+                                }
+                        ]
+                ]
+                
+                this.metrics = metrics;
+                this.name = name;
+        }
+        
+        /**
+         * Set basic information for the output
+         */
+   override setBasicInformation(ArrayList<ArrayList<String>> output){
+                val metaInfo = new ArrayList<String>();
+                metaInfo.add(META_MODEL_HEADER);
+                metaInfo.add(this.metaModel);
+                
+                val edgeInfo = new ArrayList<String>();
+                edgeInfo.add(NUM_EDGE_TYPE_HEADER);
+                edgeInfo.add(this.statistic.allTypes.size()+"");
+                
+                val nodeInfo = new ArrayList<String>();
+                nodeInfo.add(NUM_NODE_HEADER);
+                nodeInfo.add(this.statistic.allNodes.size()+"");
+                
+                val stateInfo = new ArrayList<String>();
+                stateInfo.add(STATE_ID_HEADER);
+                stateInfo.add(this.name);
+                
+                
+                output.add(metaInfo);
+                output.add(edgeInfo);
+                output.add(nodeInfo);
+                output.add(stateInfo);
+        }
+        
+        def EList<EObject> getNeighbours(EObject o, EReference r){
+                return (o.eGet(r, true) as EList<EObject>);
+        }
+        
+        def addEdge(EObject source, EObject target, EReference r){
+                if(target !== null && r !== null){
+                        statistic.addEdge(source, target, r.name);
+                }
+        }
+        
+        override GraphStatistic getStatistic(){
+                return this.statistic;
+        }
+        
+        override String getName(){
+                return this.name;
+        }
+        
+        def void setMetaModel(String model){
+                this.metaModel = model;
+        }
+        
+        def String getMetaModel(){
+                return this.metaModel;
+        }
+        
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.xtend
new file mode 100644
index 00000000..cf4aedba
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.xtend
@@ -0,0 +1,61 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import java.util.ArrayList
+import java.util.List
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MultiplexParticipationCoefficientMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeActivityMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric
+
+abstract class Graph {
+        
+        protected static val String META_MODEL_HEADER = "Meta Mode"
+        protected static val String NUM_NODE_HEADER = "Number Of Nodes";
+        protected static val String NUM_EDGE_TYPE_HEADER = "Number of Edge types"; 
+        protected static val String STATE_ID_HEADER = "State Id";
+        
+        protected val statistic = new GraphStatistic();
+        protected var List<Metric> metrics;
+        protected var String name = "";
+        protected var String metaModel = "";
+        
+        /**
+         * evaluate all metrics for this model
+         * return the result as a two dimentional list
+         */
+        def ArrayList<ArrayList<String>> evaluateAllMetrics(){
+                val result = new ArrayList<ArrayList<String>>();
+                setBasicInformation(result);
+                
+                for(metric : this.metrics){
+                        val datas = metric.evaluate(this.statistic);
+                        for(row : datas){
+                                result.add(new ArrayList<String>(row));
+                        }
+                }
+                return result;
+        }       
+        
+        def MetricSampleGroup evaluateAllMetricsToSamples(){
+                var sample = new MetricSampleGroup();
+                
+                for(metric : this.metrics){
+                        if(metric instanceof MultiplexParticipationCoefficientMetric){
+                                sample.mpcSamples = metric.evaluateSamples(this.statistic);                             
+                        }else if(metric instanceof NodeActivityMetric){
+                                sample.naSamples = metric.evaluateSamples(this.statistic);
+                        }else if(metric instanceof OutDegreeMetric){
+                                sample.outDegreeSamples = metric.evaluateSamples(this.statistic);
+                        }
+                }
+                
+                return sample;
+        }
+        
+        def void setBasicInformation(ArrayList<ArrayList<String>> result);
+        
+        def GraphStatistic getStatistic();
+        
+        def String getName();
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend
new file mode 100644
index 00000000..7ed58094
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.xtend
@@ -0,0 +1,107 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph
+
+import com.google.common.collect.ArrayListMultimap
+import com.google.common.collect.Multimap
+import java.util.HashMap
+import java.util.HashSet
+import java.util.List
+import org.eclipse.emf.ecore.EObject
+
+class GraphStatistic {
+        val incomingEdges = new HashMap<String, Multimap<EObject, EObject>>;
+        val outcomingEdges = new HashMap<String, Multimap<EObject, EObject>>;
+        
+        val edgeTypes = new HashSet<String>();
+        val nodes = new HashSet<EObject>();
+                
+        /**
+         * Add an edge type to to the graph
+         * @param type: type to add
+         */
+        def void addType(String type){
+                if(edgeTypes.contains(type)){
+                        return;
+                }
+                edgeTypes.add(type);
+                incomingEdges.put(type, ArrayListMultimap.create());
+                outcomingEdges.put(type, ArrayListMultimap.create());
+        }
+        
+        /**
+         * Add a node to he graph 
+         * @param node: node to add
+         */
+         def void addNode(EObject n){
+                if(nodes.contains(n)){
+                        return;
+                }
+                
+                nodes.add(n);
+         }
+         
+         /**
+          * Add an edge to the graph
+          * @param source: source node
+          * @param target: target node
+          * @param type: type of the reference
+          */
+          def void addEdge(EObject source, EObject target, String type){
+                outcomingEdges.get(type).put(source, target);
+                incomingEdges.get(type).put(target, source);
+          }
+          
+          /**
+           * calculate the out degree for an object
+           */
+          def int outDegree(EObject o){
+                var count = 0;
+                
+                for (String type : edgeTypes){
+                        count += outcomingEdges.get(type).get(o).size();
+                }
+                return count;
+          }
+          
+          /**
+           * calculate the in degree of an object
+           */
+          def int inDegree(EObject o){
+                var count = 0;
+                
+                for (String type : edgeTypes){
+                        count += incomingEdges.get(type).get(o).size();
+                }
+                return count;
+          }
+          
+          /**
+           * calculate the dimentional degree of a node
+           */
+          def int dimentionalDegree(EObject o, String type){
+                return incomingEdges.get(type).get(o).size() + outcomingEdges.get(type).get(o).size();
+          }
+          
+          /**
+           * calculate the number of edge types for a given degree.
+           */
+          def int numOfEdgeTypes(EObject o){
+                var count = 0;
+                
+                for(String type : edgeTypes){
+                        if(dimentionalDegree(o, type) > 0){
+                                count++;
+                        }
+                }
+                
+                return count;
+          }
+          
+          def List<String> getAllTypes(){
+                return edgeTypes.toList();
+          }
+          
+          def List<EObject> getAllNodes(){
+                return nodes.toList();
+          }
+}
+
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.xtend
new file mode 100644
index 00000000..14337ab0
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.xtend
@@ -0,0 +1,77 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.BooleanElementImpl
+import java.util.ArrayList
+import java.util.List
+
+class PartialInterpretationGraph extends Graph{
+        
+        /**
+         * Define a new PartialInterpretationGraph by parse every element from a PartialInterpretation
+         */
+        new(PartialInterpretation partial, List<Metric> metrics, String name){          
+                //the edge types are defined in terms of RelationDeclaration
+                partial.problem.relations.filter(RelationDeclaration).forEach[
+                        this.statistic.addType(it.name);
+                ]
+                // add all elements
+                val elements = getElements(partial);
+                for(element : elements){
+                        statistic.addNode(element)
+                }
+                
+                for(relationInterpretation : partial.partialrelationinterpretation) {
+                        val type = relationInterpretation.interpretationOf.name
+                        
+                        for(edge : relationInterpretation.relationlinks.filter(BinaryElementRelationLink)){
+                                statistic.addEdge(edge.param1, edge.param2, type);
+                        }                       
+                }       
+                
+                this.name = name;
+                this.metrics = metrics; 
+        }
+        
+        /**
+         * Set basic information for the output
+         */
+        override setBasicInformation(ArrayList<ArrayList<String>> output){
+                val metaInfo = new ArrayList<String>();
+                metaInfo.add(META_MODEL_HEADER);
+                metaInfo.add(this.metaModel);
+                
+                val edgeInfo = new ArrayList<String>();
+                edgeInfo.add(NUM_EDGE_TYPE_HEADER);
+                edgeInfo.add(this.statistic.allTypes.size()+"");
+                
+                val nodeInfo = new ArrayList<String>();
+                nodeInfo.add(NUM_NODE_HEADER);
+                nodeInfo.add(this.statistic.allNodes.size()+"");
+                
+                val stateInfo = new ArrayList<String>();
+                stateInfo.add(STATE_ID_HEADER);
+                stateInfo.add(this.name);
+                
+                output.add(metaInfo);
+                output.add(edgeInfo);
+                output.add(nodeInfo);
+                output.add(stateInfo);
+        }
+        
+        private def getElements(PartialInterpretation partial){
+                return partial.newElements.filter[!(it instanceof BooleanElementImpl)] + partial.problem.elements;
+        }
+        
+        override getStatistic() {
+                throw new UnsupportedOperationException("TODO: auto-generated method stub")
+        }
+        
+        override getName() {
+                return name;
+        }
+        
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/CsvFileWriter.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/CsvFileWriter.xtend
new file mode 100644
index 00000000..bed356e9
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/CsvFileWriter.xtend
@@ -0,0 +1,37 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io;
+
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.PrintWriter
+import java.util.ArrayList
+import java.util.List
+
+class CsvFileWriter {
+        def static void write(ArrayList<ArrayList<String>> datas, String uri) {
+                if(datas.size() <= 0) {
+                        return;
+                }
+                
+                //println("Output csv for " + uri);
+                try  {
+                        val PrintWriter writer = new PrintWriter(new File(uri));
+                        val output = new StringBuilder;
+                        for(List<String> datarow : datas){
+                                for(var i = 0; i < datarow.size() - 1; i++){
+                                        output.append(datarow.get(i) + ',');
+                                }
+                                
+                                if(datarow.size > 1){
+                                        output.append(datarow.get(datarow.size() - 1));
+                                        output.append('\n');
+                                }
+                        }
+                        
+                        writer.write(output.toString());
+                        writer.close();
+                        //println("Output csv finished");
+                }catch(FileNotFoundException e) {
+                        e.printStackTrace();
+                }
+        }
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/GraphReader.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/GraphReader.xtend
new file mode 100644
index 00000000..fc56e142
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/GraphReader.xtend
@@ -0,0 +1,81 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io;
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.EMFGraph
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MultiplexParticipationCoefficientMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeActivityMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric
+import java.io.File
+import java.io.FileNotFoundException
+import java.util.ArrayList
+import java.util.List
+import org.eclipse.emf.common.util.URI
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.EPackage
+import org.eclipse.emf.ecore.EReference
+import org.eclipse.emf.ecore.resource.Resource
+import org.eclipse.emf.ecore.resource.ResourceSet
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl
+import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl
+
+class GraphReader{
+        val ResourceSet resSet = new ResourceSetImpl();
+        val referenceTypes = new ArrayList<String>();
+        
+        new(EPackage metaModel) {
+                Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("*",new XMIResourceFactoryImpl)
+                
+                //find all reference types in the meta model
+                metaModel.eAllContents.forEach[
+                        if(it instanceof EReference){
+                                referenceTypes.add(it.name);
+                        }
+                ]
+        }
+        
+        def List<EMFGraph> readModels(String path){
+                val dir = new File(path);
+                if(!dir.isDirectory){
+                        throw new Exception("expecting a directory");
+                }
+                
+                val graphs = new ArrayList<EMFGraph>();
+                
+                val metrics = new ArrayList<Metric>();
+                metrics.add(new OutDegreeMetric());
+                metrics.add(new NodeActivityMetric());
+                metrics.add(new MultiplexParticipationCoefficientMetric());
+                                
+                //check all files in the directory with xmi
+                for(String name : dir.list.filter[it| it.endsWith(".xmi")]){
+                        val file = new File(name);
+                        val roots = readModel(EObject, path,  file.name);                       
+                        //add a list of metrics
+                        val g = new EMFGraph();
+                        for(root : roots){
+                                g.init(root, metrics, name.replaceFirst(".xmi", ""), referenceTypes);
+                        }
+                        
+                        graphs.add(g);
+                }
+                
+                return graphs;
+        }
+        
+        def <RootType extends EObject> List<RootType> readModel(Class<RootType> type, String path, String name) {
+                try {
+                        val resource = resSet.getResource(getURI(path, name),true);
+                        if(resource === null) throw new FileNotFoundException(getURI(path, name).toString)
+                        else {          
+                                return resource.contents as List<RootType>
+                        }
+                } catch(Exception e) {
+                        e.printStackTrace();
+                        throw new FileNotFoundException(getURI(path, name).toString + "reason: " + e.message)
+                }
+        }
+        
+        def static getURI(String path, String name) {
+                URI.createFileURI(path + "/"  + name)
+        }
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/RepMetricsReader.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/RepMetricsReader.xtend
new file mode 100644
index 00000000..867ddd1a
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/io/RepMetricsReader.xtend
@@ -0,0 +1,79 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app.Domain
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MultiplexParticipationCoefficientMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeActivityMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric
+import java.io.File
+import java.util.List
+import java.util.Scanner
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+
+/**
+ * Read the sample of the distribution of a metric provided the csv file of the metric
+ */
+class RepMetricsReader {
+        static def read(Domain d){
+                var domainRepPath = CsvDataName.REP_PATH + d.name + '/';
+                var rep = new MetricSampleGroup()
+                rep.mpcSamples = readFile(domainRepPath + CsvDataName.MPC_REP, MultiplexParticipationCoefficientMetric.valueName,
+                                                          MultiplexParticipationCoefficientMetric.countName).map[Double.parseDouble(it)];
+                rep.naSamples = readFile(domainRepPath+CsvDataName.NA_REP, NodeActivityMetric.valueName, NodeActivityMetric.countName
+                                                        ).map[Double.parseDouble(it)];
+                rep.outDegreeSamples = readFile(domainRepPath+CsvDataName.OUT_D_REP, OutDegreeMetric.valueName, OutDegreeMetric.countName
+                                                        ).map[Double.parseDouble(it)];
+                return rep;
+        }
+        
+        /**
+         * read metric data and parse it to samples
+         */
+        private static def List<String> readFile(String filename, String valueDataName, String countDataName){
+                var s = new Scanner(new File(filename));
+                val counts = newArrayList();
+                val values = newArrayList();
+                //read data from csv
+                while(s.hasNext()){
+                        var data = s.nextLine().split(',');     
+                        
+                        if(data.size >= 1){
+                                if(data.get(0).equals(countDataName)){
+                                        //add all data with parsing them as integers
+                                        counts.addAll(data.subList(1, data.size()).map[Integer.parseInt(it)]);
+                                }else if(data.get(0).equals(valueDataName)){
+                                        //add all data without parsing (there can be either double or string, to be parsed later)
+                                        values.addAll(data.subList(1, data.size()));
+                                }
+                        }
+                }
+                
+                return createSamples(counts, values);
+        }
+        
+        // create samples from values and counts
+        private static def List<String> createSamples(List<Integer> counts, List<String> values){
+                val samples = newArrayList();
+                
+                if(counts.size() != values.size()){
+                        throw new RuntimeException("counts and values should have the same size!");
+                }
+                
+                for(var i = 0; i < counts.size(); i++){
+                        for(var j = 0; j < counts.get(i); j++){
+                                samples.add(values.get(i));
+                        }
+                }
+                
+                return samples;
+        }
+        
+        
+}
+
+class CsvDataName{
+        public static val REP_PATH = 'data/';
+        public static val MPC_REP = 'mpc_rep.csv';
+        public static val NA_REP = 'na_rep.csv';
+        public static val OUT_D_REP = 'out_d_rep.csv';
+}
+
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/Metric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/Metric.xtend
new file mode 100644
index 00000000..38ef72f2
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/Metric.xtend
@@ -0,0 +1,8 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatistic
+
+abstract class Metric {
+        abstract def String[][] evaluate(GraphStatistic g);
+        abstract def double[] evaluateSamples(GraphStatistic g);
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/MetricSampleGroup.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/MetricSampleGroup.xtend
new file mode 100644
index 00000000..8cd3daee
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/MetricSampleGroup.xtend
@@ -0,0 +1,9 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics
+
+import java.util.List
+
+class MetricSampleGroup{
+        public var List<Double> mpcSamples;
+        public var List<Double> naSamples;
+        public var List<Double> outDegreeSamples;
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/MultiplexParticipationCoefficientMetric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/MultiplexParticipationCoefficientMetric.xtend
new file mode 100644
index 00000000..d9c88bb4
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/MultiplexParticipationCoefficientMetric.xtend
@@ -0,0 +1,80 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatistic
+import java.text.DecimalFormat
+import java.util.ArrayList
+import java.util.HashMap
+import org.eclipse.emf.ecore.EObject
+
+class MultiplexParticipationCoefficientMetric extends Metric {
+        public static val countName = "MPCCount";
+        public static val valueName = "MPCValue";
+        
+        
+        override evaluate(GraphStatistic g) {
+                //because the precision issue of double, we translate double values into String to be the key
+                val formatter = new DecimalFormat("#0.00000");     
+                
+                //get number of different types
+                val typeCounts = g.allTypes.size;
+                val map = new HashMap<String, Integer>();
+                //calculate the metric distribution
+                g.allNodes.forEach[n|
+                        var coef = calculateMPC(n, g, typeCounts);
+                        
+                        //format number to String
+                        val value = formatter.format(coef);
+                        if(!map.containsKey(value)){
+                                map.put(value, 1);
+                        }else{
+                                map.put(value, map.get(value) + 1);
+                        }               
+                        
+                ]
+                
+                //convert it into a 2 dimentional array
+                val String[][] datas = newArrayOfSize(2, map.size+1);
+                datas.get(0).set(0, valueName);
+                datas.get(1).set(0, countName)
+                var count = 1;
+                for(entry : map.entrySet.sortBy[it.key]){
+                        datas.get(0).set(count, entry.key+"");
+                        datas.get(1).set(count, entry.value+"");
+                        count++;
+                }
+                
+                return datas;
+        }
+        
+        override evaluateSamples(GraphStatistic g){
+                val samples = new ArrayList<Double>();
+                val typeCounts = g.allTypes.size;
+                //calculate the metric distribution
+                g.allNodes.forEach[
+                        samples.add(calculateMPC(it, g, typeCounts));
+                ]
+                
+                return samples;
+        }
+        
+        def double calculateMPC(EObject n, GraphStatistic g, int typeCounts){
+                val edgeCounts = g.outDegree(n) + g.inDegree(n);
+                        
+                var coef = 0.0;
+                
+                for(type : g.allTypes){
+                        val degree = g.dimentionalDegree(n, type) as double;
+                        coef += Math.pow(degree / edgeCounts, 2);
+                }               
+                coef = 1 - coef;                
+                coef = coef * typeCounts / (typeCounts-1);
+                
+                //Consider the case that either typeCounts-1 or the edgeCounts could be 0 in some situation
+                //in this case the metric should be evaluated to 0
+                if(Double.isNaN(coef)){
+                        coef = 0;
+                }
+                
+                return coef;
+        }
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/NodeActivityMetric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/NodeActivityMetric.xtend
new file mode 100644
index 00000000..fbf06c47
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/NodeActivityMetric.xtend
@@ -0,0 +1,49 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatistic
+import java.util.ArrayList
+import java.util.HashMap
+
+class NodeActivityMetric extends Metric {
+        public static val countName = "NACount";
+        public static val valueName = "NAValue";
+        
+        override evaluate(GraphStatistic g) {
+                val map = new HashMap<Integer, Integer>();
+                
+                //calculate the metric distribution
+                g.allNodes.forEach[
+                        val value = g.numOfEdgeTypes(it);
+                        if(!map.containsKey(value)){
+                                map.put(value, 1);
+                        }else{
+                                map.put(value, map.get(value) + 1);
+                        }
+                ]
+                
+                //convert it into a 2 dimentional array
+                val String[][] datas = newArrayOfSize(2, map.size+1);
+                datas.get(0).set(0, valueName);
+                datas.get(1).set(0, countName)
+
+                var count = 1;
+                for(entry : map.entrySet.sortBy[it.key]){
+                        datas.get(0).set(count, entry.key+"");
+                        datas.get(1).set(count, entry.value+"");
+                        count++;
+                }
+                
+                return datas;
+        }
+        
+        override evaluateSamples(GraphStatistic g){
+                val samples = new ArrayList<Double>();
+                
+                //calculate the metric distribution
+                g.allNodes.forEach[
+                        samples.add(g.numOfEdgeTypes(it) as double);
+                ]
+                
+                return samples;
+        }
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/OutDegreeMetric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/OutDegreeMetric.xtend
new file mode 100644
index 00000000..55046b14
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/OutDegreeMetric.xtend
@@ -0,0 +1,49 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatistic
+import java.util.ArrayList
+import java.util.HashMap
+
+class OutDegreeMetric extends Metric {
+        public static val countName = "OutDegreeCount";
+        public static val valueName = "OutDegreeValue";
+        
+        override evaluate(GraphStatistic g) {
+                val map = new HashMap<Integer, Integer>();
+                
+                //calculate the metric distribution
+                g.allNodes.forEach[
+                        val value = g.outDegree(it);
+                        if(!map.containsKey(value)){
+                                map.put(value, 1);
+                        }else{
+                                map.put(value, map.get(value) + 1);
+                        }
+                ]
+                
+                //convert it into a 2 dimentional array
+                val String[][] datas = newArrayOfSize(2, map.size+1);
+                datas.get(0).set(0, valueName);
+                datas.get(1).set(0, countName)
+                var count = 1;
+                for(entry : map.entrySet.sortBy[it.key]){
+                        datas.get(0).set(count, entry.key+"");
+                        datas.get(1).set(count, entry.value+"");
+                        count++;
+                }
+                
+                return datas;
+        }
+        
+        override evaluateSamples(GraphStatistic g){
+                val samples = new ArrayList<Double>();
+                
+                //calculate the metric distribution
+                g.allNodes.forEach[
+                        samples.add(g.outDegree(it) as double);
+                ]
+                
+                return samples;
+        }
+        
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/metrics_plot/.gitignore b/Metrics/Metrics-Calculation/metrics_plot/.gitignore
new file mode 100644
index 00000000..dc53b109
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/.gitignore
@@ -0,0 +1,10 @@
+# virtual enviroment
+venv/
+
+# python cache
+*.pyc
+.ipynb_checkpoints/
+.idea/
+
+# keep folders
+!.gitignore
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/input/.gitignore b/Metrics/Metrics-Calculation/metrics_plot/model comparison/input/.gitignore
new file mode 100644
index 00000000..b3934b01
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/input/.gitignore
@@ -0,0 +1,3 @@
+# ignore everything in this folder
+*
+!.gitignore
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Alloy (30 nodes)-/MPC.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Alloy (30 nodes)-/MPC.png
new file mode 100644
index 00000000..cd2af5ce
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Alloy (30 nodes)-/MPC.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Alloy (30 nodes)-/Node Activity.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Alloy (30 nodes)-/Node Activity.png
new file mode 100644
index 00000000..2ce3672b
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Alloy (30 nodes)-/Node Activity.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Alloy (30 nodes)-/Out Degree.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Alloy (30 nodes)-/Out Degree.png
new file mode 100644
index 00000000..d4d9afe1
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Alloy (30 nodes)-/Out Degree.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-/MPC.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-/MPC.png
new file mode 100644
index 00000000..8d76fed9
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-/MPC.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-/Node Activity.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-/Node Activity.png
new file mode 100644
index 00000000..daa7929a
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-/Node Activity.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-/Out Degree.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-/Out Degree.png
new file mode 100644
index 00000000..e56b1b6e
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-/Out Degree.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-Viatra (100 nodes)-/MPC.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-Viatra (100 nodes)-/MPC.png
new file mode 100644
index 00000000..8705cee2
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-Viatra (100 nodes)-/MPC.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-Viatra (100 nodes)-/Node Activity.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-Viatra (100 nodes)-/Node Activity.png
new file mode 100644
index 00000000..bdab3741
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-Viatra (100 nodes)-/Node Activity.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-Viatra (100 nodes)-/Out Degree.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-Viatra (100 nodes)-/Out Degree.png
new file mode 100644
index 00000000..e4269f6e
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Random-Viatra (100 nodes)-/Out Degree.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Viatra (60 nodes)-Viatra (100 nodes)-/MPC.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Viatra (60 nodes)-Viatra (100 nodes)-/MPC.png
new file mode 100644
index 00000000..e4b6b527
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Viatra (60 nodes)-Viatra (100 nodes)-/MPC.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Viatra (60 nodes)-Viatra (100 nodes)-/Node Activity.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Viatra (60 nodes)-Viatra (100 nodes)-/Node Activity.png
new file mode 100644
index 00000000..e067ad66
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Viatra (60 nodes)-Viatra (100 nodes)-/Node Activity.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Viatra (60 nodes)-Viatra (100 nodes)-/Out Degree.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Viatra (60 nodes)-Viatra (100 nodes)-/Out Degree.png
new file mode 100644
index 00000000..9b89e4f9
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/Human-Viatra (30 nodes)-Viatra (60 nodes)-Viatra (100 nodes)-/Out Degree.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/real vs viatra vs alloy/MPC.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/real vs viatra vs alloy/MPC.png
new file mode 100644
index 00000000..4f189578
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/real vs viatra vs alloy/MPC.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/real vs viatra vs alloy/Node Activity.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/real vs viatra vs alloy/Node Activity.png
new file mode 100644
index 00000000..add3c0f8
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/real vs viatra vs alloy/Node Activity.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/real vs viatra vs alloy/Out Degree.png b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/real vs viatra vs alloy/Out Degree.png
new file mode 100644
index 00000000..f4717a1a
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/output/real vs viatra vs alloy/Out Degree.png
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model comparison/src/plot_ks_stats.py b/Metrics/Metrics-Calculation/metrics_plot/model comparison/src/plot_ks_stats.py
new file mode 100644
index 00000000..2f39ca93
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model comparison/src/plot_ks_stats.py
@@ -0,0 +1,98 @@
+import os, sys
+lib_path = os.path.abspath(os.path.join('..', '..', 'utils'))
+sys.path.append(lib_path)
+import glob
+import random 
+from sklearn.manifold import MDS
+import matplotlib.pyplot as plt
+from scipy import stats
+import numpy as np
+from GraphType import GraphCollection
+
+def main():
+    # read models
+    human = GraphCollection('../input/humanOutput/', 500, 'Human')
+    viatra30 = GraphCollection('../input/viatraOutput30/', 500, 'Viatra (30 nodes)')
+    # viatra60 = GraphCollection('../input/viatraOutput60/', 500, 'Viatra (60 nodes)')
+    # viatra100 = GraphCollection('../input/viatraOutput100/', 500, 'Viatra (100 nodes)')
+    # random = GraphCollection('../input/randomOutput/', 500, 'Random')
+    # alloy = GraphCollection('../input/alloyOutput/', 500, 'Alloy (30 nodes)')
+
+    models_to_compare = [human, viatra30]
+    
+    # define output folder
+    outputFolder = '../output/'
+
+    #calculate metrics
+    metricStat(models_to_compare, 'Node Activity', nodeActivity, 0, outputFolder)
+    metricStat(models_to_compare, 'Out Degree', outDegree, 1, outputFolder)
+    metricStat(models_to_compare, 'MPC', mpc, 2, outputFolder)
+
+def calculateKSMatrix(dists):
+    dist = []
+
+    for i in range(len(dists)):
+        dist = dist + dists[i]
+    matrix = np.empty((len(dist),len(dist)))
+
+    for i in range(len(dist)):
+        matrix[i,i] = 0
+        for j in range(i+1, len(dist)):
+            value, p = stats.ks_2samp(dist[i], dist[j])
+            matrix[i, j] = value
+            matrix[j, i] = value
+    return matrix
+
+
+def calculateMDS(dissimilarities):
+    embedding = MDS(n_components=2, dissimilarity='precomputed')
+    trans = embedding.fit_transform(X=dissimilarities)
+    return trans
+
+def plot(graphTypes, coords, title='',index = 0, savePath = ''):
+    half_length = int(coords.shape[0] / len(graphTypes))
+    color = ['blue', 'red', 'green', 'yellow']
+    plt.figure(index, figsize=(7, 4))
+    plt.title(title)
+    for i in range(len(graphTypes)):
+        x = (coords[(i*half_length):((i+1)*half_length), 0].tolist())
+        y = (coords[(i*half_length):((i+1)*half_length), 1].tolist())
+        plt.plot(x, y, color=color[i], marker='o', label = graphTypes[i].name, linestyle='', alpha=0.7)
+    plt.legend(loc='upper right')
+    plt.savefig(fname = savePath, dpi=150)
+    #graph.show()
+
+def mkdir_p(mypath):
+    '''Creates a directory. equivalent to using mkdir -p on the command line'''
+
+    from errno import EEXIST
+    from os import makedirs,path
+
+    try:
+        makedirs(mypath)
+    except OSError as exc: # Python >2.5
+        if exc.errno == EEXIST and path.isdir(mypath):
+            pass
+        else: raise
+
+def metricStat(graphTypes, metricName, metric, graphIndex, outputFolder):
+    metrics = []
+    for graph in graphTypes:
+        metrics.append(metric(graph))
+        outputFolder = outputFolder + graph.name + '-'
+    print('calculate' + metricName +' for ' + outputFolder)
+    mkdir_p(outputFolder)
+    out_d_coords = calculateMDS(calculateKSMatrix(metrics))
+    plot(graphTypes, out_d_coords, metricName, graphIndex,outputFolder + '/'+ metricName+'.png')
+
+def nodeActivity(graphType):
+    return graphType.nas
+
+def outDegree(graphType):
+    return graphType.out_ds
+
+def mpc(graphType):
+    return graphType.mpcs
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/input/.gitignore b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/input/.gitignore
new file mode 100644
index 00000000..b3934b01
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/input/.gitignore
@@ -0,0 +1,3 @@
+# ignore everything in this folder
+*
+!.gitignore
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/controled_viatra_with_mpc/Node Activity.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/controled_viatra_with_mpc/Node Activity.jpg
new file mode 100644
index 00000000..d2dbd970
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/controled_viatra_with_mpc/Node Activity.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/controled_viatra_with_mpc/mpc.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/controled_viatra_with_mpc/mpc.jpg
new file mode 100644
index 00000000..3ca2e0bc
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/controled_viatra_with_mpc/mpc.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/controled_viatra_with_mpc/out_degree.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/controled_viatra_with_mpc/out_degree.jpg
new file mode 100644
index 00000000..5b623374
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/controled_viatra_with_mpc/out_degree.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf/mpc.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf/mpc.jpg
new file mode 100644
index 00000000..7a744ea6
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf/mpc.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf/node activity.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf/node activity.jpg
new file mode 100644
index 00000000..dfcc973e
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf/node activity.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf/out degree.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf/out degree.jpg
new file mode 100644
index 00000000..b3f4f912
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf/out degree.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf_instantiator/Node Activity.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf_instantiator/Node Activity.jpg
new file mode 100644
index 00000000..f0d09211
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf_instantiator/Node Activity.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf_instantiator/mpc.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf_instantiator/mpc.jpg
new file mode 100644
index 00000000..94b070d4
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf_instantiator/mpc.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf_instantiator/out_degree.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf_instantiator/out_degree.jpg
new file mode 100644
index 00000000..8d0151fa
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/random_emf_instantiator/out_degree.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_constraints/MPC.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_constraints/MPC.jpg
new file mode 100644
index 00000000..b10d97e6
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_constraints/MPC.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_constraints/node activity.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_constraints/node activity.jpg
new file mode 100644
index 00000000..e41c998b
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_constraints/node activity.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_constraints/out degree.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_constraints/out degree.jpg
new file mode 100644
index 00000000..d2776bc8
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_constraints/out degree.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_no_constraints/MPC.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_no_constraints/MPC.jpg
new file mode 100644
index 00000000..19feb5e8
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_no_constraints/MPC.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_no_constraints/node activity.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_no_constraints/node activity.jpg
new file mode 100644
index 00000000..bc7a83fc
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_no_constraints/node activity.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_no_constraints/out degree.jpg b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_no_constraints/out degree.jpg
new file mode 100644
index 00000000..13094840
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/output/viatra_no_constraints/out degree.jpg
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/src/metrics_distance.ipynb b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/src/metrics_distance.ipynb
new file mode 100644
index 00000000..550e3978
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/src/metrics_distance.ipynb
@@ -0,0 +1,481 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Compare Metrics Distances to The Human Models"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from GraphType import GraphStat\n",
+    "from GraphType import GraphCollection\n",
+    "from scipy import stats\n",
+    "from ipywidgets import interact, fixed, interactive\n",
+    "import readCSV as reader\n",
+    "import ipywidgets as widgets\n",
+    "import matplotlib.pyplot as plt\n",
+    "import random\n",
+    "import numpy as np\n",
+    "import constants\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Classes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Record the average distances of different metrics for a model to the human models "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GraphDistance:\n",
+    "    #init with a graph stat and a collection of graph stats\n",
+    "    def __init__(self, graphStat, collection):\n",
+    "        self.graph = graphStat\n",
+    "        self.collection = collection\n",
+    "        self.out_d_distance = average_ks_distance(collection.out_ds, graphStat.out_d)\n",
+    "        self.na_distance = average_ks_distance(collection.nas, graphStat.na)\n",
+    "        self.mpc_distance = average_ks_distance(collection.mpcs, graphStat.mpc)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Methods"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Calculate the average ks distance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def average_ks_distance(targets, sample):\n",
+    "    distance = 0.0\n",
+    "    for target in targets:\n",
+    "        value, p = stats.ks_2samp(target, sample)\n",
+    "        distance += value\n",
+    "    distance = distance / len(targets)\n",
+    "    return distance\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "* Find the median ks distance of the same number of nodes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def find_median(x, metric_distances):\n",
+    "    distance_dic = {}\n",
+    "    for index, num_of_nodes in enumerate(x):\n",
+    "        if num_of_nodes[0] not in distance_dic:\n",
+    "            distance_dic[num_of_nodes[0]] = []\n",
+    "        distance_dic[num_of_nodes[0]].append(metric_distances[index])\n",
+    "    median_x = []\n",
+    "    y = []\n",
+    "    for num_of_nodes, distances in distance_dic.items():\n",
+    "        median_x.append(num_of_nodes)\n",
+    "        y.append(np.median(distances))\n",
+    "    order = np.argsort(median_x)\n",
+    "    median_x = np.array(median_x)[order]\n",
+    "    median_y = np.array(y)[order]\n",
+    "    return median_x, median_y\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Plot Diagram"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# metric_selector: GraphDistance -> float\n",
+    "def plot(infos, lines, id, metric_selector,colors, title):\n",
+    "    metric_distances = retrive_info_from_list(metric_selector, list(infos.values()))\n",
+    "    x = retrive_info_from_list(lambda a : a.graph.num_nodes, list(infos.values()))\n",
+    "    graph = plt.figure(id,figsize=(18, 10))\n",
+    "    plt.title(title)\n",
+    "    plt.plot(x, metric_distances, color='red', linestyle='', marker='o',alpha=0.7)\n",
+    "    #plot ks distance median\n",
+    "    median_x, median_y = find_median(x, metric_distances)\n",
+    "    plt.plot(median_x, median_y, color='black',marker='o')\n",
+    "    for i in range(0, len(lines)):\n",
+    "        line_infos = retrive_info_from_list(lambda a: infos[a], lines[i])\n",
+    "        line_y = retrive_info_from_list(metric_selector, line_infos)\n",
+    "        line_x = retrive_info_from_list(lambda a : a.graph.num_nodes, line_infos)\n",
+    "        plt.plot(line_x, line_y, marker='o', color=colors[i])\n",
+    "    #graph.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Retrieve information from a list "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def retrive_info_from_list(selector, distances):\n",
+    "    return list(map(selector, distances))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Read Models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "human = GraphCollection('../statistics/humanOutput/', 300, 'Human', True)\n",
+    "file_names = reader.readmultiplefiles('../statistics/viatraEvolve/', 1000, False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Calculate Distances"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Progress Widge\n",
+    "w2 = widgets.FloatProgress(\n",
+    "    value=0,\n",
+    "    min=0,\n",
+    "    max=1.0,\n",
+    "    step=0.1,\n",
+    "    description='Loading Files...:',\n",
+    "    bar_style='info',\n",
+    "    orientation='horizontal'\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ca7932bce2a741afaff6b919042c42b0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "FloatProgress(value=0.0, bar_style='info', description='Loading Files...:', max=1.0)"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "infos = []\n",
+    "# read all files\n",
+    "counter = 0.0\n",
+    "size = len(file_names)\n",
+    "#display progress bar\n",
+    "display(w2)\n",
+    "for name in file_names:\n",
+    "    infos.append(GraphStat(name))\n",
+    "\n",
+    "info_dic = {}\n",
+    "for info in infos:\n",
+    "    w2.value = (counter/size)\n",
+    "    counter+=1\n",
+    "    info = GraphDistance(info, human)\n",
+    "    info_dic[info.graph.id] = info"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Plot Graphs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* widget for select trajectory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filenames = reader.readmultiplefiles('../statistics/trajectories/', 10, False)\n",
+    "trajectories = {}\n",
+    "for name in filenames:\n",
+    "    trajectories[name] = reader.readTrajectory(name)\n",
+    "\n",
+    "w = widgets.SelectMultiple(\n",
+    "    options = trajectories,\n",
+    "    value = [trajectories[filenames[0]]],\n",
+    "    description='Trajectory:',\n",
+    "    disabled=False,\n",
+    ")\n",
+    "\n",
+    "#generate random color for each line\n",
+    "colors = []\n",
+    "\n",
+    "for i in range(0, len(trajectories)):\n",
+    "    color = \"#%06x\" % random.randint(0, 0xFFFFFF)\n",
+    "    colors.append(color)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Out Degree"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "08da62cb0c3f4e6e9591c7dc811d27cc",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', index=(1,), options={'../statistics/trajectori…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_out_degree(lines)>"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_out_degree(lines):\n",
+    "    plot(info_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out degree')\n",
+    "interact(plot_out_degree, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Node Activity"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a708f43645a24bd2b15b53ea12c7d88f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', index=(1,), options={'../statistics/trajectori…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_na(lines)>"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_na(lines):\n",
+    "    plot(info_dic, lines, 0, lambda a: a.na_distance, colors, 'node activity')\n",
+    "interact(plot_na, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### MPC"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "124a0cb0ebfb4225bf4ced24c09032f7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', index=(1,), options={'../statistics/trajectori…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_out_degree(lines)>"
+      ]
+     },
+     "execution_count": 65,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_out_degree(lines):\n",
+    "    plot(info_dic, lines, 0, lambda a: a.mpc_distance, colors, 'MPC')\n",
+    "interact(plot_out_degree, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for name in file_names:\n",
+    "    contents = reader.readcsvfile(name)\n",
+    "    if(contents['State Id'][0] == 1032396643):\n",
+    "        print(name)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "metadata": {
+     "collapsed": false
+    },
+    "source": []
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/src/metrics_distance_with_selector.ipynb b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/src/metrics_distance_with_selector.ipynb
new file mode 100644
index 00000000..4c7fecb3
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/src/metrics_distance_with_selector.ipynb
@@ -0,0 +1,955 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Measuremments with Representative"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os, sys\n",
+    "lib_path = os.path.abspath(os.path.join('..', '..', 'utils'))\n",
+    "sys.path.append(lib_path)\n",
+    "from GraphType import GraphStat\n",
+    "from GraphType import GraphCollection\n",
+    "from scipy import stats\n",
+    "from ipywidgets import interact, fixed, interactive\n",
+    "import readCSV as reader\n",
+    "import ipywidgets as widgets\n",
+    "import matplotlib.pyplot as plt\n",
+    "import random\n",
+    "import numpy as np\n",
+    "import constants\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Classes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Record the distances of different metrics using a representative"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GraphDistanceWithRep:\n",
+    "    #init with a graph stat and a collection of graph stats\n",
+    "    def __init__(self, graphStat, rep):\n",
+    "        self.graph = graphStat\n",
+    "        self.rep = rep\n",
+    "        self.out_d_distance, _ = stats.ks_2samp(graphStat.out_d, rep.out_d)\n",
+    "        self.na_distance,_ = stats.ks_2samp(graphStat.na, rep.na)\n",
+    "        self.mpc_distance,_ = stats.ks_2samp(graphStat.mpc, rep.mpc)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Methods\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Find the median ks distance of the same number of nodes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def find_median(x, metric_distances):\n",
+    "    distance_dic = {}\n",
+    "    for index, num_of_nodes in enumerate(x):\n",
+    "        if num_of_nodes[0] not in distance_dic:\n",
+    "            distance_dic[num_of_nodes[0]] = []\n",
+    "        distance_dic[num_of_nodes[0]].append(metric_distances[index])\n",
+    "    median_x = []\n",
+    "    y = []\n",
+    "    for num_of_nodes, distances in distance_dic.items():\n",
+    "        median_x.append(num_of_nodes)\n",
+    "        y.append(np.median(distances))\n",
+    "    order = np.argsort(median_x)\n",
+    "    median_x = np.array(median_x)[order]\n",
+    "    median_y = np.array(y)[order]\n",
+    "    return median_x, median_y\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Plot Diagram"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# metric_selector: GraphDistance -> float\n",
+    "def plot(infos, lines, id, metric_selector,colors, title, foldername):\n",
+    "    metric_distances = retrive_info_from_list(metric_selector, list(infos.values()))\n",
+    "    x = retrive_info_from_list(lambda a : a.graph.num_nodes, list(infos.values()))\n",
+    "    graph = plt.figure(id,figsize=(18, 10))\n",
+    "    plt.title(title)\n",
+    "    plt.plot(x, metric_distances, color='red', linestyle='', marker='o',alpha=0.7)\n",
+    "    #plot ks distance median\n",
+    "    median_x, median_y = find_median(x, metric_distances)\n",
+    "    plt.plot(median_x, median_y, color='black',marker='o')\n",
+    "    for i in range(0, len(lines)):\n",
+    "        line_infos = retrive_info_from_list(lambda a: infos[a], lines[i])\n",
+    "        line_y = retrive_info_from_list(metric_selector, line_infos)\n",
+    "        line_x = retrive_info_from_list(lambda a : a.graph.num_nodes, line_infos)\n",
+    "        plt.plot(line_x, line_y, marker='o', color=colors[i])\n",
+    "    mkdir_p(foldername)\n",
+    "    plt.savefig(fname = foldername+title+'.jpg', dpi=150)\n",
+    "    #graph.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Retrieve information from a list "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def retrive_info_from_list(selector, distances):\n",
+    "    return list(map(selector, distances))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def readStats(path, numModels):\n",
+    "    names =  reader.readmultiplefiles(path, numModels, False)\n",
+    "    stats = []\n",
+    "    for name in names:\n",
+    "        stats.append(GraphStat(name))\n",
+    "    return stats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calDistanceDic(stats, rep):\n",
+    "    dic = {}\n",
+    "    for info in stats:\n",
+    "        info = GraphDistanceWithRep(info, rep)\n",
+    "        dic[info.graph.id] = info\n",
+    "    return dic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def createRandomColors(size):\n",
+    "    #generate random color for each line\n",
+    "    colors = []\n",
+    "\n",
+    "    for i in range(0, size):\n",
+    "        color = \"#%06x\" % random.randint(0, 0xFFFFFF)\n",
+    "        colors.append(color)\n",
+    "    return colors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def createSelectionWidge(options):\n",
+    "    w = widgets.SelectMultiple(\n",
+    "        options = options,\n",
+    "        value = [],\n",
+    "        description='Trajectory:',\n",
+    "        disabled=False,\n",
+    "    )\n",
+    "    return w"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def mkdir_p(mypath):\n",
+    "    '''Creates a directory. equivalent to using mkdir -p on the command line'''\n",
+    "\n",
+    "    from errno import EEXIST\n",
+    "    from os import makedirs,path\n",
+    "\n",
+    "    try:\n",
+    "        makedirs(mypath)\n",
+    "    except OSError as exc: # Python >2.5\n",
+    "        if exc.errno == EEXIST and path.isdir(mypath):\n",
+    "            pass\n",
+    "        else: raise"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Metrics During GenerationPlots"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Read Human Representatives"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Read Models\n",
+    "#read representative\n",
+    "human_rep = GraphStat(constants.HUMAN_OUT_D_REP)\n",
+    "human_na = GraphStat(constants.HUMAN_NA_REP)\n",
+    "human_mpc = GraphStat(constants.HUMAN_MPC_REP)\n",
+    "\n",
+    "# assign rep distributions to human_rep\n",
+    "human_rep.na = human_na.na\n",
+    "human_rep.mpc = human_mpc.mpc"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Viatra No Constraint"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Read generated models\n",
+    "viatra_no_con_stats = readStats('../input/viatra_nocon_output/', 5000)\n",
+    "viatra_no_con_dic = calDistanceDic(viatra_no_con_stats, human_rep)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filenames = reader.readmultiplefiles('../input/viatra_nocon_output/trajectories/', 15, False)\n",
+    "trajectories = {}\n",
+    "for name in filenames:\n",
+    "    trajectories[name] = reader.readTrajectory(name)\n",
+    "w = createSelectionWidge(trajectories)\n",
+    "colors = createRandomColors(len(trajectories))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9519be563fbc41c28921c77ef6481b17",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_out_degree(lines)>"
+      ]
+     },
+     "execution_count": 77,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_out_degree(lines):\n",
+    "    plot(viatra_no_con_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out degree', '../output/viatra_no_constraints/')\n",
+    "interact(plot_out_degree, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c896725e542c4bf8a1bc76ba66819b20",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_out_na(lines)>"
+      ]
+     },
+     "execution_count": 78,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_out_na(lines):\n",
+    "    plot(viatra_no_con_dic, lines, 0, lambda a: a.na_distance, colors, 'node activity', '../output/viatra_no_constraints/')\n",
+    "interact(plot_out_na, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "880410d675624545ab73977a463bb5c9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_out_mpc(lines)>"
+      ]
+     },
+     "execution_count": 79,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_out_mpc(lines):\n",
+    "    plot(viatra_no_con_dic, lines, 0, lambda a: a.mpc_distance, colors, 'MPC', '../output/viatra_no_constraints/')\n",
+    "interact(plot_out_mpc, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Viatra with constraints"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "viatra_con_stats = readStats('../input/viatra_con_output/',5000)\n",
+    "viatra_con_dic = calDistanceDic(viatra_con_stats, human_rep)\n",
+    "\n",
+    "# trajectories and colors\n",
+    "trajectories = {}\n",
+    "w = createSelectionWidge(trajectories)\n",
+    "colors = createRandomColors(len(trajectories))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0d04d6db770a49f4a160ff55cc7131f6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_out_degree(lines)>"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_out_degree(lines):\n",
+    "    plot(viatra_con_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out degree', '../output/viatra_constraints/')\n",
+    "interact(plot_out_degree, lines=[[]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "96eebad1f6274d79ad377c8c54b44615",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_na(lines)>"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_na(lines):\n",
+    "    plot(viatra_con_dic, lines, 0, lambda a: a.na_distance, colors, 'node activity', '../output/viatra_constraints/')\n",
+    "interact(plot_na, lines=[[]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4fc2714a3cd3440daf5014bb4b942b9a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_mpc(lines)>"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_mpc(lines):\n",
+    "    plot(viatra_con_dic, lines, 0, lambda a: a.mpc_distance, colors, 'MPC', '../output/viatra_constraints/')\n",
+    "interact(plot_mpc, lines=[[]])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Controlled RandomEMF"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "random_emf_stats = readStats('../input/random_emf_output/',5000)\n",
+    "random_emf_dic = calDistanceDic(random_emf_stats, human_rep)\n",
+    "\n",
+    "# trajectories and colors\n",
+    "trajectories = {}\n",
+    "w = createSelectionWidge(trajectories)\n",
+    "colors = createRandomColors(len(trajectories))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "4401931533b5497f864f146d7b4dcd3c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_out_degree(lines)>"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_out_degree(lines):\n",
+    "    plot(random_emf_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out degree', '../output/random_emf/')\n",
+    "interact(plot_out_degree, lines=[[]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "fb7bdedff841420bb8f817013f565020",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_node_activity(lines)>"
+      ]
+     },
+     "execution_count": 61,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_node_activity(lines):\n",
+    "    plot(random_emf_dic, lines, 0, lambda a: a.na_distance, colors, 'node activity', '../output/random_emf/')\n",
+    "interact(plot_node_activity, lines=[[]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6b0c349c4a3b4813825513f739ea30da",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(Dropdown(description='lines', options=([],), value=[]), Output()), _dom_classes=('widget…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_mpc(lines)>"
+      ]
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_mpc(lines):\n",
+    "    plot(random_emf_dic, lines, 0, lambda a: a.mpc_distance, colors, 'mpc', '../output/random_emf/')\n",
+    "interact(plot_mpc, lines=[[]])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Controlled Viatra with MPC"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "con_viatra_stats = readStats('../input/controled_viatra_mpc/',5000)\n",
+    "con_viatra_dic = calDistanceDic(con_viatra_stats, human_rep)\n",
+    "\n",
+    "# trajectories and colors\n",
+    "trajectories = {}\n",
+    "w = createSelectionWidge(trajectories)\n",
+    "colors = createRandomColors(len(trajectories))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b76901ba9d44433984032e0dc5679fa9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_out_degree(lines)>"
+      ]
+     },
+     "execution_count": 74,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_out_degree(lines):\n",
+    "    plot(con_viatra_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out_degree', '../output/controled_viatra_with_mpc/')\n",
+    "interact(plot_out_degree, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9e0d61e29b02467cb52618860a1bde7f",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_na(lines)>"
+      ]
+     },
+     "execution_count": 75,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_na(lines):\n",
+    "    plot(con_viatra_dic, lines, 0, lambda a: a.na_distance, colors, 'Node Activity', '../output/controled_viatra_with_mpc/')\n",
+    "interact(plot_na, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "70074805fee44a1aa5b9ccb3770b5c0c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_mpc(lines)>"
+      ]
+     },
+     "execution_count": 76,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_mpc(lines):\n",
+    "    plot(con_viatra_dic, lines, 0, lambda a: a.mpc_distance, colors, 'mpc', '../output/controled_viatra_with_mpc/')\n",
+    "interact(plot_mpc, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## (Pseudo) Random EMF instantiator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "random_emf_stats = readStats('../input/real_random_output/',5000)\n",
+    "random_emf_dic = calDistanceDic(random_emf_stats, human_rep)\n",
+    "\n",
+    "# trajectories and colors\n",
+    "trajectories = {}\n",
+    "w = createSelectionWidge(trajectories)\n",
+    "colors = createRandomColors(len(trajectories))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "912ba2fdfd7c46848065f174aa6177e0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_out_degree(lines)>"
+      ]
+     },
+     "execution_count": 82,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_out_degree(lines):\n",
+    "    plot(random_emf_dic, lines, 0, lambda a: a.out_d_distance, colors, 'out_degree', '../output/random_emf_instantiator/')\n",
+    "interact(plot_out_degree, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0ba621dd0e7d4957aaff2cf209bba165",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_na(lines)>"
+      ]
+     },
+     "execution_count": 83,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_na(lines):\n",
+    "    plot(random_emf_dic, lines, 0, lambda a: a.na_distance, colors, 'Node Activity', '../output/random_emf_instantiator/')\n",
+    "interact(plot_na, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 84,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d432bbae1c6f48c3acd1767f2e2b13c7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(SelectMultiple(description='Trajectory:', options={}, value=()), Output()), _dom_classes…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.plot_mpc(lines)>"
+      ]
+     },
+     "execution_count": 84,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def plot_mpc(lines):\n",
+    "    plot(random_emf_dic, lines, 0, lambda a: a.mpc_distance, colors, 'mpc', '../output/random_emf_instantiator/')\n",
+    "interact(plot_mpc, lines=w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/src/representative_selector .ipynb b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/src/representative_selector .ipynb
new file mode 100644
index 00000000..9653b2a0
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/model_evolve_comparison/src/representative_selector .ipynb
@@ -0,0 +1,336 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Use K-medoid algorithm to find the suitable human model representitives"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os, sys\n",
+    "lib_path = os.path.abspath(os.path.join('..', '..', 'utils'))\n",
+    "sys.path.append(lib_path)\n",
+    "from GraphType import GraphStat\n",
+    "import readCSV as reader\n",
+    "from scipy import stats\n",
+    "from ipywidgets import interact, fixed, interactive\n",
+    "import ipywidgets as widgets\n",
+    "from pyclustering.cluster.kmedoids import kmedoids\n",
+    "from pyclustering.utils.metric import distance_metric, type_metric\n",
+    "import random"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Define a new distance metric"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def ks_value(dest1, dest2):\n",
+    "    value, p = stats.ks_2samp(dest1, dest2)\n",
+    "    return value\n",
+    "\n",
+    "\n",
+    "ks_metric = distance_metric(type_metric.USER_DEFINED, func=ks_value)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Read Human Models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1253"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Progress Widge\n",
+    "w = widgets.FloatProgress(\n",
+    "    value=0,\n",
+    "    min=0,\n",
+    "    max=1.0,\n",
+    "    step=0.1,\n",
+    "    description='Loading Files...:',\n",
+    "    bar_style='info',\n",
+    "    orientation='horizontal'\n",
+    ")\n",
+    "\n",
+    "\n",
+    "humanFiles = reader.readmultiplefiles('../input/humanOutput/', 1300, False)\n",
+    "modelToFileName = {}\n",
+    "for name in humanFiles:\n",
+    "    modelToFileName[GraphStat(name)] = name\n",
+    "\n",
+    "models = list(modelToFileName.keys())\n",
+    "len(humanFiles)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Find Representative by K-medroid for different dists on GraphStat"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Returns the index of the representative"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def findRep(graphStats, func):\n",
+    "    out_ds = list(map(func, models))\n",
+    "\n",
+    "    #choose a random starting point\n",
+    "    start_index = random.randint(0, len(out_ds))\n",
+    "\n",
+    "    # start with one initial metrid [start_index]\n",
+    "    outdegree_kmedoid = kmedoids(out_ds, [start_index], metric=ks_metric)\n",
+    "\n",
+    "    outdegree_kmedoid.process()\n",
+    "    centoids = outdegree_kmedoid.get_medoids()\n",
+    "    return centoids[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Find representative for out degree"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* the rep found is ../input/humanOutput\\R_20158_run_1.csv\n",
+    "* the average distance between it and others is 0.05515988287586802"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "../input/humanOutput\\R_20158_run_1.csv\n",
+      "../input/humanOutput\\R_20158_run_1.csv\n"
+     ]
+    }
+   ],
+   "source": [
+    "od_rep_index = findRep(models, lambda m: m.out_d)\n",
+    "print(list(modelToFileName.values())[od_rep_index])\n",
+    "od_rep_model = models[od_rep_index]\n",
+    "print(modelToFileName[od_rep_model])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.05515988287586802\n"
+     ]
+    }
+   ],
+   "source": [
+    "total_distance = 0\n",
+    "count = 0\n",
+    "for model in models:\n",
+    "    total_distance += ks_value(od_rep_model.out_d, model.out_d)\n",
+    "print(total_distance / len(models))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Find Representative for node activities"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* the rep found is ../input/humanOutput\\R_2016176_run_1.csv\n",
+    "* the average distance between it and others is 0.05275267434589047"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "../input/humanOutput\\R_2016176_run_1.csv\n",
+      "../input/humanOutput\\R_2016176_run_1.csv\n"
+     ]
+    }
+   ],
+   "source": [
+    "total_distance = 0\n",
+    "for model in models:\n",
+    "    total_distance += ks_value(od_rep_model.mpc, model.mpc)\n",
+    "print(total_distance / len(models))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.05275267434589047\n"
+     ]
+    }
+   ],
+   "source": [
+    "total_distance = 0\n",
+    "count = 0\n",
+    "for model in models:\n",
+    "    total_distance += ks_value(od_rep_model.na, model.na)\n",
+    "print(total_distance / len(models))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Find Representative for MPC"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* the rep found is ../input/humanOutput\\R_2015246_run_1.csv\n",
+    "* the average distance between it and others is 0.08556632702185384"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "../input/humanOutput\\R_2015246_run_1.csv\n",
+      "../input/humanOutput\\R_2015246_run_1.csv\n"
+     ]
+    }
+   ],
+   "source": [
+    "mpc_rep_index = findRep(models, lambda m: m.mpc)\n",
+    "print(list(modelToFileName.values())[mpc_rep_index])\n",
+    "mpc_rep_model = models[mpc_rep_index]\n",
+    "print(modelToFileName[mpc_rep_model])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.08556632702185384\n"
+     ]
+    }
+   ],
+   "source": [
+    "total_distance = 0\n",
+    "count = 0\n",
+    "for model in models:\n",
+    "    total_distance += ks_value(od_rep_model.mpc, model.mpc)\n",
+    "print(total_distance / len(models))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
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..13754e80
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/utils/GraphType.py
@@ -0,0 +1,29 @@
+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.name = name
+        models = reader.readmultiplefiles(path, number, shouldShuffle)
+        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)
+        print(len(self.out_ds))
+
+#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.num_nodes = np.array(contents[constants.NUMBER_NODES])
+        if constants.STATE_ID in contents:
+            self.id = (contents[constants.STATE_ID])[0]
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..ce9d4255
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/utils/constants.py
@@ -0,0 +1,25 @@
+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'
+
+HUMAN_OUT_D_REP = '../input/humanOutput/R_20158_run_1.csv'
+
+HUMAN_MPC_REP = '../input/humanOutput/R_2015246_run_1.csv'
+
+HUMAN_NA_REP = '../input/humanOutput/R_2016176_run_1.csv'
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..e0402519
--- /dev/null
+++ b/Metrics/Metrics-Calculation/metrics_plot/utils/readCSV.py
@@ -0,0 +1,169 @@
+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:
+        for i, line in enumerate(f):
+            arr = line.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:]
+            # all other contants are integer
+            else:
+                contents[arr[0]] = list(map(int, arr[1:]))
+    f.close()
+    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])
+    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()
+