12 files changed, 599 insertions, 0 deletions

diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.EMFGraph.java._trace b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.EMFGraph.java._trace
new file mode 100644
index 00000000..6e2ea420
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.EMFGraph.java._trace
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.EMFGraph.xtendbin b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.EMFGraph.xtendbin
new file mode 100644
index 00000000..e949bb11
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.EMFGraph.xtendbin
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.Graph.java._trace b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.Graph.java._trace
new file mode 100644
index 00000000..e1d021fd
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.Graph.java._trace
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.Graph.xtendbin b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.Graph.xtendbin
new file mode 100644
index 00000000..547fdc38
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.Graph.xtendbin
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.GraphStatistic.java._trace b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.GraphStatistic.java._trace
new file mode 100644
index 00000000..5928ed9d
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.GraphStatistic.java._trace
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.GraphStatistic.xtendbin b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.GraphStatistic.xtendbin
new file mode 100644
index 00000000..e9269f16
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.GraphStatistic.xtendbin
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.PartialInterpretationGraph.java._trace b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.PartialInterpretationGraph.java._trace
new file mode 100644
index 00000000..f19eb46c
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.PartialInterpretationGraph.java._trace
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.PartialInterpretationGraph.xtendbin b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.PartialInterpretationGraph.xtendbin
new file mode 100644
index 00000000..c634ef10
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/.PartialInterpretationGraph.xtendbin
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.java
new file mode 100644
index 00000000..8a9aa8d3
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/EMFGraph.java
@@ -0,0 +1,140 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph;
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.Graph;
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatistic;
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.xtend.lib.annotations.AccessorType;
+import org.eclipse.xtend.lib.annotations.Accessors;
+import org.eclipse.xtext.xbase.lib.IteratorExtensions;
+import org.eclipse.xtext.xbase.lib.Pure;
+
+@SuppressWarnings("all")
+public class EMFGraph extends Graph {
+  @Accessors(AccessorType.PUBLIC_GETTER)
+  private EObject root;
+  
+  public void init(final EObject root, final List<Metric> metrics, final String name, final List<EReference> referenceTypes) {
+    final List<EObject> otherContents = IteratorExtensions.<EObject>toList(root.eAllContents());
+    this.root = root;
+    otherContents.add(root);
+    this.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
+   */
+  public void init(final List<EObject> objects, final List<Metric> metrics, final String name, final List<EReference> referenceTypes) {
+    final Consumer<EObject> _function = (EObject it) -> {
+      HashSet<String> types = new HashSet<String>();
+      types.add(it.eClass().getName());
+      this.statistic.addNodeWithAllTypes(it, types);
+    };
+    objects.forEach(_function);
+    final Consumer<EReference> _function_1 = (EReference it) -> {
+      boolean _isDerived = it.isDerived();
+      boolean _not = (!_isDerived);
+      if (_not) {
+        this.statistic.addEdgeType(it.getName());
+      }
+    };
+    referenceTypes.forEach(_function_1);
+    final Consumer<EObject> _function_2 = (EObject source) -> {
+      final Consumer<EReference> _function_3 = (EReference r) -> {
+        boolean _isMany = r.isMany();
+        if (_isMany) {
+          final Consumer<EObject> _function_4 = (EObject target) -> {
+            this.addEdge(source, target, r);
+          };
+          this.getNeighbours(source, r).forEach(_function_4);
+        } else {
+          Object _eGet = source.eGet(r);
+          final EObject target = ((EObject) _eGet);
+          this.addEdge(source, target, r);
+        }
+      };
+      source.eClass().getEAllReferences().forEach(_function_3);
+    };
+    objects.forEach(_function_2);
+    this.metrics = metrics;
+    this.name = name;
+  }
+  
+  public void removeReference(final EReference r) {
+    boolean _containsEdgeType = this.statistic.containsEdgeType(r.getName());
+    if (_containsEdgeType) {
+      this.statistic.removeReference(r.getName(), r.isContainment());
+    }
+  }
+  
+  /**
+   * Set basic information for the output
+   */
+  @Override
+  public void setBasicInformation(final ArrayList<ArrayList<String>> output) {
+    final ArrayList<String> metaInfo = new ArrayList<String>();
+    metaInfo.add(Graph.META_MODEL_HEADER);
+    metaInfo.add(this.metaModel);
+    final ArrayList<String> edgeInfo = new ArrayList<String>();
+    edgeInfo.add(Graph.NUM_EDGE_TYPE_HEADER);
+    int _size = this.statistic.getAllTypes().size();
+    String _plus = (Integer.valueOf(_size) + "");
+    edgeInfo.add(_plus);
+    final ArrayList<String> nodeInfo = new ArrayList<String>();
+    nodeInfo.add(Graph.NUM_NODE_HEADER);
+    int _size_1 = this.statistic.getAllNodes().size();
+    String _plus_1 = (Integer.valueOf(_size_1) + "");
+    nodeInfo.add(_plus_1);
+    final ArrayList<String> stateInfo = new ArrayList<String>();
+    stateInfo.add(Graph.STATE_ID_HEADER);
+    stateInfo.add(this.name);
+    output.add(metaInfo);
+    output.add(edgeInfo);
+    output.add(nodeInfo);
+    output.add(stateInfo);
+  }
+  
+  public EList<EObject> getNeighbours(final EObject o, final EReference r) {
+    Object _eGet = o.eGet(r, true);
+    return ((EList<EObject>) _eGet);
+  }
+  
+  public void addEdge(final EObject source, final EObject target, final EReference r) {
+    if ((((target != null) && (r != null)) && (!r.isDerived()))) {
+      this.statistic.addEdge(source, target, r.getName());
+    }
+  }
+  
+  @Override
+  public GraphStatistic getStatistic() {
+    return this.statistic;
+  }
+  
+  @Override
+  public String getName() {
+    return this.name;
+  }
+  
+  public void setMetaModel(final String model) {
+    this.metaModel = model;
+  }
+  
+  public String getMetaModel() {
+    return this.metaModel;
+  }
+  
+  @Pure
+  public EObject getRoot() {
+    return this.root;
+  }
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.java
new file mode 100644
index 00000000..f9923a63
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/Graph.java
@@ -0,0 +1,96 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph;
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatistic;
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.EdgeTypeMetric;
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric;
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup;
+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.NodeTypeMetric;
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric;
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.TypedOutDegree;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import org.eclipse.xtext.xbase.lib.Conversions;
+
+@SuppressWarnings("all")
+public abstract class Graph {
+  protected final static String META_MODEL_HEADER = "Meta Mode";
+  
+  protected final static String NUM_NODE_HEADER = "Number Of Nodes";
+  
+  protected final static String NUM_EDGE_TYPE_HEADER = "Number of Edge types";
+  
+  protected final static String STATE_ID_HEADER = "State Id";
+  
+  protected final GraphStatistic statistic = new GraphStatistic();
+  
+  protected List<Metric> metrics;
+  
+  protected String name = "";
+  
+  protected String metaModel = "";
+  
+  /**
+   * evaluate all metrics for this model
+   * return the result as a two dimentional list
+   */
+  public ArrayList<ArrayList<String>> evaluateAllMetrics() {
+    final ArrayList<ArrayList<String>> result = new ArrayList<ArrayList<String>>();
+    this.setBasicInformation(result);
+    for (final Metric metric : this.metrics) {
+      {
+        final String[][] datas = metric.evaluate(this.statistic);
+        for (final String[] row : datas) {
+          ArrayList<String> _arrayList = new ArrayList<String>((Collection<? extends String>)Conversions.doWrapArray(row));
+          result.add(_arrayList);
+        }
+      }
+    }
+    return result;
+  }
+  
+  public MetricSampleGroup evaluateAllMetricsToSamples() {
+    MetricSampleGroup sample = new MetricSampleGroup();
+    for (final Metric metric : this.metrics) {
+      if ((metric instanceof MultiplexParticipationCoefficientMetric)) {
+        Object _evaluateSamples = ((MultiplexParticipationCoefficientMetric)metric).evaluateSamples(this.statistic);
+        sample.mpcSamples = ((ArrayList<Double>) _evaluateSamples);
+      } else {
+        if ((metric instanceof NodeActivityMetric)) {
+          Object _evaluateSamples_1 = ((NodeActivityMetric)metric).evaluateSamples(this.statistic);
+          sample.naSamples = ((ArrayList<Double>) _evaluateSamples_1);
+        } else {
+          if ((metric instanceof OutDegreeMetric)) {
+            Object _evaluateSamples_2 = ((OutDegreeMetric)metric).evaluateSamples(this.statistic);
+            sample.outDegreeSamples = ((ArrayList<Double>) _evaluateSamples_2);
+          } else {
+            if ((metric instanceof TypedOutDegree)) {
+              Object _evaluateSamples_3 = ((TypedOutDegree)metric).evaluateSamples(this.statistic);
+              sample.typedOutDegreeSamples = ((HashMap<String, List<Integer>>) _evaluateSamples_3);
+            } else {
+              if ((metric instanceof NodeTypeMetric)) {
+                Object _evaluateSamples_4 = ((NodeTypeMetric)metric).evaluateSamples(this.statistic);
+                sample.nodeTypeSamples = ((HashMap<String, Double>) _evaluateSamples_4);
+              } else {
+                if ((metric instanceof EdgeTypeMetric)) {
+                  Object _evaluateSamples_5 = ((EdgeTypeMetric)metric).evaluateSamples(this.statistic);
+                  sample.edgeTypeSamples = ((HashMap<String, Double>) _evaluateSamples_5);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return sample;
+  }
+  
+  public abstract void setBasicInformation(final ArrayList<ArrayList<String>> result);
+  
+  public abstract GraphStatistic getStatistic();
+  
+  public abstract String getName();
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.java
new file mode 100644
index 00000000..7bd1d899
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/GraphStatistic.java
@@ -0,0 +1,201 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph;
+
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Multimap;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class GraphStatistic {
+  private final HashMap<String, Multimap<EObject, EObject>> incomingEdges = new HashMap<String, Multimap<EObject, EObject>>();
+  
+  private final HashMap<String, Multimap<EObject, EObject>> outgoingEdges = new HashMap<String, Multimap<EObject, EObject>>();
+  
+  private final HashSet<String> edgeTypes = new HashSet<String>();
+  
+  private final HashMap<EObject, Set<String>> nodeToType = new HashMap<EObject, Set<String>>();
+  
+  /**
+   * Add an edge type to to the graph
+   * @param type: type to add
+   */
+  public void addEdgeType(final String type) {
+    boolean _contains = this.edgeTypes.contains(type);
+    if (_contains) {
+      return;
+    }
+    this.edgeTypes.add(type);
+    this.incomingEdges.put(type, ArrayListMultimap.<EObject, EObject>create());
+    this.outgoingEdges.put(type, ArrayListMultimap.<EObject, EObject>create());
+  }
+  
+  /**
+   * Add a node to the graph with one type in its type hierarchy
+   * @param node: node to add
+   */
+  public void addNodeWithType(final EObject n, final String Type) {
+    HashSet<String> _hashSet = new HashSet<String>();
+    Set<String> types = this.nodeToType.getOrDefault(n, _hashSet);
+    types.add(Type);
+    this.nodeToType.put(n, types);
+  }
+  
+  public boolean containsNode(final EObject o) {
+    return this.nodeToType.containsKey(o);
+  }
+  
+  public Set<String> getTypesForNode(final EObject o) {
+    HashSet<String> _hashSet = new HashSet<String>();
+    return this.nodeToType.getOrDefault(o, _hashSet);
+  }
+  
+  public void overwriteCurrentType(final EObject o, final String type) {
+    HashSet<String> _hashSet = new HashSet<String>();
+    Set<String> typeSet = this.nodeToType.getOrDefault(o, _hashSet);
+    typeSet.clear();
+    typeSet.add(type);
+    this.nodeToType.put(o, typeSet);
+  }
+  
+  /**
+   * Add a node to the graph with all types in its type hierarchy
+   */
+  public void addNodeWithAllTypes(final EObject n, final Set<String> types) {
+    this.nodeToType.put(n, types);
+  }
+  
+  /**
+   * Add an edge to the graph
+   * @param source: source node
+   * @param target: target node
+   * @param type: type of the reference
+   */
+  public void addEdge(final EObject source, final EObject target, final String type) {
+    this.outgoingEdges.get(type).put(source, target);
+    this.incomingEdges.get(type).put(target, source);
+  }
+  
+  /**
+   * check if this graph contains a specific edge type
+   */
+  public boolean containsEdgeType(final String typeName) {
+    if ((this.outgoingEdges.containsKey(typeName) && this.incomingEdges.containsKey(typeName))) {
+      return true;
+    }
+    return false;
+  }
+  
+  /**
+   * remove references from the statistics, potentially remove the nodes associated with it
+   * @Param name: name of the reference
+   * @Param isContainment: if true then the corresponding nodes on the incoming side will also be removed
+   */
+  public void removeReference(final String name, final boolean isContainment) {
+    boolean _contains = this.edgeTypes.contains(name);
+    boolean _not = (!_contains);
+    if (_not) {
+      return;
+    }
+    this.edgeTypes.remove(name);
+    Multimap<EObject, EObject> incomingSet = this.incomingEdges.remove(name);
+    this.outgoingEdges.remove(name);
+    if ((!isContainment)) {
+      return;
+    }
+    final Set<EObject> nodesToRemove = incomingSet.keySet();
+    final Consumer<EObject> _function = (EObject it) -> {
+      this.nodeToType.remove(it);
+    };
+    nodesToRemove.forEach(_function);
+    final Procedure1<Multimap<EObject, EObject>> _function_1 = (Multimap<EObject, EObject> refMap) -> {
+      final Consumer<EObject> _function_2 = (EObject it) -> {
+        refMap.removeAll(it);
+      };
+      nodesToRemove.forEach(_function_2);
+      Collection<EObject> values = refMap.values();
+      values.removeAll(nodesToRemove);
+      return;
+    };
+    final Procedure1<Multimap<EObject, EObject>> removeForMultimap = _function_1;
+    IterableExtensions.<Multimap<EObject, EObject>>forEach(this.incomingEdges.values(), removeForMultimap);
+    IterableExtensions.<Multimap<EObject, EObject>>forEach(this.outgoingEdges.values(), removeForMultimap);
+  }
+  
+  /**
+   * calculate the out degree for an object
+   */
+  public int outDegree(final EObject o) {
+    int count = 0;
+    for (final String type : this.edgeTypes) {
+      int _count = count;
+      int _size = this.outgoingEdges.get(type).get(o).size();
+      count = (_count + _size);
+    }
+    return count;
+  }
+  
+  /**
+   * calculate the in degree of an object
+   */
+  public int inDegree(final EObject o) {
+    int count = 0;
+    for (final String type : this.edgeTypes) {
+      int _count = count;
+      int _size = this.incomingEdges.get(type).get(o).size();
+      count = (_count + _size);
+    }
+    return count;
+  }
+  
+  /**
+   * calculate the dimentional degree of a node
+   */
+  public int dimentionalDegree(final EObject o, final String type) {
+    int _size = this.incomingEdges.get(type).get(o).size();
+    int _size_1 = this.outgoingEdges.get(type).get(o).size();
+    return (_size + _size_1);
+  }
+  
+  /**
+   * calculate the number of edge types for a given node.
+   */
+  public int numOfEdgeTypes(final EObject o) {
+    int count = 0;
+    for (final String type : this.edgeTypes) {
+      int _dimentionalDegree = this.dimentionalDegree(o, type);
+      boolean _greaterThan = (_dimentionalDegree > 0);
+      if (_greaterThan) {
+        count++;
+      }
+    }
+    return count;
+  }
+  
+  public List<String> getAllTypes() {
+    return IterableExtensions.<String>toList(this.edgeTypes);
+  }
+  
+  public Map<EObject, Set<String>> getNodeToTypesMap() {
+    return this.nodeToType;
+  }
+  
+  public List<EObject> getAllNodes() {
+    return IterableExtensions.<EObject>toList(this.nodeToType.keySet());
+  }
+  
+  public HashMap<String, Multimap<EObject, EObject>> getOutgoingEdges() {
+    return this.outgoingEdges;
+  }
+  
+  public HashMap<String, Multimap<EObject, EObject>> incomingEdges() {
+    return this.incomingEdges;
+  }
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.java
new file mode 100644
index 00000000..83bb92ca
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/xtend-gen/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/graph/PartialInterpretationGraph.java
@@ -0,0 +1,162 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph;
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.Graph;
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.GraphStatistic;
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric;
+import com.google.common.collect.Iterables;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition;
+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.PartialRelationInterpretation;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.PartialComplexTypeInterpretationImpl;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+
+@SuppressWarnings("all")
+public class PartialInterpretationGraph extends Graph {
+  private final String typeToExclude = "undefinedpart";
+  
+  private final String classSuffix = " class";
+  
+  /**
+   * Define a new PartialInterpretationGraph by parse every element from a PartialInterpretation
+   */
+  public PartialInterpretationGraph(final PartialInterpretation partial, final List<Metric> metrics, final String name) {
+    final Consumer<RelationDeclaration> _function = (RelationDeclaration it) -> {
+      String n = it.getName().split(" ")[0];
+      this.statistic.addEdgeType(n);
+    };
+    Iterables.<RelationDeclaration>filter(partial.getProblem().getRelations(), RelationDeclaration.class).forEach(_function);
+    final Iterable<PartialComplexTypeInterpretationImpl> typeInterpretations = this.getTypes(partial);
+    for (final PartialComplexTypeInterpretationImpl type : typeInterpretations) {
+      boolean _isConcreteType = this.isConcreteType(type.getInterpretationOf());
+      if (_isConcreteType) {
+        String typeName = type.getInterpretationOf().getName().replace(this.classSuffix, "");
+        EList<DefinedElement> _elements = type.getElements();
+        for (final DefinedElement node : _elements) {
+          boolean _containsNode = this.statistic.containsNode(node);
+          boolean _not = (!_containsNode);
+          if (_not) {
+            this.statistic.addNodeWithType(node, typeName);
+          } else {
+            String currentType = ((String[])Conversions.unwrapArray(this.statistic.getTypesForNode(node), String.class))[0];
+            boolean _isSuperType = this.isSuperType(currentType, type.getInterpretationOf());
+            if (_isSuperType) {
+              this.statistic.overwriteCurrentType(node, typeName);
+            }
+          }
+        }
+      }
+    }
+    EList<PartialRelationInterpretation> _partialrelationinterpretation = partial.getPartialrelationinterpretation();
+    for (final PartialRelationInterpretation relationInterpretation : _partialrelationinterpretation) {
+      {
+        final String type_1 = relationInterpretation.getInterpretationOf().getName().split(" ")[0];
+        Iterable<BinaryElementRelationLink> _filter = Iterables.<BinaryElementRelationLink>filter(relationInterpretation.getRelationlinks(), BinaryElementRelationLink.class);
+        for (final BinaryElementRelationLink edge : _filter) {
+          this.statistic.addEdge(edge.getParam1(), edge.getParam2(), type_1);
+        }
+      }
+    }
+    this.name = name;
+    this.metrics = metrics;
+  }
+  
+  /**
+   * recursively check if a type is the super type of another
+   */
+  public boolean isSuperType(final String typeName, final Type subtypeToCheck) {
+    EList<Type> superTypes = subtypeToCheck.getSupertypes();
+    int _size = superTypes.size();
+    boolean _equals = (_size == 0);
+    if (_equals) {
+      return false;
+    } else {
+      final Function1<Type, String> _function = (Type it) -> {
+        return it.getName().replace(this.classSuffix, "");
+      };
+      boolean _contains = ListExtensions.<Type, String>map(subtypeToCheck.getSupertypes(), _function).contains(typeName);
+      if (_contains) {
+        return true;
+      } else {
+        for (final Type superType : superTypes) {
+          boolean _isSuperType = this.isSuperType(typeName, superType);
+          if (_isSuperType) {
+            return true;
+          }
+        }
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Check if a Type object is the class that we want to consider
+   *    A type object is to be considered if it satisfy one of the following:
+   *    1. if it is not abstract
+   *    2. if it is abstract but has a subclass of type TypeDefinition (This means the generation is
+   *       started with nodes in this type)
+   */
+  public boolean isConcreteType(final Type t) {
+    if (((!t.isIsAbstract()) || (IterableExtensions.<Type>findFirst(t.getSubtypes(), ((Function1<Type, Boolean>) (Type it) -> {
+      return Boolean.valueOf((it instanceof TypeDefinition));
+    })) != null))) {
+      return true;
+    }
+    return false;
+  }
+  
+  /**
+   * Set basic information for the output
+   */
+  @Override
+  public void setBasicInformation(final ArrayList<ArrayList<String>> output) {
+    final ArrayList<String> metaInfo = new ArrayList<String>();
+    metaInfo.add(Graph.META_MODEL_HEADER);
+    metaInfo.add(this.metaModel);
+    final ArrayList<String> edgeInfo = new ArrayList<String>();
+    edgeInfo.add(Graph.NUM_EDGE_TYPE_HEADER);
+    int _size = this.statistic.getAllTypes().size();
+    String _plus = (Integer.valueOf(_size) + "");
+    edgeInfo.add(_plus);
+    final ArrayList<String> nodeInfo = new ArrayList<String>();
+    nodeInfo.add(Graph.NUM_NODE_HEADER);
+    int _size_1 = this.statistic.getAllNodes().size();
+    String _plus_1 = (Integer.valueOf(_size_1) + "");
+    nodeInfo.add(_plus_1);
+    final ArrayList<String> stateInfo = new ArrayList<String>();
+    stateInfo.add(Graph.STATE_ID_HEADER);
+    stateInfo.add(this.name);
+    output.add(metaInfo);
+    output.add(edgeInfo);
+    output.add(nodeInfo);
+    output.add(stateInfo);
+  }
+  
+  private Iterable<PartialComplexTypeInterpretationImpl> getTypes(final PartialInterpretation partial) {
+    final Function1<PartialComplexTypeInterpretationImpl, Boolean> _function = (PartialComplexTypeInterpretationImpl it) -> {
+      boolean _contains = it.getInterpretationOf().getName().toLowerCase().contains(this.typeToExclude);
+      return Boolean.valueOf((!_contains));
+    };
+    return IterableExtensions.<PartialComplexTypeInterpretationImpl>filter(Iterables.<PartialComplexTypeInterpretationImpl>filter(partial.getPartialtypeinterpratation(), PartialComplexTypeInterpretationImpl.class), _function);
+  }
+  
+  @Override
+  public GraphStatistic getStatistic() {
+    throw new UnsupportedOperationException("TODO: auto-generated method stub");
+  }
+  
+  @Override
+  public String getName() {
+    return this.name;
+  }
+}