56 files changed, 7647 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..c5fe8c25
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.classpath
@@ -0,0 +1,12 @@
+<?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="src" path="constraints"/>
+        <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="lib" path="C:/Users/chenp/eclipse-workspace/VIATRA-Generator/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/lib/weka.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/.settings/org.eclipse.wst.validation.prefs b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.settings/org.eclipse.wst.validation.prefs
new file mode 100644
index 00000000..b0a80408
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/.settings/org.eclipse.wst.validation.prefs
@@ -0,0 +1,10 @@
+DELEGATES_PREFERENCE=delegateValidatorList
+USER_BUILD_PREFERENCE=enabledBuildValidatorList
+USER_MANUAL_PREFERENCE=enabledManualValidatorList
+USER_PREFERENCE=overrideGlobalPreferencestruedisableAllValidationfalseversion1.2.701.v201810290944
+eclipse.preferences.version=1
+override=true
+suspend=false
+vals/org.eclipse.wst.xml.core.xml/global=FF03
+vals/org.eclipse.wst.xsd.core.xsd/global=FF02162org.eclipse.wst.xsd.core.internal.validation.eclipse.Validator
+vf.version=3
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..7c4f553d
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/META-INF/MANIFEST.MF
@@ -0,0 +1,30 @@
+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.viatrasolver.partialinterpretationlanguage;bundle-version="1.0.0",
+ org.eclipse.viatra.dse;bundle-version="0.21.2",
+ org.eclipse.viatra.query.runtime.rete;bundle-version="2.1.2",
+ org.eclipse.viatra.addon.validation.core;bundle-version="2.1.2",
+ org.eclipse.collections;bundle-version="9.2.0",
+ org.eclipse.viatra.query.runtime.localsearch;bundle-version="2.1.2",
+ org.apache.log4j;bundle-version="1.2.15",
+ hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph;bundle-version="1.0.0",
+ github-graph;bundle-version="0.1.0"
+Export-Package: ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app,
+ ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance,
+ ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph,
+ ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io,
+ ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics,
+ ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.predictor,
+ ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.validation
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/constraints/constraints/ecore/LoopInInheritenceConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/ecore/LoopInInheritenceConstraint0.java
new file mode 100644
index 00000000..c31e59e7
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/ecore/LoopInInheritenceConstraint0.java
@@ -0,0 +1,79 @@
+/**
+Generated from platform:/resource/SocialNetwork_plugin/queries/queries/Ecore.vql
+*/
+package constraints.ecore;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import ecore.LoopInInheritence;
+
+public class LoopInInheritenceConstraint0 implements IConstraintSpecification {
+
+    private LoopInInheritence querySpecification;
+
+    public LoopInInheritenceConstraint0() {
+        querySpecification = LoopInInheritence.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("a",signature.get("a"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "a"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/ecore/NonSymmetricOppositeConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/ecore/NonSymmetricOppositeConstraint0.java
new file mode 100644
index 00000000..29b35552
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/ecore/NonSymmetricOppositeConstraint0.java
@@ -0,0 +1,80 @@
+/**
+Generated from platform:/resource/SocialNetwork_plugin/queries/queries/Ecore.vql
+*/
+package constraints.ecore;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import ecore.NonSymmetricOpposite;
+
+public class NonSymmetricOppositeConstraint0 implements IConstraintSpecification {
+
+    private NonSymmetricOpposite querySpecification;
+
+    public NonSymmetricOppositeConstraint0() {
+        querySpecification = NonSymmetricOpposite.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("a",signature.get("a"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "a"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+            "b"
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/ecore/OppositeDifferentClassConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/ecore/OppositeDifferentClassConstraint0.java
new file mode 100644
index 00000000..9ef4e35e
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/ecore/OppositeDifferentClassConstraint0.java
@@ -0,0 +1,79 @@
+/**
+Generated from platform:/resource/SocialNetwork_plugin/queries/queries/Ecore.vql
+*/
+package constraints.ecore;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import ecore.OppositeDifferentClass;
+
+public class OppositeDifferentClassConstraint0 implements IConstraintSpecification {
+
+    private OppositeDifferentClass querySpecification;
+
+    public OppositeDifferentClassConstraint0() {
+        querySpecification = OppositeDifferentClass.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("a",signature.get("a"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "a"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/ChoiceHasNoIncomingConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/ChoiceHasNoIncomingConstraint0.java
new file mode 100644
index 00000000..dbc51a5e
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/ChoiceHasNoIncomingConstraint0.java
@@ -0,0 +1,79 @@
+/**
+Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/queries/hu/bme/mit/inf/dslreasoner/partialsnapshot_mavo/yakindu/patterns.vql
+*/
+package constraints.yakindumm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Arrays;
+
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.ChoiceHasNoIncoming;
+
+public class ChoiceHasNoIncomingConstraint0 implements IConstraintSpecification {
+
+    private ChoiceHasNoIncoming querySpecification;
+
+    public ChoiceHasNoIncomingConstraint0() {
+        querySpecification = ChoiceHasNoIncoming.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("c",signature.get("c"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "c"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/ChoiceHasNoOutgoingConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/ChoiceHasNoOutgoingConstraint0.java
new file mode 100644
index 00000000..bdddd5b5
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/ChoiceHasNoOutgoingConstraint0.java
@@ -0,0 +1,79 @@
+/**
+Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/queries/hu/bme/mit/inf/dslreasoner/partialsnapshot_mavo/yakindu/patterns.vql
+*/
+package constraints.yakindumm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Arrays;
+
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.ChoiceHasNoOutgoing;
+
+public class ChoiceHasNoOutgoingConstraint0 implements IConstraintSpecification {
+
+    private ChoiceHasNoOutgoing querySpecification;
+
+    public ChoiceHasNoOutgoingConstraint0() {
+        querySpecification = ChoiceHasNoOutgoing.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("c",signature.get("c"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "c"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/IncomingToEntryConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/IncomingToEntryConstraint0.java
new file mode 100644
index 00000000..b49d9474
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/IncomingToEntryConstraint0.java
@@ -0,0 +1,80 @@
+/**
+Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/queries/hu/bme/mit/inf/dslreasoner/partialsnapshot_mavo/yakindu/patterns.vql
+*/
+package constraints.yakindumm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Arrays;
+
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.IncomingToEntry;
+
+public class IncomingToEntryConstraint0 implements IConstraintSpecification {
+
+    private IncomingToEntry querySpecification;
+
+    public IncomingToEntryConstraint0() {
+        querySpecification = IncomingToEntry.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("e",signature.get("e"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "e"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+            "t"
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/MultipleEntryInRegionConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/MultipleEntryInRegionConstraint0.java
new file mode 100644
index 00000000..535e7eee
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/MultipleEntryInRegionConstraint0.java
@@ -0,0 +1,79 @@
+/**
+Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/queries/hu/bme/mit/inf/dslreasoner/partialsnapshot_mavo/yakindu/patterns.vql
+*/
+package constraints.yakindumm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Arrays;
+
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.MultipleEntryInRegion;
+
+public class MultipleEntryInRegionConstraint0 implements IConstraintSpecification {
+
+    private MultipleEntryInRegion querySpecification;
+
+    public MultipleEntryInRegionConstraint0() {
+        querySpecification = MultipleEntryInRegion.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("r",signature.get("r"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "r"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/MultipleTransitionFromEntryConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/MultipleTransitionFromEntryConstraint0.java
new file mode 100644
index 00000000..a41b2fc1
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/MultipleTransitionFromEntryConstraint0.java
@@ -0,0 +1,81 @@
+/**
+Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/queries/hu/bme/mit/inf/dslreasoner/partialsnapshot_mavo/yakindu/patterns.vql
+*/
+package constraints.yakindumm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Arrays;
+
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.MultipleTransitionFromEntry;
+
+public class MultipleTransitionFromEntryConstraint0 implements IConstraintSpecification {
+
+    private MultipleTransitionFromEntry querySpecification;
+
+    public MultipleTransitionFromEntryConstraint0() {
+        querySpecification = MultipleTransitionFromEntry.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("e",signature.get("e"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "e"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+            "t1",
+            "t2"
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/NoEntryInRegionConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/NoEntryInRegionConstraint0.java
new file mode 100644
index 00000000..9eb7783f
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/NoEntryInRegionConstraint0.java
@@ -0,0 +1,79 @@
+/**
+Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/queries/hu/bme/mit/inf/dslreasoner/partialsnapshot_mavo/yakindu/patterns.vql
+*/
+package constraints.yakindumm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Arrays;
+
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.NoEntryInRegion;
+
+public class NoEntryInRegionConstraint0 implements IConstraintSpecification {
+
+    private NoEntryInRegion querySpecification;
+
+    public NoEntryInRegionConstraint0() {
+        querySpecification = NoEntryInRegion.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("r1",signature.get("r1"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "r1"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/NoOutgoingTransitionFromEntryConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/NoOutgoingTransitionFromEntryConstraint0.java
new file mode 100644
index 00000000..35d54e8e
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/NoOutgoingTransitionFromEntryConstraint0.java
@@ -0,0 +1,79 @@
+/**
+Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/queries/hu/bme/mit/inf/dslreasoner/partialsnapshot_mavo/yakindu/patterns.vql
+*/
+package constraints.yakindumm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Arrays;
+
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.NoOutgoingTransitionFromEntry;
+
+public class NoOutgoingTransitionFromEntryConstraint0 implements IConstraintSpecification {
+
+    private NoOutgoingTransitionFromEntry querySpecification;
+
+    public NoOutgoingTransitionFromEntryConstraint0() {
+        querySpecification = NoOutgoingTransitionFromEntry.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("e",signature.get("e"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "e"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/NoStateInRegionConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/NoStateInRegionConstraint0.java
new file mode 100644
index 00000000..49c0063f
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/NoStateInRegionConstraint0.java
@@ -0,0 +1,79 @@
+/**
+Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/queries/hu/bme/mit/inf/dslreasoner/partialsnapshot_mavo/yakindu/patterns.vql
+*/
+package constraints.yakindumm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Arrays;
+
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.NoStateInRegion;
+
+public class NoStateInRegionConstraint0 implements IConstraintSpecification {
+
+    private NoStateInRegion querySpecification;
+
+    public NoStateInRegionConstraint0() {
+        querySpecification = NoStateInRegion.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("region",signature.get("region"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "region"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/OutgoingFromExitConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/OutgoingFromExitConstraint0.java
new file mode 100644
index 00000000..ddb907ff
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/OutgoingFromExitConstraint0.java
@@ -0,0 +1,80 @@
+/**
+Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/queries/hu/bme/mit/inf/dslreasoner/partialsnapshot_mavo/yakindu/patterns.vql
+*/
+package constraints.yakindumm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Arrays;
+
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.OutgoingFromExit;
+
+public class OutgoingFromExitConstraint0 implements IConstraintSpecification {
+
+    private OutgoingFromExit querySpecification;
+
+    public OutgoingFromExitConstraint0() {
+        querySpecification = OutgoingFromExit.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("e",signature.get("e"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "e"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+            "t"
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/OutgoingFromFinalConstraint0.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/OutgoingFromFinalConstraint0.java
new file mode 100644
index 00000000..3b2949fd
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/constraints/yakindumm/OutgoingFromFinalConstraint0.java
@@ -0,0 +1,80 @@
+/**
+Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph/queries/hu/bme/mit/inf/dslreasoner/partialsnapshot_mavo/yakindu/patterns.vql
+*/
+package constraints.yakindumm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Arrays;
+
+import org.eclipse.viatra.addon.validation.core.api.Severity;
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
+
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.OutgoingFromFinal;
+
+public class OutgoingFromFinalConstraint0 implements IConstraintSpecification {
+
+    private OutgoingFromFinal querySpecification;
+
+    public OutgoingFromFinalConstraint0() {
+        querySpecification = OutgoingFromFinal.instance();
+    }
+
+    @Override
+    public String getMessageFormat() {
+        return "error";
+    }
+
+
+    @Override
+    public Map<String,Object> getKeyObjects(IPatternMatch signature) {
+        Map<String,Object> map = new HashMap<>();
+        map.put("f",signature.get("f"));
+        return map;
+    }
+
+    @Override
+    public List<String> getKeyNames() {
+        List<String> keyNames = Arrays.asList(
+            "f"
+        );
+        return keyNames;
+    }
+
+    @Override
+    public List<String> getPropertyNames() {
+        List<String> propertyNames = Arrays.asList(
+            "t"
+        );
+        return propertyNames;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricPropertyNames() {
+        Set<List<String>> symmetricPropertyNamesSet = new HashSet<>();
+        return symmetricPropertyNamesSet;
+    }
+
+    @Override
+    public Set<List<String>> getSymmetricKeyNames() {
+        Set<List<String>> symmetricKeyNamesSet = new HashSet<>();
+        return symmetricKeyNamesSet;
+    }
+
+    @Override
+    public Severity getSeverity() {
+        return Severity.ERROR;
+    }
+
+    @Override
+    public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> getQuerySpecification() {
+        return querySpecification;
+    }
+
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/.gitignore b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/.gitignore
new file mode 100644
index 00000000..c42ca056
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/.gitignore
@@ -0,0 +1,8 @@
+/.Ecore_pattern.java._trace
+/.MoreThenFiveSuperTypes.java._trace
+/.DirectSupertype.java._trace
+/.Ecore.java._trace
+/.LoopInInheritence.java._trace
+/.NonSymmetricOpposite.java._trace
+/.Opposite.java._trace
+/.OppositeDifferentClass.java._trace
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/DirectSupertype.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/DirectSupertype.java
new file mode 100644
index 00000000..a6ffad45
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/DirectSupertype.java
@@ -0,0 +1,692 @@
+/**
+ * Generated from platform:/resource/SocialNetwork_plugin/queries/ecore/Ecore.vql
+ */
+package ecore;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         pattern directSupertype(a: EClass, b:EClass) {
+ *              EClass.eSuperTypes(a,b);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class DirectSupertype extends BaseGeneratedEMFQuerySpecification<DirectSupertype.Matcher> {
+  /**
+   * Pattern-specific match representation of the ecore.directSupertype pattern,
+   * to be used in conjunction with {@link Matcher}.
+   * 
+   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+   * Each instance is a (possibly partial) substitution of pattern parameters,
+   * usable to represent a match of the pattern in the result of a query,
+   * or to specify the bound (fixed) input parameters when issuing a query.
+   * 
+   * @see Matcher
+   * 
+   */
+  public static abstract class Match extends BasePatternMatch {
+    private EClass fA;
+    
+    private EClass fB;
+    
+    private static List<String> parameterNames = makeImmutableList("a", "b");
+    
+    private Match(final EClass pA, final EClass pB) {
+      this.fA = pA;
+      this.fB = pB;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      if ("a".equals(parameterName)) return this.fA;
+      if ("b".equals(parameterName)) return this.fB;
+      return null;
+    }
+    
+    public EClass getA() {
+      return this.fA;
+    }
+    
+    public EClass getB() {
+      return this.fB;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("a".equals(parameterName) ) {
+          this.fA = (EClass) newValue;
+          return true;
+      }
+      if ("b".equals(parameterName) ) {
+          this.fB = (EClass) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setA(final EClass pA) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fA = pA;
+    }
+    
+    public void setB(final EClass pB) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fB = pB;
+    }
+    
+    @Override
+    public String patternName() {
+      return "ecore.directSupertype";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return DirectSupertype.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fA, fB};
+    }
+    
+    @Override
+    public DirectSupertype.Match toImmutable() {
+      return isMutable() ? newMatch(fA, fB) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"a\"=" + prettyPrintValue(fA) + ", ");
+      result.append("\"b\"=" + prettyPrintValue(fB));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fA, fB);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof DirectSupertype.Match)) {
+          DirectSupertype.Match other = (DirectSupertype.Match) obj;
+          return Objects.equals(fA, other.fA) && Objects.equals(fB, other.fB);
+      } else {
+          // this should be infrequent
+          if (!(obj instanceof IPatternMatch)) {
+              return false;
+          }
+          IPatternMatch otherSig  = (IPatternMatch) obj;
+          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+      }
+    }
+    
+    @Override
+    public DirectSupertype specification() {
+      return DirectSupertype.instance();
+    }
+    
+    /**
+     * Returns an empty, mutable match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @return the empty match.
+     * 
+     */
+    public static DirectSupertype.Match newEmptyMatch() {
+      return new Mutable(null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static DirectSupertype.Match newMutableMatch(final EClass pA, final EClass pB) {
+      return new Mutable(pA, pB);
+    }
+    
+    /**
+     * Returns a new (partial) match.
+     * This can be used e.g. to call the matcher with a partial match.
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static DirectSupertype.Match newMatch(final EClass pA, final EClass pB) {
+      return new Immutable(pA, pB);
+    }
+    
+    private static final class Mutable extends DirectSupertype.Match {
+      Mutable(final EClass pA, final EClass pB) {
+        super(pA, pB);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends DirectSupertype.Match {
+      Immutable(final EClass pA, final EClass pB) {
+        super(pA, pB);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the ecore.directSupertype pattern,
+   * providing pattern-specific query methods.
+   * 
+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+   * 
+   * <p>Matches of the pattern will be represented as {@link Match}.
+   * 
+   * <p>Original source:
+   * <code><pre>
+   * pattern directSupertype(a: EClass, b:EClass) {
+   *    EClass.eSuperTypes(a,b);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see DirectSupertype
+   * 
+   */
+  public static class Matcher extends BaseMatcher<DirectSupertype.Match> {
+    /**
+     * Initializes the pattern matcher within an existing VIATRA Query engine.
+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+     * 
+     * @param engine the existing VIATRA Query engine in which this matcher will be created.
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * 
+     */
+    public static DirectSupertype.Matcher on(final ViatraQueryEngine engine) {
+      // check if matcher already exists
+      Matcher matcher = engine.getExistingMatcher(querySpecification());
+      if (matcher == null) {
+          matcher = (Matcher)engine.getMatcher(querySpecification());
+      }
+      return matcher;
+    }
+    
+    /**
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * @return an initialized matcher
+     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+     * 
+     */
+    public static DirectSupertype.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_A = 0;
+    
+    private static final int POSITION_B = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(DirectSupertype.Matcher.class);
+    
+    /**
+     * Initializes the pattern matcher within an existing VIATRA Query engine.
+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+     * 
+     * @param engine the existing VIATRA Query engine in which this matcher will be created.
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * 
+     */
+    private Matcher() {
+      super(querySpecification());
+    }
+    
+    /**
+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<DirectSupertype.Match> getAllMatches(final EClass pA, final EClass pB) {
+      return rawStreamAllMatches(new Object[]{pA, pB}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<DirectSupertype.Match> streamAllMatches(final EClass pA, final EClass pB) {
+      return rawStreamAllMatches(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<DirectSupertype.Match> getOneArbitraryMatch(final EClass pA, final EClass pB) {
+      return rawGetOneArbitraryMatch(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+     * under any possible substitution of the unspecified parameters (if any).
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final EClass pA, final EClass pB) {
+      return rawHasMatch(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final EClass pA, final EClass pB) {
+      return rawCountMatches(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @param processor the action that will process the selected match.
+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+     * 
+     */
+    public boolean forOneArbitraryMatch(final EClass pA, final EClass pB, final Consumer<? super DirectSupertype.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pA, pB}, processor);
+    }
+    
+    /**
+     * Returns a new (partial) match.
+     * This can be used e.g. to call the matcher with a partial match.
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public DirectSupertype.Match newMatch(final EClass pA, final EClass pB) {
+      return DirectSupertype.Match.newMatch(pA, pB);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<EClass> rawStreamAllValuesOfa(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_A, parameters).map(EClass.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EClass> getAllValuesOfa() {
+      return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EClass> streamAllValuesOfa() {
+      return rawStreamAllValuesOfa(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EClass> streamAllValuesOfa(final DirectSupertype.Match partialMatch) {
+      return rawStreamAllValuesOfa(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EClass> streamAllValuesOfa(final EClass pB) {
+      return rawStreamAllValuesOfa(new Object[]{null, pB});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EClass> getAllValuesOfa(final DirectSupertype.Match partialMatch) {
+      return rawStreamAllValuesOfa(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EClass> getAllValuesOfa(final EClass pB) {
+      return rawStreamAllValuesOfa(new Object[]{null, pB}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<EClass> rawStreamAllValuesOfb(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_B, parameters).map(EClass.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EClass> getAllValuesOfb() {
+      return rawStreamAllValuesOfb(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EClass> streamAllValuesOfb() {
+      return rawStreamAllValuesOfb(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EClass> streamAllValuesOfb(final DirectSupertype.Match partialMatch) {
+      return rawStreamAllValuesOfb(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EClass> streamAllValuesOfb(final EClass pA) {
+      return rawStreamAllValuesOfb(new Object[]{pA, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EClass> getAllValuesOfb(final DirectSupertype.Match partialMatch) {
+      return rawStreamAllValuesOfb(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EClass> getAllValuesOfb(final EClass pA) {
+      return rawStreamAllValuesOfb(new Object[]{pA, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected DirectSupertype.Match tupleToMatch(final Tuple t) {
+      try {
+          return DirectSupertype.Match.newMatch((EClass) t.get(POSITION_A), (EClass) t.get(POSITION_B));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected DirectSupertype.Match arrayToMatch(final Object[] match) {
+      try {
+          return DirectSupertype.Match.newMatch((EClass) match[POSITION_A], (EClass) match[POSITION_B]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected DirectSupertype.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return DirectSupertype.Match.newMutableMatch((EClass) match[POSITION_A], (EClass) match[POSITION_B]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    /**
+     * @return the singleton instance of the query specification of this pattern
+     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+     * 
+     */
+    public static IQuerySpecification<DirectSupertype.Matcher> querySpecification() {
+      return DirectSupertype.instance();
+    }
+  }
+  
+  private DirectSupertype() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static DirectSupertype instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected DirectSupertype.Matcher instantiate(final ViatraQueryEngine engine) {
+    return DirectSupertype.Matcher.on(engine);
+  }
+  
+  @Override
+  public DirectSupertype.Matcher instantiate() {
+    return DirectSupertype.Matcher.create();
+  }
+  
+  @Override
+  public DirectSupertype.Match newEmptyMatch() {
+    return DirectSupertype.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public DirectSupertype.Match newMatch(final Object... parameters) {
+    return DirectSupertype.Match.newMatch((org.eclipse.emf.ecore.EClass) parameters[0], (org.eclipse.emf.ecore.EClass) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link JvmGenericType: ecore.DirectSupertype (visibility: PUBLIC, simpleName: DirectSupertype, identifier: ecore.DirectSupertype, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ecore) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link JvmGenericType: ecore.DirectSupertype (visibility: PUBLIC, simpleName: DirectSupertype, identifier: ecore.DirectSupertype, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ecore) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final DirectSupertype INSTANCE = new DirectSupertype();
+    
+    /**
+     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
+     * This initialization order is required to support indirect recursion.
+     * 
+     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.
+     * 
+     */
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final DirectSupertype.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EClass", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EClass")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_b = new PParameter("b", "org.eclipse.emf.ecore.EClass", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EClass")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_a, parameter_b);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "ecore.directSupertype";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("a","b");
+    }
+    
+    @Override
+    public List<PParameter> getParameters() {
+      return parameters;
+    }
+    
+    @Override
+    public Set<PBody> doGetContainedBodies() {
+      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+      Set<PBody> bodies = new LinkedHashSet<>();
+      {
+          PBody body = new PBody(this);
+          PVariable var_a = body.getOrCreateVariableByName("a");
+          PVariable var_b = body.getOrCreateVariableByName("b");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_a, parameter_a),
+             new ExportedParameter(body, var_b, parameter_b)
+          ));
+          //    EClass.eSuperTypes(a,b)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass", "eSuperTypes")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+          new Equality(body, var__virtual_0_, var_b);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/Ecore.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/Ecore.java
new file mode 100644
index 00000000..bca43a17
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/Ecore.java
@@ -0,0 +1,97 @@
+/**
+ * Generated from platform:/resource/SocialNetwork_plugin/queries/ecore/Ecore.vql
+ */
+package ecore;
+
+import ecore.DirectSupertype;
+import ecore.LoopInInheritence;
+import ecore.NonSymmetricOpposite;
+import ecore.Opposite;
+import ecore.OppositeDifferentClass;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedPatternGroup;
+
+/**
+ * A pattern group formed of all public patterns defined in Ecore.vql.
+ * 
+ * <p>Use the static instance as any {@link interface org.eclipse.viatra.query.runtime.api.IQueryGroup}, to conveniently prepare
+ * a VIATRA Query engine for matching all patterns originally defined in file Ecore.vql,
+ * in order to achieve better performance than one-by-one on-demand matcher initialization.
+ * 
+ * <p> From package ecore, the group contains the definition of the following patterns: <ul>
+ * <li>directSupertype</li>
+ * <li>loopInInheritence</li>
+ * <li>opposite</li>
+ * <li>oppositeDifferentClass</li>
+ * <li>nonSymmetricOpposite</li>
+ * </ul>
+ * 
+ * @see IQueryGroup
+ * 
+ */
+@SuppressWarnings("all")
+public final class Ecore extends BaseGeneratedPatternGroup {
+  /**
+   * Access the pattern group.
+   * 
+   * @return the singleton instance of the group
+   * @throws ViatraQueryRuntimeException if there was an error loading the generated code of pattern specifications
+   * 
+   */
+  public static Ecore instance() {
+    if (INSTANCE == null) {
+        INSTANCE = new Ecore();
+    }
+    return INSTANCE;
+  }
+  
+  private static Ecore INSTANCE;
+  
+  private Ecore() {
+    querySpecifications.add(DirectSupertype.instance());
+    querySpecifications.add(LoopInInheritence.instance());
+    querySpecifications.add(Opposite.instance());
+    querySpecifications.add(OppositeDifferentClass.instance());
+    querySpecifications.add(NonSymmetricOpposite.instance());
+  }
+  
+  public DirectSupertype getDirectSupertype() {
+    return DirectSupertype.instance();
+  }
+  
+  public DirectSupertype.Matcher getDirectSupertype(final ViatraQueryEngine engine) {
+    return DirectSupertype.Matcher.on(engine);
+  }
+  
+  public LoopInInheritence getLoopInInheritence() {
+    return LoopInInheritence.instance();
+  }
+  
+  public LoopInInheritence.Matcher getLoopInInheritence(final ViatraQueryEngine engine) {
+    return LoopInInheritence.Matcher.on(engine);
+  }
+  
+  public Opposite getOpposite() {
+    return Opposite.instance();
+  }
+  
+  public Opposite.Matcher getOpposite(final ViatraQueryEngine engine) {
+    return Opposite.Matcher.on(engine);
+  }
+  
+  public OppositeDifferentClass getOppositeDifferentClass() {
+    return OppositeDifferentClass.instance();
+  }
+  
+  public OppositeDifferentClass.Matcher getOppositeDifferentClass(final ViatraQueryEngine engine) {
+    return OppositeDifferentClass.Matcher.on(engine);
+  }
+  
+  public NonSymmetricOpposite getNonSymmetricOpposite() {
+    return NonSymmetricOpposite.instance();
+  }
+  
+  public NonSymmetricOpposite.Matcher getNonSymmetricOpposite(final ViatraQueryEngine engine) {
+    return NonSymmetricOpposite.Matcher.on(engine);
+  }
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/LoopInInheritence.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/LoopInInheritence.java
new file mode 100644
index 00000000..fb14941f
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/LoopInInheritence.java
@@ -0,0 +1,548 @@
+/**
+ * Generated from platform:/resource/SocialNetwork_plugin/queries/ecore/Ecore.vql
+ */
+package ecore;
+
+import ecore.DirectSupertype;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         {@literal @}Constraint(key={a}, severity="error", message="error")
+ *         pattern loopInInheritence(a: EClass) {
+ *              find directSupertype+(a,a);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class LoopInInheritence extends BaseGeneratedEMFQuerySpecification<LoopInInheritence.Matcher> {
+  /**
+   * Pattern-specific match representation of the ecore.loopInInheritence pattern,
+   * to be used in conjunction with {@link Matcher}.
+   * 
+   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+   * Each instance is a (possibly partial) substitution of pattern parameters,
+   * usable to represent a match of the pattern in the result of a query,
+   * or to specify the bound (fixed) input parameters when issuing a query.
+   * 
+   * @see Matcher
+   * 
+   */
+  public static abstract class Match extends BasePatternMatch {
+    private EClass fA;
+    
+    private static List<String> parameterNames = makeImmutableList("a");
+    
+    private Match(final EClass pA) {
+      this.fA = pA;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      if ("a".equals(parameterName)) return this.fA;
+      return null;
+    }
+    
+    public EClass getA() {
+      return this.fA;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("a".equals(parameterName) ) {
+          this.fA = (EClass) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setA(final EClass pA) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fA = pA;
+    }
+    
+    @Override
+    public String patternName() {
+      return "ecore.loopInInheritence";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return LoopInInheritence.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fA};
+    }
+    
+    @Override
+    public LoopInInheritence.Match toImmutable() {
+      return isMutable() ? newMatch(fA) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"a\"=" + prettyPrintValue(fA));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fA);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof LoopInInheritence.Match)) {
+          LoopInInheritence.Match other = (LoopInInheritence.Match) obj;
+          return Objects.equals(fA, other.fA);
+      } else {
+          // this should be infrequent
+          if (!(obj instanceof IPatternMatch)) {
+              return false;
+          }
+          IPatternMatch otherSig  = (IPatternMatch) obj;
+          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+      }
+    }
+    
+    @Override
+    public LoopInInheritence specification() {
+      return LoopInInheritence.instance();
+    }
+    
+    /**
+     * Returns an empty, mutable match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @return the empty match.
+     * 
+     */
+    public static LoopInInheritence.Match newEmptyMatch() {
+      return new Mutable(null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static LoopInInheritence.Match newMutableMatch(final EClass pA) {
+      return new Mutable(pA);
+    }
+    
+    /**
+     * Returns a new (partial) match.
+     * This can be used e.g. to call the matcher with a partial match.
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static LoopInInheritence.Match newMatch(final EClass pA) {
+      return new Immutable(pA);
+    }
+    
+    private static final class Mutable extends LoopInInheritence.Match {
+      Mutable(final EClass pA) {
+        super(pA);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends LoopInInheritence.Match {
+      Immutable(final EClass pA) {
+        super(pA);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the ecore.loopInInheritence pattern,
+   * providing pattern-specific query methods.
+   * 
+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+   * 
+   * <p>Matches of the pattern will be represented as {@link Match}.
+   * 
+   * <p>Original source:
+   * <code><pre>
+   * {@literal @}Constraint(key={a}, severity="error", message="error")
+   * pattern loopInInheritence(a: EClass) {
+   *    find directSupertype+(a,a);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see LoopInInheritence
+   * 
+   */
+  public static class Matcher extends BaseMatcher<LoopInInheritence.Match> {
+    /**
+     * Initializes the pattern matcher within an existing VIATRA Query engine.
+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+     * 
+     * @param engine the existing VIATRA Query engine in which this matcher will be created.
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * 
+     */
+    public static LoopInInheritence.Matcher on(final ViatraQueryEngine engine) {
+      // check if matcher already exists
+      Matcher matcher = engine.getExistingMatcher(querySpecification());
+      if (matcher == null) {
+          matcher = (Matcher)engine.getMatcher(querySpecification());
+      }
+      return matcher;
+    }
+    
+    /**
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * @return an initialized matcher
+     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+     * 
+     */
+    public static LoopInInheritence.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_A = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(LoopInInheritence.Matcher.class);
+    
+    /**
+     * Initializes the pattern matcher within an existing VIATRA Query engine.
+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+     * 
+     * @param engine the existing VIATRA Query engine in which this matcher will be created.
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * 
+     */
+    private Matcher() {
+      super(querySpecification());
+    }
+    
+    /**
+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<LoopInInheritence.Match> getAllMatches(final EClass pA) {
+      return rawStreamAllMatches(new Object[]{pA}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<LoopInInheritence.Match> streamAllMatches(final EClass pA) {
+      return rawStreamAllMatches(new Object[]{pA});
+    }
+    
+    /**
+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<LoopInInheritence.Match> getOneArbitraryMatch(final EClass pA) {
+      return rawGetOneArbitraryMatch(new Object[]{pA});
+    }
+    
+    /**
+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+     * under any possible substitution of the unspecified parameters (if any).
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final EClass pA) {
+      return rawHasMatch(new Object[]{pA});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final EClass pA) {
+      return rawCountMatches(new Object[]{pA});
+    }
+    
+    /**
+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param processor the action that will process the selected match.
+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+     * 
+     */
+    public boolean forOneArbitraryMatch(final EClass pA, final Consumer<? super LoopInInheritence.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pA}, processor);
+    }
+    
+    /**
+     * Returns a new (partial) match.
+     * This can be used e.g. to call the matcher with a partial match.
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public LoopInInheritence.Match newMatch(final EClass pA) {
+      return LoopInInheritence.Match.newMatch(pA);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<EClass> rawStreamAllValuesOfa(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_A, parameters).map(EClass.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EClass> getAllValuesOfa() {
+      return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EClass> streamAllValuesOfa() {
+      return rawStreamAllValuesOfa(emptyArray());
+    }
+    
+    @Override
+    protected LoopInInheritence.Match tupleToMatch(final Tuple t) {
+      try {
+          return LoopInInheritence.Match.newMatch((EClass) t.get(POSITION_A));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected LoopInInheritence.Match arrayToMatch(final Object[] match) {
+      try {
+          return LoopInInheritence.Match.newMatch((EClass) match[POSITION_A]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected LoopInInheritence.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return LoopInInheritence.Match.newMutableMatch((EClass) match[POSITION_A]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    /**
+     * @return the singleton instance of the query specification of this pattern
+     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+     * 
+     */
+    public static IQuerySpecification<LoopInInheritence.Matcher> querySpecification() {
+      return LoopInInheritence.instance();
+    }
+  }
+  
+  private LoopInInheritence() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static LoopInInheritence instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected LoopInInheritence.Matcher instantiate(final ViatraQueryEngine engine) {
+    return LoopInInheritence.Matcher.on(engine);
+  }
+  
+  @Override
+  public LoopInInheritence.Matcher instantiate() {
+    return LoopInInheritence.Matcher.create();
+  }
+  
+  @Override
+  public LoopInInheritence.Match newEmptyMatch() {
+    return LoopInInheritence.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public LoopInInheritence.Match newMatch(final Object... parameters) {
+    return LoopInInheritence.Match.newMatch((org.eclipse.emf.ecore.EClass) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link JvmGenericType: ecore.LoopInInheritence (visibility: PUBLIC, simpleName: LoopInInheritence, identifier: ecore.LoopInInheritence, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ecore) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link JvmGenericType: ecore.LoopInInheritence (visibility: PUBLIC, simpleName: LoopInInheritence, identifier: ecore.LoopInInheritence, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ecore) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final LoopInInheritence INSTANCE = new LoopInInheritence();
+    
+    /**
+     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
+     * This initialization order is required to support indirect recursion.
+     * 
+     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.
+     * 
+     */
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final LoopInInheritence.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EClass", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EClass")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_a);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "ecore.loopInInheritence";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("a");
+    }
+    
+    @Override
+    public List<PParameter> getParameters() {
+      return parameters;
+    }
+    
+    @Override
+    public Set<PBody> doGetContainedBodies() {
+      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+      Set<PBody> bodies = new LinkedHashSet<>();
+      {
+          PBody body = new PBody(this);
+          PVariable var_a = body.getOrCreateVariableByName("a");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_a, parameter_a)
+          ));
+          //    find directSupertype+(a,a)
+          new BinaryTransitiveClosure(body, Tuples.flatTupleOf(var_a, var_a), DirectSupertype.instance().getInternalQueryRepresentation());
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("a")
+                              }));
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("message", "error");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/NonSymmetricOpposite.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/NonSymmetricOpposite.java
new file mode 100644
index 00000000..d230e3f4
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/NonSymmetricOpposite.java
@@ -0,0 +1,707 @@
+/**
+ * Generated from platform:/resource/SocialNetwork_plugin/queries/ecore/Ecore.vql
+ */
+package ecore;
+
+import ecore.Opposite;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         {@literal @}Constraint(key={a}, severity="error", message="error")
+ *         pattern nonSymmetricOpposite(a:EReference, b:EReference) {
+ *              find opposite(a,b);
+ *              neg find opposite(b,a);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class NonSymmetricOpposite extends BaseGeneratedEMFQuerySpecification<NonSymmetricOpposite.Matcher> {
+  /**
+   * Pattern-specific match representation of the ecore.nonSymmetricOpposite pattern,
+   * to be used in conjunction with {@link Matcher}.
+   * 
+   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+   * Each instance is a (possibly partial) substitution of pattern parameters,
+   * usable to represent a match of the pattern in the result of a query,
+   * or to specify the bound (fixed) input parameters when issuing a query.
+   * 
+   * @see Matcher
+   * 
+   */
+  public static abstract class Match extends BasePatternMatch {
+    private EReference fA;
+    
+    private EReference fB;
+    
+    private static List<String> parameterNames = makeImmutableList("a", "b");
+    
+    private Match(final EReference pA, final EReference pB) {
+      this.fA = pA;
+      this.fB = pB;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      if ("a".equals(parameterName)) return this.fA;
+      if ("b".equals(parameterName)) return this.fB;
+      return null;
+    }
+    
+    public EReference getA() {
+      return this.fA;
+    }
+    
+    public EReference getB() {
+      return this.fB;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("a".equals(parameterName) ) {
+          this.fA = (EReference) newValue;
+          return true;
+      }
+      if ("b".equals(parameterName) ) {
+          this.fB = (EReference) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setA(final EReference pA) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fA = pA;
+    }
+    
+    public void setB(final EReference pB) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fB = pB;
+    }
+    
+    @Override
+    public String patternName() {
+      return "ecore.nonSymmetricOpposite";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return NonSymmetricOpposite.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fA, fB};
+    }
+    
+    @Override
+    public NonSymmetricOpposite.Match toImmutable() {
+      return isMutable() ? newMatch(fA, fB) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"a\"=" + prettyPrintValue(fA) + ", ");
+      result.append("\"b\"=" + prettyPrintValue(fB));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fA, fB);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof NonSymmetricOpposite.Match)) {
+          NonSymmetricOpposite.Match other = (NonSymmetricOpposite.Match) obj;
+          return Objects.equals(fA, other.fA) && Objects.equals(fB, other.fB);
+      } else {
+          // this should be infrequent
+          if (!(obj instanceof IPatternMatch)) {
+              return false;
+          }
+          IPatternMatch otherSig  = (IPatternMatch) obj;
+          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+      }
+    }
+    
+    @Override
+    public NonSymmetricOpposite specification() {
+      return NonSymmetricOpposite.instance();
+    }
+    
+    /**
+     * Returns an empty, mutable match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @return the empty match.
+     * 
+     */
+    public static NonSymmetricOpposite.Match newEmptyMatch() {
+      return new Mutable(null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static NonSymmetricOpposite.Match newMutableMatch(final EReference pA, final EReference pB) {
+      return new Mutable(pA, pB);
+    }
+    
+    /**
+     * Returns a new (partial) match.
+     * This can be used e.g. to call the matcher with a partial match.
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static NonSymmetricOpposite.Match newMatch(final EReference pA, final EReference pB) {
+      return new Immutable(pA, pB);
+    }
+    
+    private static final class Mutable extends NonSymmetricOpposite.Match {
+      Mutable(final EReference pA, final EReference pB) {
+        super(pA, pB);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends NonSymmetricOpposite.Match {
+      Immutable(final EReference pA, final EReference pB) {
+        super(pA, pB);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the ecore.nonSymmetricOpposite pattern,
+   * providing pattern-specific query methods.
+   * 
+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+   * 
+   * <p>Matches of the pattern will be represented as {@link Match}.
+   * 
+   * <p>Original source:
+   * <code><pre>
+   * {@literal @}Constraint(key={a}, severity="error", message="error")
+   * pattern nonSymmetricOpposite(a:EReference, b:EReference) {
+   *    find opposite(a,b);
+   *    neg find opposite(b,a);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see NonSymmetricOpposite
+   * 
+   */
+  public static class Matcher extends BaseMatcher<NonSymmetricOpposite.Match> {
+    /**
+     * Initializes the pattern matcher within an existing VIATRA Query engine.
+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+     * 
+     * @param engine the existing VIATRA Query engine in which this matcher will be created.
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * 
+     */
+    public static NonSymmetricOpposite.Matcher on(final ViatraQueryEngine engine) {
+      // check if matcher already exists
+      Matcher matcher = engine.getExistingMatcher(querySpecification());
+      if (matcher == null) {
+          matcher = (Matcher)engine.getMatcher(querySpecification());
+      }
+      return matcher;
+    }
+    
+    /**
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * @return an initialized matcher
+     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+     * 
+     */
+    public static NonSymmetricOpposite.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_A = 0;
+    
+    private static final int POSITION_B = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(NonSymmetricOpposite.Matcher.class);
+    
+    /**
+     * Initializes the pattern matcher within an existing VIATRA Query engine.
+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+     * 
+     * @param engine the existing VIATRA Query engine in which this matcher will be created.
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * 
+     */
+    private Matcher() {
+      super(querySpecification());
+    }
+    
+    /**
+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<NonSymmetricOpposite.Match> getAllMatches(final EReference pA, final EReference pB) {
+      return rawStreamAllMatches(new Object[]{pA, pB}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<NonSymmetricOpposite.Match> streamAllMatches(final EReference pA, final EReference pB) {
+      return rawStreamAllMatches(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<NonSymmetricOpposite.Match> getOneArbitraryMatch(final EReference pA, final EReference pB) {
+      return rawGetOneArbitraryMatch(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+     * under any possible substitution of the unspecified parameters (if any).
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final EReference pA, final EReference pB) {
+      return rawHasMatch(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final EReference pA, final EReference pB) {
+      return rawCountMatches(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @param processor the action that will process the selected match.
+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+     * 
+     */
+    public boolean forOneArbitraryMatch(final EReference pA, final EReference pB, final Consumer<? super NonSymmetricOpposite.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pA, pB}, processor);
+    }
+    
+    /**
+     * Returns a new (partial) match.
+     * This can be used e.g. to call the matcher with a partial match.
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public NonSymmetricOpposite.Match newMatch(final EReference pA, final EReference pB) {
+      return NonSymmetricOpposite.Match.newMatch(pA, pB);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<EReference> rawStreamAllValuesOfa(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_A, parameters).map(EReference.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfa() {
+      return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfa() {
+      return rawStreamAllValuesOfa(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfa(final NonSymmetricOpposite.Match partialMatch) {
+      return rawStreamAllValuesOfa(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfa(final EReference pB) {
+      return rawStreamAllValuesOfa(new Object[]{null, pB});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfa(final NonSymmetricOpposite.Match partialMatch) {
+      return rawStreamAllValuesOfa(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfa(final EReference pB) {
+      return rawStreamAllValuesOfa(new Object[]{null, pB}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<EReference> rawStreamAllValuesOfb(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_B, parameters).map(EReference.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfb() {
+      return rawStreamAllValuesOfb(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfb() {
+      return rawStreamAllValuesOfb(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfb(final NonSymmetricOpposite.Match partialMatch) {
+      return rawStreamAllValuesOfb(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfb(final EReference pA) {
+      return rawStreamAllValuesOfb(new Object[]{pA, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfb(final NonSymmetricOpposite.Match partialMatch) {
+      return rawStreamAllValuesOfb(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfb(final EReference pA) {
+      return rawStreamAllValuesOfb(new Object[]{pA, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected NonSymmetricOpposite.Match tupleToMatch(final Tuple t) {
+      try {
+          return NonSymmetricOpposite.Match.newMatch((EReference) t.get(POSITION_A), (EReference) t.get(POSITION_B));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected NonSymmetricOpposite.Match arrayToMatch(final Object[] match) {
+      try {
+          return NonSymmetricOpposite.Match.newMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected NonSymmetricOpposite.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return NonSymmetricOpposite.Match.newMutableMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    /**
+     * @return the singleton instance of the query specification of this pattern
+     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+     * 
+     */
+    public static IQuerySpecification<NonSymmetricOpposite.Matcher> querySpecification() {
+      return NonSymmetricOpposite.instance();
+    }
+  }
+  
+  private NonSymmetricOpposite() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static NonSymmetricOpposite instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected NonSymmetricOpposite.Matcher instantiate(final ViatraQueryEngine engine) {
+    return NonSymmetricOpposite.Matcher.on(engine);
+  }
+  
+  @Override
+  public NonSymmetricOpposite.Matcher instantiate() {
+    return NonSymmetricOpposite.Matcher.create();
+  }
+  
+  @Override
+  public NonSymmetricOpposite.Match newEmptyMatch() {
+    return NonSymmetricOpposite.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public NonSymmetricOpposite.Match newMatch(final Object... parameters) {
+    return NonSymmetricOpposite.Match.newMatch((org.eclipse.emf.ecore.EReference) parameters[0], (org.eclipse.emf.ecore.EReference) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link JvmGenericType: ecore.NonSymmetricOpposite (visibility: PUBLIC, simpleName: NonSymmetricOpposite, identifier: ecore.NonSymmetricOpposite, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ecore) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link JvmGenericType: ecore.NonSymmetricOpposite (visibility: PUBLIC, simpleName: NonSymmetricOpposite, identifier: ecore.NonSymmetricOpposite, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ecore) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final NonSymmetricOpposite INSTANCE = new NonSymmetricOpposite();
+    
+    /**
+     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
+     * This initialization order is required to support indirect recursion.
+     * 
+     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.
+     * 
+     */
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final NonSymmetricOpposite.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_b = new PParameter("b", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_a, parameter_b);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "ecore.nonSymmetricOpposite";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("a","b");
+    }
+    
+    @Override
+    public List<PParameter> getParameters() {
+      return parameters;
+    }
+    
+    @Override
+    public Set<PBody> doGetContainedBodies() {
+      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+      Set<PBody> bodies = new LinkedHashSet<>();
+      {
+          PBody body = new PBody(this);
+          PVariable var_a = body.getOrCreateVariableByName("a");
+          PVariable var_b = body.getOrCreateVariableByName("b");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_a, parameter_a),
+             new ExportedParameter(body, var_b, parameter_b)
+          ));
+          //    find opposite(a,b)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_a, var_b), Opposite.instance().getInternalQueryRepresentation());
+          //    neg find opposite(b,a)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_b, var_a), Opposite.instance().getInternalQueryRepresentation());
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("a")
+                              }));
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("message", "error");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/Opposite.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/Opposite.java
new file mode 100644
index 00000000..d826f072
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/Opposite.java
@@ -0,0 +1,693 @@
+/**
+ * Generated from platform:/resource/SocialNetwork_plugin/queries/ecore/Ecore.vql
+ */
+package ecore;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         pattern opposite(a:EReference, b: EReference) {
+ *              EReference.eOpposite(a,b);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class Opposite extends BaseGeneratedEMFQuerySpecification<Opposite.Matcher> {
+  /**
+   * Pattern-specific match representation of the ecore.opposite pattern,
+   * to be used in conjunction with {@link Matcher}.
+   * 
+   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+   * Each instance is a (possibly partial) substitution of pattern parameters,
+   * usable to represent a match of the pattern in the result of a query,
+   * or to specify the bound (fixed) input parameters when issuing a query.
+   * 
+   * @see Matcher
+   * 
+   */
+  public static abstract class Match extends BasePatternMatch {
+    private EReference fA;
+    
+    private EReference fB;
+    
+    private static List<String> parameterNames = makeImmutableList("a", "b");
+    
+    private Match(final EReference pA, final EReference pB) {
+      this.fA = pA;
+      this.fB = pB;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      if ("a".equals(parameterName)) return this.fA;
+      if ("b".equals(parameterName)) return this.fB;
+      return null;
+    }
+    
+    public EReference getA() {
+      return this.fA;
+    }
+    
+    public EReference getB() {
+      return this.fB;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("a".equals(parameterName) ) {
+          this.fA = (EReference) newValue;
+          return true;
+      }
+      if ("b".equals(parameterName) ) {
+          this.fB = (EReference) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setA(final EReference pA) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fA = pA;
+    }
+    
+    public void setB(final EReference pB) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fB = pB;
+    }
+    
+    @Override
+    public String patternName() {
+      return "ecore.opposite";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return Opposite.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fA, fB};
+    }
+    
+    @Override
+    public Opposite.Match toImmutable() {
+      return isMutable() ? newMatch(fA, fB) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"a\"=" + prettyPrintValue(fA) + ", ");
+      result.append("\"b\"=" + prettyPrintValue(fB));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fA, fB);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof Opposite.Match)) {
+          Opposite.Match other = (Opposite.Match) obj;
+          return Objects.equals(fA, other.fA) && Objects.equals(fB, other.fB);
+      } else {
+          // this should be infrequent
+          if (!(obj instanceof IPatternMatch)) {
+              return false;
+          }
+          IPatternMatch otherSig  = (IPatternMatch) obj;
+          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+      }
+    }
+    
+    @Override
+    public Opposite specification() {
+      return Opposite.instance();
+    }
+    
+    /**
+     * Returns an empty, mutable match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @return the empty match.
+     * 
+     */
+    public static Opposite.Match newEmptyMatch() {
+      return new Mutable(null, null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static Opposite.Match newMutableMatch(final EReference pA, final EReference pB) {
+      return new Mutable(pA, pB);
+    }
+    
+    /**
+     * Returns a new (partial) match.
+     * This can be used e.g. to call the matcher with a partial match.
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static Opposite.Match newMatch(final EReference pA, final EReference pB) {
+      return new Immutable(pA, pB);
+    }
+    
+    private static final class Mutable extends Opposite.Match {
+      Mutable(final EReference pA, final EReference pB) {
+        super(pA, pB);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends Opposite.Match {
+      Immutable(final EReference pA, final EReference pB) {
+        super(pA, pB);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the ecore.opposite pattern,
+   * providing pattern-specific query methods.
+   * 
+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+   * 
+   * <p>Matches of the pattern will be represented as {@link Match}.
+   * 
+   * <p>Original source:
+   * <code><pre>
+   * pattern opposite(a:EReference, b: EReference) {
+   *    EReference.eOpposite(a,b);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see Opposite
+   * 
+   */
+  public static class Matcher extends BaseMatcher<Opposite.Match> {
+    /**
+     * Initializes the pattern matcher within an existing VIATRA Query engine.
+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+     * 
+     * @param engine the existing VIATRA Query engine in which this matcher will be created.
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * 
+     */
+    public static Opposite.Matcher on(final ViatraQueryEngine engine) {
+      // check if matcher already exists
+      Matcher matcher = engine.getExistingMatcher(querySpecification());
+      if (matcher == null) {
+          matcher = (Matcher)engine.getMatcher(querySpecification());
+      }
+      return matcher;
+    }
+    
+    /**
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * @return an initialized matcher
+     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+     * 
+     */
+    public static Opposite.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_A = 0;
+    
+    private static final int POSITION_B = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(Opposite.Matcher.class);
+    
+    /**
+     * Initializes the pattern matcher within an existing VIATRA Query engine.
+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+     * 
+     * @param engine the existing VIATRA Query engine in which this matcher will be created.
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * 
+     */
+    private Matcher() {
+      super(querySpecification());
+    }
+    
+    /**
+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<Opposite.Match> getAllMatches(final EReference pA, final EReference pB) {
+      return rawStreamAllMatches(new Object[]{pA, pB}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<Opposite.Match> streamAllMatches(final EReference pA, final EReference pB) {
+      return rawStreamAllMatches(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<Opposite.Match> getOneArbitraryMatch(final EReference pA, final EReference pB) {
+      return rawGetOneArbitraryMatch(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+     * under any possible substitution of the unspecified parameters (if any).
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final EReference pA, final EReference pB) {
+      return rawHasMatch(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final EReference pA, final EReference pB) {
+      return rawCountMatches(new Object[]{pA, pB});
+    }
+    
+    /**
+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @param processor the action that will process the selected match.
+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+     * 
+     */
+    public boolean forOneArbitraryMatch(final EReference pA, final EReference pB, final Consumer<? super Opposite.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pA, pB}, processor);
+    }
+    
+    /**
+     * Returns a new (partial) match.
+     * This can be used e.g. to call the matcher with a partial match.
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param pB the fixed value of pattern parameter b, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public Opposite.Match newMatch(final EReference pA, final EReference pB) {
+      return Opposite.Match.newMatch(pA, pB);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<EReference> rawStreamAllValuesOfa(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_A, parameters).map(EReference.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfa() {
+      return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfa() {
+      return rawStreamAllValuesOfa(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfa(final Opposite.Match partialMatch) {
+      return rawStreamAllValuesOfa(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfa(final EReference pB) {
+      return rawStreamAllValuesOfa(new Object[]{null, pB});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfa(final Opposite.Match partialMatch) {
+      return rawStreamAllValuesOfa(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfa(final EReference pB) {
+      return rawStreamAllValuesOfa(new Object[]{null, pB}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<EReference> rawStreamAllValuesOfb(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_B, parameters).map(EReference.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfb() {
+      return rawStreamAllValuesOfb(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfb() {
+      return rawStreamAllValuesOfb(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfb(final Opposite.Match partialMatch) {
+      return rawStreamAllValuesOfb(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     *      
+     * @return the Stream of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfb(final EReference pA) {
+      return rawStreamAllValuesOfb(new Object[]{pA, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfb(final Opposite.Match partialMatch) {
+      return rawStreamAllValuesOfb(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for b.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfb(final EReference pA) {
+      return rawStreamAllValuesOfb(new Object[]{pA, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected Opposite.Match tupleToMatch(final Tuple t) {
+      try {
+          return Opposite.Match.newMatch((EReference) t.get(POSITION_A), (EReference) t.get(POSITION_B));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected Opposite.Match arrayToMatch(final Object[] match) {
+      try {
+          return Opposite.Match.newMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected Opposite.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return Opposite.Match.newMutableMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    /**
+     * @return the singleton instance of the query specification of this pattern
+     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+     * 
+     */
+    public static IQuerySpecification<Opposite.Matcher> querySpecification() {
+      return Opposite.instance();
+    }
+  }
+  
+  private Opposite() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static Opposite instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected Opposite.Matcher instantiate(final ViatraQueryEngine engine) {
+    return Opposite.Matcher.on(engine);
+  }
+  
+  @Override
+  public Opposite.Matcher instantiate() {
+    return Opposite.Matcher.create();
+  }
+  
+  @Override
+  public Opposite.Match newEmptyMatch() {
+    return Opposite.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public Opposite.Match newMatch(final Object... parameters) {
+    return Opposite.Match.newMatch((org.eclipse.emf.ecore.EReference) parameters[0], (org.eclipse.emf.ecore.EReference) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link JvmGenericType: ecore.Opposite (visibility: PUBLIC, simpleName: Opposite, identifier: ecore.Opposite, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ecore) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link JvmGenericType: ecore.Opposite (visibility: PUBLIC, simpleName: Opposite, identifier: ecore.Opposite, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ecore) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final Opposite INSTANCE = new Opposite();
+    
+    /**
+     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
+     * This initialization order is required to support indirect recursion.
+     * 
+     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.
+     * 
+     */
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final Opposite.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_b = new PParameter("b", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_a, parameter_b);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "ecore.opposite";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("a","b");
+    }
+    
+    @Override
+    public List<PParameter> getParameters() {
+      return parameters;
+    }
+    
+    @Override
+    public Set<PBody> doGetContainedBodies() {
+      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+      Set<PBody> bodies = new LinkedHashSet<>();
+      {
+          PBody body = new PBody(this);
+          PVariable var_a = body.getOrCreateVariableByName("a");
+          PVariable var_b = body.getOrCreateVariableByName("b");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_a, parameter_a),
+             new ExportedParameter(body, var_b, parameter_b)
+          ));
+          //    EReference.eOpposite(a,b)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference", "eOpposite")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+          new Equality(body, var__virtual_0_, var_b);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/OppositeDifferentClass.java b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/OppositeDifferentClass.java
new file mode 100644
index 00000000..3a0df648
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/constraints/ecore/OppositeDifferentClass.java
@@ -0,0 +1,577 @@
+/**
+ * Generated from platform:/resource/SocialNetwork_plugin/queries/ecore/Ecore.vql
+ */
+package ecore;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         {@literal @}Constraint(key={a}, severity="error", message="error")
+ *         pattern oppositeDifferentClass(a:EReference) {
+ *              EReference.eOpposite(a,b);
+ *              EReference.eContainingClass(a,aContaining);
+ *              EReference.eType(b,bTarget);
+ *              aContaining != bTarget;
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class OppositeDifferentClass extends BaseGeneratedEMFQuerySpecification<OppositeDifferentClass.Matcher> {
+  /**
+   * Pattern-specific match representation of the ecore.oppositeDifferentClass pattern,
+   * to be used in conjunction with {@link Matcher}.
+   * 
+   * <p>Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+   * Each instance is a (possibly partial) substitution of pattern parameters,
+   * usable to represent a match of the pattern in the result of a query,
+   * or to specify the bound (fixed) input parameters when issuing a query.
+   * 
+   * @see Matcher
+   * 
+   */
+  public static abstract class Match extends BasePatternMatch {
+    private EReference fA;
+    
+    private static List<String> parameterNames = makeImmutableList("a");
+    
+    private Match(final EReference pA) {
+      this.fA = pA;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      if ("a".equals(parameterName)) return this.fA;
+      return null;
+    }
+    
+    public EReference getA() {
+      return this.fA;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("a".equals(parameterName) ) {
+          this.fA = (EReference) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setA(final EReference pA) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fA = pA;
+    }
+    
+    @Override
+    public String patternName() {
+      return "ecore.oppositeDifferentClass";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return OppositeDifferentClass.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fA};
+    }
+    
+    @Override
+    public OppositeDifferentClass.Match toImmutable() {
+      return isMutable() ? newMatch(fA) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"a\"=" + prettyPrintValue(fA));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fA);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof OppositeDifferentClass.Match)) {
+          OppositeDifferentClass.Match other = (OppositeDifferentClass.Match) obj;
+          return Objects.equals(fA, other.fA);
+      } else {
+          // this should be infrequent
+          if (!(obj instanceof IPatternMatch)) {
+              return false;
+          }
+          IPatternMatch otherSig  = (IPatternMatch) obj;
+          return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+      }
+    }
+    
+    @Override
+    public OppositeDifferentClass specification() {
+      return OppositeDifferentClass.instance();
+    }
+    
+    /**
+     * Returns an empty, mutable match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @return the empty match.
+     * 
+     */
+    public static OppositeDifferentClass.Match newEmptyMatch() {
+      return new Mutable(null);
+    }
+    
+    /**
+     * Returns a mutable (partial) match.
+     * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+     * 
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static OppositeDifferentClass.Match newMutableMatch(final EReference pA) {
+      return new Mutable(pA);
+    }
+    
+    /**
+     * Returns a new (partial) match.
+     * This can be used e.g. to call the matcher with a partial match.
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static OppositeDifferentClass.Match newMatch(final EReference pA) {
+      return new Immutable(pA);
+    }
+    
+    private static final class Mutable extends OppositeDifferentClass.Match {
+      Mutable(final EReference pA) {
+        super(pA);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends OppositeDifferentClass.Match {
+      Immutable(final EReference pA) {
+        super(pA);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the ecore.oppositeDifferentClass pattern,
+   * providing pattern-specific query methods.
+   * 
+   * <p>Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+   * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+   * 
+   * <p>Matches of the pattern will be represented as {@link Match}.
+   * 
+   * <p>Original source:
+   * <code><pre>
+   * {@literal @}Constraint(key={a}, severity="error", message="error")
+   * pattern oppositeDifferentClass(a:EReference) {
+   *    EReference.eOpposite(a,b);
+   *    EReference.eContainingClass(a,aContaining);
+   *    EReference.eType(b,bTarget);
+   *    aContaining != bTarget;
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see OppositeDifferentClass
+   * 
+   */
+  public static class Matcher extends BaseMatcher<OppositeDifferentClass.Match> {
+    /**
+     * Initializes the pattern matcher within an existing VIATRA Query engine.
+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+     * 
+     * @param engine the existing VIATRA Query engine in which this matcher will be created.
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * 
+     */
+    public static OppositeDifferentClass.Matcher on(final ViatraQueryEngine engine) {
+      // check if matcher already exists
+      Matcher matcher = engine.getExistingMatcher(querySpecification());
+      if (matcher == null) {
+          matcher = (Matcher)engine.getMatcher(querySpecification());
+      }
+      return matcher;
+    }
+    
+    /**
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * @return an initialized matcher
+     * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+     * 
+     */
+    public static OppositeDifferentClass.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_A = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(OppositeDifferentClass.Matcher.class);
+    
+    /**
+     * Initializes the pattern matcher within an existing VIATRA Query engine.
+     * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+     * 
+     * @param engine the existing VIATRA Query engine in which this matcher will be created.
+     * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+     * 
+     */
+    private Matcher() {
+      super(querySpecification());
+    }
+    
+    /**
+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<OppositeDifferentClass.Match> getAllMatches(final EReference pA) {
+      return rawStreamAllMatches(new Object[]{pA}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+     * </p>
+     * <strong>NOTE</strong>: It is important not to modify the source model while the stream is being processed.
+     * If the match set of the pattern changes during processing, the contents of the stream is <strong>undefined</strong>.
+     * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<OppositeDifferentClass.Match> streamAllMatches(final EReference pA) {
+      return rawStreamAllMatches(new Object[]{pA});
+    }
+    
+    /**
+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<OppositeDifferentClass.Match> getOneArbitraryMatch(final EReference pA) {
+      return rawGetOneArbitraryMatch(new Object[]{pA});
+    }
+    
+    /**
+     * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+     * under any possible substitution of the unspecified parameters (if any).
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final EReference pA) {
+      return rawHasMatch(new Object[]{pA});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final EReference pA) {
+      return rawCountMatches(new Object[]{pA});
+    }
+    
+    /**
+     * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @param processor the action that will process the selected match.
+     * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+     * 
+     */
+    public boolean forOneArbitraryMatch(final EReference pA, final Consumer<? super OppositeDifferentClass.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pA}, processor);
+    }
+    
+    /**
+     * Returns a new (partial) match.
+     * This can be used e.g. to call the matcher with a partial match.
+     * <p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+     * @param pA the fixed value of pattern parameter a, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public OppositeDifferentClass.Match newMatch(final EReference pA) {
+      return OppositeDifferentClass.Match.newMatch(pA);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<EReference> rawStreamAllValuesOfa(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_A, parameters).map(EReference.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<EReference> getAllValuesOfa() {
+      return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for a.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<EReference> streamAllValuesOfa() {
+      return rawStreamAllValuesOfa(emptyArray());
+    }
+    
+    @Override
+    protected OppositeDifferentClass.Match tupleToMatch(final Tuple t) {
+      try {
+          return OppositeDifferentClass.Match.newMatch((EReference) t.get(POSITION_A));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected OppositeDifferentClass.Match arrayToMatch(final Object[] match) {
+      try {
+          return OppositeDifferentClass.Match.newMatch((EReference) match[POSITION_A]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected OppositeDifferentClass.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return OppositeDifferentClass.Match.newMutableMatch((EReference) match[POSITION_A]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    /**
+     * @return the singleton instance of the query specification of this pattern
+     * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+     * 
+     */
+    public static IQuerySpecification<OppositeDifferentClass.Matcher> querySpecification() {
+      return OppositeDifferentClass.instance();
+    }
+  }
+  
+  private OppositeDifferentClass() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static OppositeDifferentClass instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected OppositeDifferentClass.Matcher instantiate(final ViatraQueryEngine engine) {
+    return OppositeDifferentClass.Matcher.on(engine);
+  }
+  
+  @Override
+  public OppositeDifferentClass.Matcher instantiate() {
+    return OppositeDifferentClass.Matcher.create();
+  }
+  
+  @Override
+  public OppositeDifferentClass.Match newEmptyMatch() {
+    return OppositeDifferentClass.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public OppositeDifferentClass.Match newMatch(final Object... parameters) {
+    return OppositeDifferentClass.Match.newMatch((org.eclipse.emf.ecore.EReference) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link JvmGenericType: ecore.OppositeDifferentClass (visibility: PUBLIC, simpleName: OppositeDifferentClass, identifier: ecore.OppositeDifferentClass, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ecore) (interface: false, strictFloatingPoint: false, anonymous: false)} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link JvmGenericType: ecore.OppositeDifferentClass (visibility: PUBLIC, simpleName: OppositeDifferentClass, identifier: ecore.OppositeDifferentClass, deprecated: <unset>) (abstract: false, static: false, final: true, packageName: ecore) (interface: false, strictFloatingPoint: false, anonymous: false)#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final OppositeDifferentClass INSTANCE = new OppositeDifferentClass();
+    
+    /**
+     * Statically initializes the query specification <b>after</b> the field {@link #INSTANCE} is assigned.
+     * This initialization order is required to support indirect recursion.
+     * 
+     * <p> The static initializer is defined using a helper field to work around limitations of the code generator.
+     * 
+     */
+    private static final Object STATIC_INITIALIZER = ensureInitialized();
+    
+    public static Object ensureInitialized() {
+      INSTANCE.ensureInitializedInternal();
+      return null;
+    }
+  }
+  
+  private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+    private static final OppositeDifferentClass.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_a);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "ecore.oppositeDifferentClass";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("a");
+    }
+    
+    @Override
+    public List<PParameter> getParameters() {
+      return parameters;
+    }
+    
+    @Override
+    public Set<PBody> doGetContainedBodies() {
+      setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+      Set<PBody> bodies = new LinkedHashSet<>();
+      {
+          PBody body = new PBody(this);
+          PVariable var_a = body.getOrCreateVariableByName("a");
+          PVariable var_b = body.getOrCreateVariableByName("b");
+          PVariable var_aContaining = body.getOrCreateVariableByName("aContaining");
+          PVariable var_bTarget = body.getOrCreateVariableByName("bTarget");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_a, parameter_a)
+          ));
+          //    EReference.eOpposite(a,b)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference", "eOpposite")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+          new Equality(body, var__virtual_0_, var_b);
+          //    EReference.eContainingClass(a,aContaining)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EStructuralFeature", "eContainingClass")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+          new Equality(body, var__virtual_1_, var_aContaining);
+          //    EReference.eType(b,bTarget)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_b, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "ETypedElement", "eType")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClassifier")));
+          new Equality(body, var__virtual_2_, var_bTarget);
+          //    aContaining != bTarget
+          new Inequality(body, var_aContaining, var_bTarget);
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("a")
+                              }));
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("message", "error");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/ecore.ecore b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/ecore.ecore
new file mode 100644
index 00000000..e7dc2768
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/ecore.ecore
@@ -0,0 +1,1016 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="ecore" nsURI="http://www.eclipse.org/emf/2002/Ecore" nsPrefix="ecore">
+  <eClassifiers xsi:type="ecore:EClass" name="EAnnotation" eSuperTypes="#//EModelElement">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EAnnotation"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="WellFormedSourceURI"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="details" upperBound="-1"
+        eType="#//EStringToStringMapEntry" containment="true" resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="details"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="contents" upperBound="-1"
+        eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject" containment="true"
+        resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="contents"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="references" upperBound="-1"
+        eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="references"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="source" eType="#//EString">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="source"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eModelElement" eType="#//EModelElement"
+        transient="true" eOpposite="#//EModelElement/eAnnotations"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EAttribute" eSuperTypes="#//EStructuralFeature">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EAttribute"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="ConsistentTransient"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eAttributeType" lowerBound="1"
+        eType="#//EDataType" changeable="false" volatile="true" transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eAttributeType"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="iD" eType="#//EBoolean">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="iD"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EBigDecimal" instanceClassName="java.math.BigDecimal">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EBigDecimal"/>
+      <details key="baseType" value="http://www.eclipse.org/emf/2003/XMLType#decimal"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EBigInteger" instanceClassName="java.math.BigInteger">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EBigInteger"/>
+      <details key="baseType" value="http://www.eclipse.org/emf/2003/XMLType#integer"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EBoolean" instanceClassName="boolean">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EBoolean"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EBooleanObject" instanceClassName="java.lang.Boolean">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EBoolean:Object"/>
+      <details key="baseType" value="EBoolean"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EByte" instanceClassName="byte">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EByte"/>
+      <details key="baseType" value="http://www.eclipse.org/emf/2003/XMLType#byte"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EByteArray" instanceClassName="byte[]">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EByteArray"/>
+      <details key="baseType" value="http://www.eclipse.org/emf/2003/XMLType#hexBinary"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EByteObject" instanceClassName="java.lang.Byte">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EByte:Object"/>
+      <details key="baseType" value="EByte"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EChar" instanceClassName="char">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EChar"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="ECharacterObject" instanceClassName="java.lang.Character">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EChar:Object"/>
+      <details key="baseType" value="EChar"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EClass" eSuperTypes="#//EClassifier">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EClass"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="InterfaceIsAbstract AtMostOneID UniqueFeatureNames UniqueOperationSignatures NoCircularSuperTypes WellFormedMapEntryClass ConsistentSuperTypes DisjointFeatureAndOperationSignatures"/>
+    </eAnnotations>
+    <eOperations name="isSuperTypeOf" eType="#//EBoolean">
+      <eParameters name="someClass" eType="#//EClass"/>
+    </eOperations>
+    <eOperations name="getFeatureCount" eType="#//EInt"/>
+    <eOperations name="getEStructuralFeature" eType="#//EStructuralFeature">
+      <eParameters name="featureID" eType="#//EInt"/>
+    </eOperations>
+    <eOperations name="getFeatureID" eType="#//EInt">
+      <eParameters name="feature" eType="#//EStructuralFeature"/>
+    </eOperations>
+    <eOperations name="getEStructuralFeature" eType="#//EStructuralFeature">
+      <eParameters name="featureName" eType="#//EString"/>
+    </eOperations>
+    <eOperations name="getOperationCount" eType="#//EInt"/>
+    <eOperations name="getEOperation" eType="#//EOperation">
+      <eParameters name="operationID" eType="#//EInt"/>
+    </eOperations>
+    <eOperations name="getOperationID" eType="#//EInt">
+      <eParameters name="operation" eType="#//EOperation"/>
+    </eOperations>
+    <eOperations name="getOverride" eType="#//EOperation">
+      <eParameters name="operation" eType="#//EOperation"/>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eOperations" upperBound="-1"
+        eType="#//EOperation" containment="true" resolveProxies="false" eOpposite="#//EOperation/eContainingClass">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eOperations"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eStructuralFeatures" upperBound="-1"
+        eType="#//EStructuralFeature" containment="true" resolveProxies="false" eOpposite="#//EStructuralFeature/eContainingClass">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eStructuralFeatures"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eGenericSuperTypes" upperBound="-1"
+        eType="#//EGenericType" unsettable="true" containment="true" resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eGenericSuperTypes"/>
+      </eAnnotations>
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="suppressedIsSetVisibility" value="true"/>
+        <details key="suppressedUnsetVisibility" value="true"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="abstract" eType="#//EBoolean">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="abstract"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eAllAttributes" upperBound="-1"
+        eType="#//EAttribute" changeable="false" volatile="true" transient="true"
+        derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eAllAttributes"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eAllContainments" upperBound="-1"
+        eType="#//EReference" changeable="false" volatile="true" transient="true"
+        derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eAllContainments"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eAllGenericSuperTypes"
+        upperBound="-1" eType="#//EGenericType" changeable="false" volatile="true"
+        transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eAllGenericSuperTypes"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eAllOperations" upperBound="-1"
+        eType="#//EOperation" changeable="false" volatile="true" transient="true"
+        derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eAllOperations"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eAllReferences" upperBound="-1"
+        eType="#//EReference" changeable="false" volatile="true" transient="true"
+        derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eAllReferences"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eAllStructuralFeatures"
+        upperBound="-1" eType="#//EStructuralFeature" changeable="false" volatile="true"
+        transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eAllStructuralFeatures"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eAllSuperTypes" upperBound="-1"
+        eType="#//EClass" changeable="false" volatile="true" transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eAllSuperTypes"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eAttributes" upperBound="-1"
+        eType="#//EAttribute" changeable="false" volatile="true" transient="true"
+        derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eAttributes"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eIDAttribute" eType="#//EAttribute"
+        changeable="false" volatile="true" transient="true" derived="true" resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eIDAttribute"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eReferences" upperBound="-1"
+        eType="#//EReference" changeable="false" volatile="true" transient="true"
+        derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eReferences"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eSuperTypes" upperBound="-1"
+        eType="#//EClass" unsettable="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eSuperTypes"/>
+      </eAnnotations>
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="suppressedIsSetVisibility" value="true"/>
+        <details key="suppressedUnsetVisibility" value="true"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="interface" eType="#//EBoolean">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="interface"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EClassifier" abstract="true" eSuperTypes="#//ENamedElement">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EClassifier"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="WellFormedInstanceTypeName UniqueTypeParameterNames"/>
+    </eAnnotations>
+    <eOperations name="isInstance" eType="#//EBoolean">
+      <eParameters name="object" eType="#//EJavaObject"/>
+    </eOperations>
+    <eOperations name="getClassifierID" eType="#//EInt"/>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eTypeParameters" upperBound="-1"
+        eType="#//ETypeParameter" containment="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eTypeParameters"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="defaultValue" eType="#//EJavaObject"
+        changeable="false" volatile="true" transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="defaultValue"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="instanceClass" changeable="false"
+        volatile="true" transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="instanceClass"/>
+      </eAnnotations>
+      <eGenericType eClassifier="#//EJavaClass">
+        <eTypeArguments/>
+      </eGenericType>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="instanceClassName" eType="#//EString"
+        volatile="true" unsettable="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="instanceClassName"/>
+      </eAnnotations>
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="suppressedIsSetVisibility" value="true"/>
+        <details key="suppressedUnsetVisibility" value="true"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="instanceTypeName" eType="#//EString"
+        volatile="true" unsettable="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="instanceTypeName"/>
+      </eAnnotations>
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="suppressedIsSetVisibility" value="true"/>
+        <details key="suppressedUnsetVisibility" value="true"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="ePackage" eType="#//EPackage"
+        transient="true" eOpposite="#//EPackage/eClassifiers"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EDataType" eSuperTypes="#//EClassifier">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EDataType"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="serializable" eType="#//EBoolean"
+        defaultValueLiteral="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="serializable"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EDate" instanceClassName="java.util.Date">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EDate"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EDiagnosticChain" instanceClassName="org.eclipse.emf.common.util.DiagnosticChain"
+      serializable="false">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EDiagnosticChain"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EDouble" instanceClassName="double">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EDouble"/>
+      <details key="baseType" value="http://www.eclipse.org/emf/2003/XMLType#double"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EDoubleObject" instanceClassName="java.lang.Double">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EDouble:Object"/>
+      <details key="baseType" value="EDouble"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EEList" instanceClassName="org.eclipse.emf.common.util.EList"
+      serializable="false">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EEList"/>
+    </eAnnotations>
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EEnum" eSuperTypes="#//EDataType">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EEnum"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="UniqueEnumeratorNames UniqueEnumeratorLiterals"/>
+    </eAnnotations>
+    <eOperations name="getEEnumLiteral" eType="#//EEnumLiteral">
+      <eParameters name="name" eType="#//EString"/>
+    </eOperations>
+    <eOperations name="getEEnumLiteral" eType="#//EEnumLiteral">
+      <eParameters name="value" eType="#//EInt"/>
+    </eOperations>
+    <eOperations name="getEEnumLiteralByLiteral" eType="#//EEnumLiteral">
+      <eParameters name="literal" eType="#//EString"/>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eLiterals" upperBound="-1"
+        eType="#//EEnumLiteral" containment="true" resolveProxies="false" eOpposite="#//EEnumLiteral/eEnum">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eLiterals"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EEnumerator" instanceClassName="org.eclipse.emf.common.util.Enumerator"
+      serializable="false">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EEnumerator"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EEnumLiteral" eSuperTypes="#//ENamedElement">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EEnumLiteral"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="instance" eType="#//EEnumerator"
+        transient="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="instance"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="literal" eType="#//EString">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="literal"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="#//EInt">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="value"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eEnum" eType="#//EEnum"
+        transient="true" eOpposite="#//EEnum/eLiterals"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EFactory" eSuperTypes="#//EModelElement">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EFactory"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eOperations name="create" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject">
+      <eParameters name="eClass" eType="#//EClass"/>
+    </eOperations>
+    <eOperations name="createFromString" eType="#//EJavaObject">
+      <eParameters name="eDataType" eType="#//EDataType"/>
+      <eParameters name="literalValue" eType="#//EString"/>
+    </eOperations>
+    <eOperations name="convertToString" eType="#//EString">
+      <eParameters name="eDataType" eType="#//EDataType"/>
+      <eParameters name="instanceValue" eType="#//EJavaObject"/>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="ePackage" lowerBound="1"
+        eType="#//EPackage" transient="true" resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="ePackage"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EFeatureMap" instanceClassName="org.eclipse.emf.ecore.util.FeatureMap"
+      serializable="false">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EFeatureMap"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EFeatureMapEntry" instanceClassName="org.eclipse.emf.ecore.util.FeatureMap$Entry"
+      serializable="false">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EFeatureMapEntry"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EFloat" instanceClassName="float">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EFloat"/>
+      <details key="baseType" value="http://www.eclipse.org/emf/2003/XMLType#float"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EFloatObject" instanceClassName="java.lang.Float">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EFloat:Object"/>
+      <details key="baseType" value="EFloat"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EGenericType">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EGenericType"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="ConsistentType ConsistentBounds ConsistentArguments"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eUpperBound" eType="#//EGenericType"
+        containment="true" resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eUpperBound"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eTypeArguments" upperBound="-1"
+        eType="#//EGenericType" containment="true" resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eTypeArguments"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eLowerBound" eType="#//EGenericType"
+        containment="true" resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eLowerBound"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eClassifier" eType="#//EClassifier">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eClassifier"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eRawType" lowerBound="1"
+        eType="#//EClassifier" changeable="false" transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eRawType"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eTypeParameter" eType="#//ETypeParameter"
+        resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eTypeParameter"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EInt" instanceClassName="int">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EInt"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EIntegerObject" instanceClassName="java.lang.Integer">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EInt:Object"/>
+      <details key="baseType" value="EInt"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EInvocationTargetException" instanceClassName="java.lang.reflect.InvocationTargetException"
+      serializable="false">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EInvocationTargetException"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EJavaClass" instanceClassName="java.lang.Class">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EJavaClass"/>
+    </eAnnotations>
+    <eTypeParameters name="T"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EJavaObject" instanceClassName="java.lang.Object">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EJavaObject"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="ELong" instanceClassName="long">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="ELong"/>
+      <details key="baseType" value="http://www.eclipse.org/emf/2003/XMLType#long"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="ELongObject" instanceClassName="java.lang.Long">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="ELong:Object"/>
+      <details key="baseType" value="ELong"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EMap" instanceClassName="java.util.Map"
+      serializable="false">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EMap"/>
+    </eAnnotations>
+    <eTypeParameters name="K"/>
+    <eTypeParameters name="V"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EModelElement" abstract="true">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EModelElement"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eOperations name="getEAnnotation" eType="#//EAnnotation">
+      <eParameters name="source" eType="#//EString"/>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eAnnotations" upperBound="-1"
+        eType="#//EAnnotation" containment="true" resolveProxies="false" eOpposite="#//EAnnotation/eModelElement">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eAnnotations"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="ENamedElement" abstract="true" eSuperTypes="#//EModelElement">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="ENamedElement"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="WellFormedName"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="name" eType="#//EString">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="name"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EObject">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EObject"/>
+      <details key="kind" value="empty"/>
+    </eAnnotations>
+    <eOperations name="eClass" eType="#//EClass"/>
+    <eOperations name="eIsProxy" eType="#//EBoolean"/>
+    <eOperations name="eResource" eType="#//EResource"/>
+    <eOperations name="eContainer" eType="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject"/>
+    <eOperations name="eContainingFeature" eType="#//EStructuralFeature"/>
+    <eOperations name="eContainmentFeature" eType="#//EReference"/>
+    <eOperations name="eContents">
+      <eGenericType eClassifier="#//EEList">
+        <eTypeArguments eClassifier="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject"/>
+      </eGenericType>
+    </eOperations>
+    <eOperations name="eAllContents">
+      <eGenericType eClassifier="#//ETreeIterator">
+        <eTypeArguments eClassifier="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject"/>
+      </eGenericType>
+    </eOperations>
+    <eOperations name="eCrossReferences">
+      <eGenericType eClassifier="#//EEList">
+        <eTypeArguments eClassifier="ecore:EClass http://www.eclipse.org/emf/2002/Ecore#//EObject"/>
+      </eGenericType>
+    </eOperations>
+    <eOperations name="eGet" eType="#//EJavaObject">
+      <eParameters name="feature" eType="#//EStructuralFeature"/>
+    </eOperations>
+    <eOperations name="eGet" eType="#//EJavaObject">
+      <eParameters name="feature" eType="#//EStructuralFeature"/>
+      <eParameters name="resolve" eType="#//EBoolean"/>
+    </eOperations>
+    <eOperations name="eSet">
+      <eParameters name="feature" eType="#//EStructuralFeature"/>
+      <eParameters name="newValue" eType="#//EJavaObject"/>
+    </eOperations>
+    <eOperations name="eIsSet" eType="#//EBoolean">
+      <eParameters name="feature" eType="#//EStructuralFeature"/>
+    </eOperations>
+    <eOperations name="eUnset">
+      <eParameters name="feature" eType="#//EStructuralFeature"/>
+    </eOperations>
+    <eOperations name="eInvoke" eType="#//EJavaObject" eExceptions="#//EInvocationTargetException">
+      <eParameters name="operation" eType="#//EOperation"/>
+      <eParameters name="arguments">
+        <eGenericType eClassifier="#//EEList">
+          <eTypeArguments/>
+        </eGenericType>
+      </eParameters>
+    </eOperations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EOperation" eSuperTypes="#//ETypedElement">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EOperation"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="UniqueParameterNames UniqueTypeParameterNames NoRepeatingVoid"/>
+    </eAnnotations>
+    <eOperations name="getOperationID" eType="#//EInt"/>
+    <eOperations name="isOverrideOf" eType="#//EBoolean">
+      <eParameters name="someOperation" eType="#//EOperation"/>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eTypeParameters" upperBound="-1"
+        eType="#//ETypeParameter" containment="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eTypeParameters"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eParameters" upperBound="-1"
+        eType="#//EParameter" containment="true" resolveProxies="false" eOpposite="#//EParameter/eOperation">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eParameters"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eGenericExceptions" upperBound="-1"
+        eType="#//EGenericType" unsettable="true" containment="true" resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eGenericExceptions"/>
+      </eAnnotations>
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="suppressedIsSetVisibility" value="true"/>
+        <details key="suppressedUnsetVisibility" value="true"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eExceptions" upperBound="-1"
+        eType="#//EClassifier" unsettable="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eExceptions"/>
+      </eAnnotations>
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="suppressedIsSetVisibility" value="true"/>
+        <details key="suppressedUnsetVisibility" value="true"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eContainingClass" eType="#//EClass"
+        transient="true" eOpposite="#//EClass/eOperations"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EPackage" eSuperTypes="#//ENamedElement">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EPackage"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="WellFormedNsURI WellFormedNsPrefix UniqueSubpackageNames UniqueClassifierNames UniqueNsURIs"/>
+    </eAnnotations>
+    <eOperations name="getEClassifier" eType="#//EClassifier">
+      <eParameters name="name" eType="#//EString"/>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eClassifiers" upperBound="-1"
+        eType="#//EClassifier" containment="true" eOpposite="#//EClassifier/ePackage">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eClassifiers"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eSubpackages" upperBound="-1"
+        eType="#//EPackage" containment="true" eOpposite="#//EPackage/eSuperPackage">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eSubpackages"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="nsPrefix" eType="#//EString">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="nsPrefix"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="nsURI" eType="#//EString">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="nsURI"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eSuperPackage" eType="#//EPackage"
+        transient="true" eOpposite="#//EPackage/eSubpackages"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EParameter" eSuperTypes="#//ETypedElement">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EParameter"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eOperation" eType="#//EOperation"
+        transient="true" eOpposite="#//EOperation/eParameters"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EReference" eSuperTypes="#//EStructuralFeature">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EReference"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="ConsistentOpposite SingleContainer ConsistentKeys ConsistentUnique ConsistentContainer"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="container" eType="#//EBoolean"
+        changeable="false" volatile="true" transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="container"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="containment" eType="#//EBoolean">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="containment"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eKeys" upperBound="-1"
+        eType="#//EAttribute">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eKeys"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eOpposite" eType="#//EReference">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eOpposite"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eReferenceType" lowerBound="1"
+        eType="#//EClass" changeable="false" volatile="true" transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eReferenceType"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="resolveProxies" eType="#//EBoolean"
+        defaultValueLiteral="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="resolveProxies"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EResource" instanceClassName="org.eclipse.emf.ecore.resource.Resource"
+      serializable="false">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EResource"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EResourceSet" instanceClassName="org.eclipse.emf.ecore.resource.ResourceSet"
+      serializable="false">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EResourceSet"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EShort" instanceClassName="short">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EShort"/>
+      <details key="baseType" value="http://www.eclipse.org/emf/2003/XMLType#short"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EShortObject" instanceClassName="java.lang.Short">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EShort:Object"/>
+      <details key="baseType" value="EShort"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="EString" instanceClassName="java.lang.String">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EString"/>
+      <details key="baseType" value="http://www.eclipse.org/emf/2003/XMLType#string"/>
+    </eAnnotations>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EStringToStringMapEntry" instanceClassName="java.util.Map$Entry">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EStringToStringMapEntry"/>
+      <details key="kind" value="empty"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="key" eType="#//EString">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="key"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="value" eType="#//EString">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="value"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="EStructuralFeature" abstract="true"
+      eSuperTypes="#//ETypedElement">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="EStructuralFeature"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="ValidDefaultValueLiteral"/>
+    </eAnnotations>
+    <eOperations name="getFeatureID" eType="#//EInt"/>
+    <eOperations name="getContainerClass">
+      <eGenericType eClassifier="#//EJavaClass">
+        <eTypeArguments/>
+      </eGenericType>
+    </eOperations>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="changeable" eType="#//EBoolean"
+        defaultValueLiteral="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="changeable"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="defaultValue" eType="#//EJavaObject"
+        changeable="false" volatile="true" transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="defaultValue"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="defaultValueLiteral" eType="#//EString">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="defaultValueLiteral"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="derived" eType="#//EBoolean">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="derived"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="transient" eType="#//EBoolean">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="transient"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="unsettable" eType="#//EBoolean">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="unsettable"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="volatile" eType="#//EBoolean">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="volatile"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eContainingClass" eType="#//EClass"
+        transient="true" eOpposite="#//EClass/eStructuralFeatures"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EDataType" name="ETreeIterator" instanceClassName="org.eclipse.emf.common.util.TreeIterator"
+      serializable="false">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="ETreeIterator"/>
+    </eAnnotations>
+    <eTypeParameters name="E"/>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="ETypedElement" abstract="true" eSuperTypes="#//ENamedElement">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="ETypedElement"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eAnnotations source="http://www.eclipse.org/emf/2002/Ecore">
+      <details key="constraints" value="ValidLowerBound ValidUpperBound ConsistentBounds ValidType"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eGenericType" eType="#//EGenericType"
+        volatile="true" unsettable="true" containment="true" resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eGenericType"/>
+      </eAnnotations>
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="suppressedIsSetVisibility" value="true"/>
+        <details key="suppressedUnsetVisibility" value="true"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eType" eType="#//EClassifier"
+        volatile="true" unsettable="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="eType"/>
+      </eAnnotations>
+      <eAnnotations source="http://www.eclipse.org/emf/2002/GenModel">
+        <details key="suppressedIsSetVisibility" value="true"/>
+        <details key="suppressedUnsetVisibility" value="true"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="lowerBound" eType="#//EInt">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="lowerBound"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="many" eType="#//EBoolean"
+        changeable="false" volatile="true" transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="many"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="ordered" eType="#//EBoolean"
+        defaultValueLiteral="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="ordered"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="required" eType="#//EBoolean"
+        changeable="false" volatile="true" transient="true" derived="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="required"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="unique" eType="#//EBoolean"
+        defaultValueLiteral="true">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="unique"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="upperBound" eType="#//EInt"
+        defaultValueLiteral="1">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="attribute"/>
+        <details key="name" value="upperBound"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+  <eClassifiers xsi:type="ecore:EClass" name="ETypeParameter" eSuperTypes="#//ENamedElement">
+    <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+      <details key="name" value="ETypeParameter"/>
+      <details key="kind" value="elementOnly"/>
+    </eAnnotations>
+    <eStructuralFeatures xsi:type="ecore:EReference" name="eBounds" upperBound="-1"
+        eType="#//EGenericType" containment="true" resolveProxies="false">
+      <eAnnotations source="http:///org/eclipse/emf/ecore/util/ExtendedMetaData">
+        <details key="kind" value="element"/>
+        <details key="name" value="eBounds"/>
+      </eAnnotations>
+    </eStructuralFeatures>
+  </eClassifiers>
+</ecore:EPackage>
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..c8fd435b
--- /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,7 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
+
+enum Domain{
+        Yakindumm,
+        Ecore,
+        Github
+}
\ 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..dfde6593
--- /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,96 @@
+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 ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.validation.ViolationCheck
+import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.impl.YakindummPackageImpl
+import java.io.File
+import java.util.ArrayList
+import org.eclipse.emf.ecore.EPackage
+import org.eclipse.emf.ecore.EcorePackage
+import org.eclipse.viatra.query.runtime.rete.matcher.ReteEngine
+import org.eclipse.emf.ecore.impl.EcorePackageImpl
+import org.eclipse.emf.ecore.EReference
+
+//import yakindumm2.impl.Yakindumm2PackageImpl
+
+class Main {
+        var static Domain d = Domain.Yakindumm;
+        val static String suffix = '.xmi'
+        val static String OUTPUT_FOLDER = "Inputs/measurement2/yakindu/Alloy/";
+        val static String INPUT_FOLDER = "outputs/measurement2/yakindu/Alloy/";
+        val static int NUM_RUNS = 1;
+        
+        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
+                var EPackage metamodel;
+                //init viatra engine for the violation checker
+                ReteEngine.getClass();
+                
+                if(d == Domain.Yakindumm){
+                        YakindummPackageImpl.eINSTANCE.eClass;
+                        metamodel = YakindummPackageImpl.eINSTANCE;
+                }else if (d == Domain.Ecore){
+                        EcorePackage.eINSTANCE.eClass;
+                        metamodel = EcorePackageImpl.eINSTANCE;
+                }else if (d == Domain.Github){
+                        //TODO: Initialize Github Package
+                }
+                
+                                                                                
+                println("Start Reading Models...");
+                var reader = new GraphReader(metamodel, suffix);
+
+                val models = new RWInformation(OUTPUT_FOLDER, INPUT_FOLDER, NUM_RUNS);
+                calculateAllModels(models.inputFolder, models.outputFolder,models.numRuns, reader);     
+                println("finished");
+        }
+        
+        static def calculateAllModels(String inputFolder, String outputFolder, int numRuns, GraphReader reader){
+                (new File(outputFolder)).mkdir();
+                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;
+                
+                //remove eGenericType for Ecore domain
+                if(d == Domain.Ecore){
+                        var refsToRemove = EcorePackageImpl.eINSTANCE.eAllContents.filter(EReference).filter[
+                                it.name.equals('eGenericType') || it.name.equals('eGenericSuperTypes') || it.name.equals('eFactoryInstance')||
+                                it.name.equals('eGenericExceptions') || it.name.equals('references') || it.name.equals('contents');
+                        ];
+                        refsToRemove.forEach[model.removeReference(it)];
+                }
+                
+                var outputs = model.evaluateAllMetrics();
+                var violations = ViolationCheck.calculateViolationCounts(model.root, d);
+                println(violations);
+                var violationsOutput = newArrayList('violations', violations+'');
+                outputs.add(violationsOutput);
+                CsvFileWriter.write(outputs, 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..5e62b586
--- /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,85 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.JSDistance
+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 KSDistance ks;
+        var static JSDistance js;
+        
+        def static void initPaths(){
+                new File("debug/metric/").mkdir();
+                new File("debug/metric/trajectories/").mkdir();
+        }
+        
+        // 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";
+                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.model = 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();
+                                println(stateId)
+                                //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()
+                        }
+                }                       
+        }
+}
\ 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/PartialInterpretationMetricDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetricDistance.xtend
new file mode 100644
index 00000000..697b2639
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetricDistance.xtend
@@ -0,0 +1,216 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.EuclideanDistance
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.JSDistance
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.KSDistance
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.StateData
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.PartialInterpretationGraph
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.RepMetricsReader
+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.predictor.LinearModel
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+import java.util.Map
+import org.apache.commons.math3.stat.regression.OLSMultipleLinearRegression
+import org.eclipse.xtend.lib.annotations.Accessors
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.EdgeTypeMetric
+
+class PartialInterpretationMetricDistance {
+        
+        var KSDistance ks;
+        var JSDistance js;
+        var EuclideanDistance ed;
+        var Map<Object, StateData> stateAndHistory;
+        var OLSMultipleLinearRegression regression;
+        List<StateData> samples;
+        var MetricSampleGroup g;
+        @Accessors(PUBLIC_GETTER)
+        var LinearModel linearModel;
+        
+        
+        new(Domain d){
+                var metrics = RepMetricsReader.read(d);
+                this.g = metrics;
+                ks = new KSDistance(g);
+                js = new JSDistance(g);
+                ed = new EuclideanDistance(g);
+                regression = new OLSMultipleLinearRegression();
+                regression.noIntercept = false;
+                stateAndHistory = new HashMap<Object, StateData>();
+                samples = new ArrayList<StateData>();
+                linearModel = new LinearModel(0.01);
+        }
+        
+        def MetricDistanceGroup calculateMetricDistanceKS(PartialInterpretation partial){
+                val metrics = new ArrayList<Metric>();
+                metrics.add(new OutDegreeMetric());
+                metrics.add(new NodeActivityMetric());
+                metrics.add(new MultiplexParticipationCoefficientMetric());
+                metrics.add(new NodeTypeMetric());
+                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);
+                var nodeType = ks.nodeTypeDistance(metricSamples.nodeTypeSamples);
+                //var typedOutDegree = ks.typedOutDegreeDistance(metricSamples.typedOutDegreeSamples);
+                var distance = new MetricDistanceGroup(mpc, na, outDegree, nodeType);
+                distance.nodeTypeInfo = metricSamples.nodeTypeSamples;
+                return distance;
+        }
+        
+        def MetricDistanceGroup calculateMetricEuclidean(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 = ed.mpcDistance(metricSamples.mpcSamples);
+                var na = ed.naDistance(metricSamples.naSamples);
+                var outDegree = ed.outDegreeDistance(metricSamples.outDegreeSamples);
+                
+                return new MetricDistanceGroup(mpc, na, outDegree);
+        }
+        
+        def 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 = js.mpcDistance(metricSamples.mpcSamples);
+                var na = js.naDistance(metricSamples.naSamples);
+                var outDegree = js.outDegreeDistance(metricSamples.outDegreeSamples);
+                
+                return new MetricDistanceGroup(mpc, na, outDegree);
+        }
+        
+        def resetRegression(Object state){
+                samples.clear();
+                
+                if(stateAndHistory.containsKey(state)){
+                        var data = stateAndHistory.get(state);
+                        
+                        var curState = state;
+                        
+                        samples.add(data);
+                        
+                        while(stateAndHistory.containsKey(data.lastState) && data.lastState != curState){
+                                curState = data.lastState;
+                                data = stateAndHistory.get(data.lastState);
+                                samples.add(data);
+                        }
+                                        
+                        if(samples.size == 0){
+                                println('state: ' + state);
+                                println('last state: ' + data.lastState);
+                        }
+                }
+                println("trajectory sample size:" + samples.size)
+        }
+        
+        def feedData(Object state, double[] features, double value, Object lastState){
+                var data = new StateData(features, value, lastState);
+                stateAndHistory.put(state, data);
+                samples.add(data);
+        }
+        
+        def getPredictionForNextDataSample(double[] features, double value, double[] featuresToPredict){        
+                if(samples.size <= 4){
+                        println('OK');
+                }       
+                var data = new StateData(features, value, null);
+                samples.add(data);
+                
+                // create training set from current data                
+                var double[][] xSamples = samples.map[it.features];
+                var double[] ySamples = samples.map[it.value];
+                
+                
+                regression.newSampleData(ySamples, xSamples);
+                var prediction = predict(featuresToPredict);    
+                
+                //remove the last element just added
+                samples.remove(samples.size - 1);
+                return prediction;
+        }
+        
+        def private predict(double[] featuresToPredict){
+                var parameters = regression.estimateRegressionParameters();
+                // the regression will add an initial column for 1's, the first parameter is constant term
+                var result = parameters.get(0);
+                for(var i = 0; i < featuresToPredict.length; i++){
+                        result += parameters.get(i+1) * featuresToPredict.get(i);
+                }
+                return result;
+        }
+        
+        def double[] calculateFeature(int step, int violations){
+                var features = newDoubleArrayOfSize(2);
+                //constant term
+                features.set(0, 1); //a
+                features.set(0, Math.sqrt(step) + 30) // b
+                features.set(1, 1.0 / (step + 30) );// c
+                
+                
+//              features.set(2, violations);
+//              features.set(3, Math.pow(violations, 2));
+                
+                return features;
+        }
+}
+
+class MetricDistanceGroup{
+        var double mpcDistance;
+        var double naDistance;
+        var double outDegreeDistance;
+        var double nodeTypeDistance;
+        protected var HashMap<String, Double> nodeTypeInfo;
+                
+        new(double mpcDistance, double naDistance, double outDegreeDistance, double nodeTypeDistance){
+                this.mpcDistance = mpcDistance;
+                this.naDistance = naDistance;
+                this.outDegreeDistance = outDegreeDistance;
+                this.nodeTypeDistance = nodeTypeDistance;
+        }
+        
+        new(double mpcDistance, double naDistance, double outDegreeDistance){
+                this.mpcDistance = mpcDistance;
+                this.naDistance = naDistance;
+                this.outDegreeDistance = outDegreeDistance;
+        }
+        
+        def double getNodeTypeDistance(){
+                return this.nodeTypeDistance;
+        }
+        
+        def double getMPCDistance(){
+                return this.mpcDistance
+        }
+        
+        def double getNADistance(){
+                return this.naDistance
+        }
+        
+        def double getOutDegreeDistance(){
+                return this.outDegreeDistance
+        }
+        
+        def double getNodeTypePercentage(String typeName){
+                return nodeTypeInfo.getOrDefault(typeName, 0.0);
+        }
+}
\ 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/CostDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/CostDistance.xtend
new file mode 100644
index 00000000..613f0f43
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/CostDistance.xtend
@@ -0,0 +1,38 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
+
+import java.text.DecimalFormat
+import java.util.HashMap
+import java.util.List
+import org.eclipse.xtend.lib.annotations.Accessors
+
+abstract class CostDistance {
+        def abstract double naDistance(List<Double> samples);   
+        def abstract double mpcDistance(List<Double> samples);
+        def abstract double outDegreeDistance(List<Double> samples);
+        
+        def protected pmfFromSamples(double[] samples, DecimalFormat formatter){
+                var length = samples.length;
+                var pmfMap = new HashMap<String, Double>();
+                
+                for(sample : samples){
+                        pmfMap.put(formatter.format(sample), pmfMap.getOrDefault(formatter.format(sample), 0.0) + 1.0 / length);
+                }
+                
+                return pmfMap;
+        }
+}
+
+class StateData{
+        @Accessors(PUBLIC_GETTER)
+        var double[] features;
+        @Accessors(PUBLIC_GETTER)
+        var double value;
+        @Accessors(PUBLIC_GETTER)
+        var Object lastState;
+        
+        new(double[] features, double value, Object lastState){
+                this.features = features;
+                this.value = value
+                this.lastState = lastState;
+        }
+}
\ 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/EuclideanDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/EuclideanDistance.xtend
new file mode 100644
index 00000000..d6adcc9a
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/EuclideanDistance.xtend
@@ -0,0 +1,72 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app.Domain
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.RepMetricsReader
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import com.google.common.collect.Sets
+import java.text.DecimalFormat
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+import java.util.Map
+import java.util.Set
+
+class EuclideanDistance extends CostDistance{
+        var MetricSampleGroup g;
+        var HashMap<String, Double> mpcPMF;
+        var HashMap<String, Double> naPMF;
+        var HashMap<String, Double> outDegreePMF;
+        var DecimalFormat formatter;
+        
+        new(MetricSampleGroup g){
+                this.g = g;
+                
+                var mpcSamples = g.mpcSamples;
+                var naSamples = g.naSamples.stream.mapToDouble([it]).toArray();
+                var outDegreeSamples = g.outDegreeSamples.stream.mapToDouble([it]).toArray();
+                
+                //needs to format the number to string avoid precision issue
+                formatter = new DecimalFormat("#0.00000");  
+                
+                mpcPMF = pmfFromSamples(mpcSamples, formatter);
+                naPMF = pmfFromSamples(naSamples, formatter);
+                outDegreePMF = pmfFromSamples(outDegreeSamples, formatter);     
+        }
+        
+        override naDistance(List<Double> samples) {
+                var pmfMap = pmfFromSamples(samples, formatter);
+                return euclideanDistance(pmfMap, naPMF);
+        }
+        
+        override mpcDistance(List<Double> samples) {
+                var pmfMap = pmfFromSamples(samples, formatter);
+                return euclideanDistance(pmfMap, mpcPMF);
+        }
+        
+        override outDegreeDistance(List<Double> samples) {
+                var pmfMap = pmfFromSamples(samples, formatter);
+                return euclideanDistance(pmfMap, outDegreePMF);
+        }
+        
+        
+        def private euclideanDistance(HashMap<String, Double> pmf1, HashMap<String, Double> pmf2){
+                var keys = Sets.union(pmf1.keySet(), pmf2.keySet());
+                var pmfList1 = pmfMapToList(pmf1, keys);
+                var pmfList2 = pmfMapToList(pmf2, keys);
+                var distance = 0.0;
+                for(var i = 0; i < pmfList1.size(); i++){
+                        distance += Math.pow(pmfList1.get(i) + pmfList2.get(i), 2);
+                }
+                
+                return Math.sqrt(distance);
+        }       
+        
+        def private pmfMapToList(Map<String, Double> map, Set<String> keys){
+                var list = new ArrayList<Double>();
+                for(key : keys){
+                        var value = map.getOrDefault(key, 0.0);
+                        list.add(value);
+                }
+                return list;
+        }
+}
\ 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/JSDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/JSDistance.xtend
new file mode 100644
index 00000000..4a0a0dc3
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/JSDistance.xtend
@@ -0,0 +1,88 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import com.google.common.collect.Sets
+import java.text.DecimalFormat
+import java.util.HashMap
+import java.util.List
+
+class JSDistance extends CostDistance {
+        var HashMap<String, Double> mpcPMF;
+        var HashMap<String, Double> naPMF;
+        var HashMap<String, Double> outDegreePMF;
+        var HashMap<String, Double> nodeTypesPMF;
+        var DecimalFormat formatter;
+        
+        new(MetricSampleGroup g){
+                var mpcSamples = g.mpcSamples;
+                var naSamples = g.naSamples.stream.mapToDouble([it]).toArray();
+                var outDegreeSamples = g.outDegreeSamples.stream.mapToDouble([it]).toArray();
+                
+                //needs to format the number to string avoid precision issue
+                formatter = new DecimalFormat("#0.00000");  
+                
+                mpcPMF = pmfFromSamples(mpcSamples, formatter);
+                naPMF = pmfFromSamples(naSamples, formatter);
+                outDegreePMF = pmfFromSamples(outDegreeSamples, formatter);     
+                nodeTypesPMF = g.nodeTypeSamples; 
+        }
+        
+        def private combinePMF(HashMap<String, Double> pmf1, HashMap<String, Double> pmf2){
+                var pmfMap = new HashMap<String, Double>();
+                
+                var union = Sets.union(pmf1.keySet(), pmf2.keySet());
+                
+                for(key : union){
+                        // corresponding to M in JS distance
+                        var value = 1.0/2 * (pmf1.getOrDefault(key, 0.0) + pmf2.getOrDefault(key, 0.0));
+                        pmfMap.put(key, value);
+                }
+                return pmfMap;
+        }
+        
+        def private jsDivergence(HashMap<String, Double> p, HashMap<String, Double> q){
+                val m = combinePMF(q, p);
+                var distance = 1.0/2 * klDivergence(p, m) + 1.0/2 * klDivergence(q, m);
+                return distance;
+        }
+        
+        def klDivergence(HashMap<String, Double> p, HashMap<String, Double> q){
+                var distance = 0.0;
+                for(key : q.keySet()){
+                        //need to convert log e to log 2
+                        if(p.containsKey(key)){
+                                distance -= p.get(key) * Math.log(q.get(key) / p.get(key)) / Math.log(2);
+                        }
+                }
+                return distance;
+        }
+        
+        override double mpcDistance(List<Double> samples){
+                // map list to array
+                var map = pmfFromSamples(samples.stream().mapToDouble([it]).toArray(), formatter);
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(map.size < 2) return 1;
+                return jsDivergence(map, mpcPMF);
+        }
+        
+        override double naDistance(List<Double> samples){
+                // map list to array
+                var map = pmfFromSamples(samples.stream().mapToDouble([it]).toArray(), formatter);
+                
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(map.size < 2) return 1;
+                return jsDivergence(map, naPMF);
+        }
+        
+        override double outDegreeDistance(List<Double> samples){
+                // map list to array
+                var map = pmfFromSamples(samples.stream().mapToDouble([it]).toArray(), formatter);
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(map.size < 2) return 1;
+                return jsDivergence(map, outDegreePMF);
+        }
+        
+        def nodeTypeDistance(HashMap<String, Double> samples){
+                return klDivergence(samples, nodeTypesPMF);
+        }
+}
\ 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..c486a328
--- /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,102 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import java.util.HashMap
+import java.util.HashSet
+import java.util.List
+import org.apache.commons.math3.stat.inference.KolmogorovSmirnovTest
+
+class KSDistance extends CostDistance {
+        var static ksTester = new KolmogorovSmirnovTest();
+        var MetricSampleGroup g;
+        
+        new(MetricSampleGroup g){
+                this.g = g;     
+        }
+        override double mpcDistance(List<Double> samples){
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(samples.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(g.mpcSamples, samples);
+        }
+        
+        override double naDistance(List<Double> samples){
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(samples.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(g.naSamples as double[], samples);
+        }
+        
+        override double outDegreeDistance(List<Double> samples){
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(samples.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(g.outDegreeSamples, samples);
+        }
+        
+        def double typedOutDegreeDistance(HashMap<String, List<Integer>> map){
+                var value = 0.0;
+                // map list to array
+                val keySet = new HashSet<String>(map.keySet);
+                keySet.addAll(g.typedOutDegreeSamples.keySet);
+                for(key : keySet){
+                        if(!map.containsKey(key) ){
+                                value += 1;
+                        }else if(!g.typedOutDegreeSamples.containsKey(key)){
+                                value += map.get(key).size * 100;       
+                        }else{
+                                var double[] rep = g.typedOutDegreeSamples.get(key).stream().mapToDouble([it|it]).toArray();
+                                var double[] ins = map.get(key).stream().mapToDouble([it|it]).toArray();
+                                if((rep.size < 2 || ins.size < 2) ){
+                                        if(rep.size < 2 && rep.containsAll(ins)){
+                                                value += 0;
+                                        }else{
+                                                value += 1;
+                                        }
+                                }else if(rep.size >= 2 && ins.size >= 2){
+                                        value += ksTester.kolmogorovSmirnovStatistic(rep, ins);
+                                }
+                        }
+                } 
+                
+                
+                return value;
+        }
+        
+        def nodeTypeDistance(HashMap<String, Double> samples){
+                var typesDistMap = g.nodeTypeSamples;
+                var sourceDist = newArrayList();
+                var instanceDist = newArrayList();
+                
+                for(key : typesDistMap.keySet()){
+                        sourceDist.add(typesDistMap.get(key));
+                        instanceDist.add(samples.getOrDefault(key, 0.0));
+                }
+                
+                return ks_distance_two_dist(sourceDist, instanceDist);
+        }
+        
+        def edgeTypeDistance(HashMap<String, Double> samples){
+                var typesDistMap = g.edgeTypeSamples;
+                var sourceDist = newArrayList();
+                var instanceDist = newArrayList();
+                
+                for(key : typesDistMap.keySet()){
+                        sourceDist.add(typesDistMap.get(key));
+                        instanceDist.add(samples.getOrDefault(key, 0.0));
+                }
+                
+                return ks_distance_two_dist(sourceDist, instanceDist);
+        }
+        
+        def double ks_distance_two_dist(List<Double> dist1, List<Double> dist2){
+                // Since we already know the pdf, we compute the ks-test manully
+                var ksStatistics = 0.0;
+                var sum1 = 0.0;
+                var sum2 = 0.0;
+                for(var i = 0; i < dist1.size(); i++){
+                        sum1 += dist1.get(i);
+                        sum2 += dist2.get(i);
+                        
+                        ksStatistics = Math.max(ksStatistics, Math.abs(sum1 - sum2));
+                } 
+                return ksStatistics;
+        }
+}
\ 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..8fa29fe6
--- /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,124 @@
+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.HashSet
+import java.util.List
+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.Accessors
+
+class EMFGraph extends Graph{   
+        @Accessors(PUBLIC_GETTER)
+        var EObject root;
+        
+        def void init (EObject root, List<Metric> metrics, String name, List<EReference> referenceTypes){
+                val otherContents = root.eAllContents.toList();
+                this.root = root;
+                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<EReference> referenceTypes){
+                objects.forEach[it|
+                        // TODO: Maybe want to consider all the super types as well
+                        var types = new HashSet();
+                        types.add(it.eClass.name);
+                        statistic.addNodeWithAllTypes(it, types);
+                ]
+                
+                referenceTypes.forEach[it|              
+                        // Only consider the edges that are not derived to preserve the statistical property
+                        if(!it.derived){
+                                statistic.addEdgeType(it.name);
+                        }
+                ];
+                
+                objects.forEach[source|
+                        source.eClass.EAllReferences.forEach[r|
+                                //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;
+        }
+        
+        def void removeReference(EReference r){
+                if (statistic.containsEdgeType(r.name)){
+                        statistic.removeReference(r.name, r.containment);
+                }
+        }
+        
+        /**
+         * 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){
+                //Only add the edge if the reference is not derived to preserve the statistical property
+                if(target !== null && r !== null && !r.derived){
+                        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..6b400b0d
--- /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,71 @@
+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 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 ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.TypedOutDegree
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeTypeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.EdgeTypeMetric
+
+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) as ArrayList<Double>;                                
+                        }else if(metric instanceof NodeActivityMetric){
+                                sample.naSamples = metric.evaluateSamples(this.statistic) as ArrayList<Double>;
+                        }else if(metric instanceof OutDegreeMetric){
+                                sample.outDegreeSamples = metric.evaluateSamples(this.statistic) as ArrayList<Double>;
+                        }else if(metric instanceof TypedOutDegree){
+                                sample.typedOutDegreeSamples = metric.evaluateSamples(this.statistic) as HashMap<String, List<Integer>>;
+                        }else if(metric instanceof NodeTypeMetric){
+                                sample.nodeTypeSamples = metric.evaluateSamples(this.statistic) as HashMap<String, Double>;
+                        }else if (metric instanceof EdgeTypeMetric){
+                                sample.edgeTypeSamples = metric.evaluateSamples(this.statistic) as HashMap<String, Double>;
+                        }
+                }
+                
+                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..31788bb2
--- /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,194 @@
+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 java.util.Map
+import java.util.Set
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.EReference
+
+class GraphStatistic {
+        val incomingEdges = new HashMap<String, Multimap<EObject, EObject>>;
+        val outgoingEdges = new HashMap<String, Multimap<EObject, EObject>>;
+
+        val edgeTypes = new HashSet<String>();
+        val nodeToType = new HashMap<EObject, Set<String>>();   
+
+        /**
+         * Add an edge type to to the graph
+         * @param type: type to add
+         */
+        def void addEdgeType(String type){
+                if(edgeTypes.contains(type)){
+                        return;
+                }
+                
+                edgeTypes.add(type);
+                incomingEdges.put(type, ArrayListMultimap.create());
+                outgoingEdges.put(type, ArrayListMultimap.create());
+        }
+        
+        /**
+         * Add a node to the graph with one type in its type hierarchy
+         * @param node: node to add
+         */
+         def void addNodeWithType(EObject n, String Type){
+                var types = nodeToType.getOrDefault(n, new HashSet<String>());
+                types.add(Type);
+                nodeToType.put(n, types);
+         }
+         
+         def boolean containsNode(EObject o){
+                return nodeToType.containsKey(o);
+         }
+         
+         def Set<String> getTypesForNode(EObject o){
+                return nodeToType.getOrDefault(o, new HashSet<String>());
+         }
+         
+         def void overwriteCurrentType(EObject o, String type){
+                var typeSet = nodeToType.getOrDefault(o, new HashSet<String>());
+                
+                // clear current types
+                typeSet.clear();
+                typeSet.add(type);
+                nodeToType.put(o, typeSet);
+         }
+         
+         /**
+          * Add a node to the graph with all types in its type hierarchy
+          */
+         def void addNodeWithAllTypes(EObject n, Set<String> types){
+                nodeToType.put(n, types);
+         }
+         
+         /**
+          * 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){
+                outgoingEdges.get(type).put(source, target);
+                incomingEdges.get(type).put(target, source);
+          }
+          
+          /**
+           * check if this graph contains a specific edge type
+           */
+           def boolean containsEdgeType(String typeName){
+                 if(outgoingEdges.containsKey(typeName) && 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
+            */
+            def removeReference(String name, boolean isContainment){
+                if(!edgeTypes.contains(name)){
+                        return;
+                }
+                
+                edgeTypes.remove(name);
+                var incomingSet = incomingEdges.remove(name);
+                outgoingEdges.remove(name);
+                
+                // if the reference is not a containment, then removing the reference is enough
+                if(!isContainment){
+                        return;
+                }
+                
+                // else remove all corresponding nodes
+                val nodesToRemove = incomingSet.keySet();
+                
+                //remove nodes from node sets
+                nodesToRemove.forEach[nodeToType.remove(it)];
+                
+                val removeForMultimap = [Multimap<EObject, EObject> refMap| 
+                        nodesToRemove.forEach[refMap.removeAll(it)];
+                        var values = refMap.values()
+                        //remove the values from the list is equavalent to remove it in the multimap
+                        values.removeAll(nodesToRemove); 
+                        return;
+                ];
+                
+                //remove nodes from all other references on incomingEdges
+                incomingEdges.values.forEach(removeForMultimap);
+                outgoingEdges.values.forEach(removeForMultimap);
+            }
+          
+          /**
+           * calculate the out degree for an object
+           */
+          def int outDegree(EObject o){
+                var count = 0;
+                
+                for (String type : edgeTypes){
+                        count += outgoingEdges.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() + outgoingEdges.get(type).get(o).size();
+          }
+          
+          /**
+           * calculate the number of edge types for a given node.
+           */
+          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 Map<EObject, Set<String>> getNodeToTypesMap(){
+                return nodeToType;
+          }
+          
+          def List<EObject> getAllNodes(){
+                return nodeToType.keySet().toList();
+          }
+          
+          def HashMap<String, Multimap<EObject, EObject>> getOutgoingEdges(){
+                return outgoingEdges; 
+          }
+          
+          def HashMap<String, Multimap<EObject, EObject>> incomingEdges(){
+                return incomingEdges; 
+          }
+          
+}
+
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..a2934eb9
--- /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,134 @@
+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.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.impl.PartialComplexTypeInterpretationImpl
+import java.util.ArrayList
+import java.util.List
+
+class PartialInterpretationGraph extends Graph{
+        val typeToExclude = "undefinedpart";
+        val classSuffix = " class";
+        
+        /**
+         * 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[
+                        //only need the name of the reference type (remove everything with and after "reference")
+                        var n = it.name.split(" ").get(0);
+                                this.statistic.addEdgeType(n);
+                ]
+                // add all elements
+                val typeInterpretations = getTypes(partial);
+                for(type : typeInterpretations){
+                        //Only consider the most concrete class
+                        if(isConcreteType(type.interpretationOf)){
+                                var typeName = type.interpretationOf.name.replace(classSuffix, '');
+                                for(node : type.elements){
+                                        if(!this.statistic.containsNode(node)){
+                                                this.statistic.addNodeWithType(node, typeName);
+                                        }else{
+                                                // if the current type of the node is a super type of the type to check, 
+                                                // substitute the current type with the new type
+                                                var currentType = statistic.getTypesForNode(node).get(0);
+                                                if(isSuperType(currentType, type.interpretationOf)){
+                                                        statistic.overwriteCurrentType(node, typeName);
+                                                }
+                                        }
+                                }
+                        }
+                }
+                
+                for(relationInterpretation : partial.partialrelationinterpretation) {
+                        //only need the name of the reference type (remove everything with and after "reference")
+                        val type = relationInterpretation.interpretationOf.name.split(" ").get(0);
+                        for(edge : relationInterpretation.relationlinks.filter(BinaryElementRelationLink)){
+                                statistic.addEdge(edge.param1, edge.param2, type);
+                        }       
+                }       
+                
+                this.name = name;
+                this.metrics = metrics; 
+        }
+        
+        /**
+         * recursively check if a type is the super type of another
+         */
+         def boolean isSuperType(String typeName, Type subtypeToCheck){
+                var superTypes = subtypeToCheck.supertypes;
+                if(superTypes.size == 0){
+                        return false;
+                }else if(subtypeToCheck.supertypes.map[it.name.replace(classSuffix, '')].contains(typeName)){
+                        return true;
+                }else{
+                        for(superType : superTypes){
+                                if(isSuperType(typeName, superType)){
+                                        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) 
+          */
+        def boolean isConcreteType(Type t){
+                if(!t.isAbstract || t.subtypes.findFirst[it instanceof TypeDefinition] !== null){
+                        return true;
+                }
+                return false;
+        }
+        
+        /**
+         * 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 getTypes(PartialInterpretation partial){
+                //only the complex type interpretations are the ones defined in meta model
+                //do not care about undefined types as it will be included in the class type
+                return partial.partialtypeinterpratation.filter(PartialComplexTypeInterpretationImpl)
+                                                                                                .filter[!it.interpretationOf.name.toLowerCase.contains(typeToExclude)];
+        }
+        
+        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..00b38d90
--- /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,52 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io;
+
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.FileOutputStream
+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;
+                }
+                val PrintWriter writer = new PrintWriter(new File(uri));
+                output(writer, datas, uri);
+        }
+        
+        def static void append(ArrayList<ArrayList<String>> datas, String uri) {
+                if(datas.size() <= 0) {
+                        return;
+                }
+                val PrintWriter writer = new PrintWriter(new FileOutputStream(new File(uri), true));
+                output(writer, datas, uri);
+        }
+        
+        
+        def private static void output(PrintWriter writer, ArrayList<ArrayList<String>> datas, String uri) {
+                //println("Output csv for " + uri);
+                try  {
+                        
+                        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..053e0da3
--- /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,112 @@
+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.EdgeTypeMetric
+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.NodeTypeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.TypedOutDegree
+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
+import org.eclipse.emf.ecore.EGenericType
+import org.eclipse.emf.ecore.EStructuralFeature
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.TypedClusteringCoefficientMetric
+
+class GraphReader{
+        val ResourceSet resSet = new ResourceSetImpl();
+        val referenceTypes = new ArrayList<EReference>();
+        var String suffix;
+        
+        new(EPackage metaModel, String suffix) {
+                Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("*",new XMIResourceFactoryImpl)
+                this.suffix = suffix;
+                
+                //find all reference types in the meta model
+                metaModel.eAllContents.forEach[
+                        if(it instanceof EReference){
+                                referenceTypes.add(it);
+                        }
+                ]
+        }
+        
+        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());
+                metrics.add(new TypedOutDegree());              
+                metrics.add(new NodeTypeMetric());
+                metrics.add(new EdgeTypeMetric());
+                var count = 1
+                //check all files in the directory with suffix
+                for(String name : dir.list.filter[it| it.endsWith(suffix)]){
+                        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(suffix, ""), referenceTypes);
+                        }
+
+                        count ++;
+                        graphs.add(g);
+                }
+                
+                return graphs;
+        }
+        
+        def EMFGraph readModel(String path, String filename){
+                val metrics = new ArrayList<Metric>();
+                metrics.add(new OutDegreeMetric());
+                metrics.add(new NodeActivityMetric());
+                metrics.add(new MultiplexParticipationCoefficientMetric());
+                metrics.add(new TypedOutDegree());              
+                metrics.add(new NodeTypeMetric());
+                metrics.add(new EdgeTypeMetric());
+                
+                val file = new File(filename);
+                val roots = readModel(EObject, path,  file.name);                       
+                //add a list of metrics
+                val g = new EMFGraph();
+                for(root : roots){
+                        g.init(root, metrics, filename.replaceFirst(suffix, ""), referenceTypes);
+                }
+                return g
+        }
+        
+        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 Exception(getURI(path, name).toString());
+                }
+        }
+        
+        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..2e7be586
--- /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,100 @@
+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.MetricSampleGroup
+import github.impl.GithubPackageImpl
+import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.impl.YakindummPackageImpl
+import java.util.HashMap
+import org.eclipse.emf.ecore.EReference
+import org.eclipse.emf.ecore.impl.EcorePackageImpl
+
+/**
+ * Read the sample of the distribution of a metric provided the csv file of the metric
+ */
+class RepMetricsReader {
+        static var Domain domain;
+        static def read(Domain d){
+                var GraphReader reader;
+                if(d == Domain.Yakindumm){
+                        reader = new GraphReader(YakindummPackageImpl.eINSTANCE, '.xmi');
+                }else if (d == Domain.Ecore){
+                        reader = new GraphReader(EcorePackageImpl.eINSTANCE, '.ecore');
+                }else if (d == Domain.Github){
+                        reader = new GraphReader(GithubPackageImpl.eINSTANCE, '.githubmodel')
+                }
+                
+                domain = d;
+                
+                var domainRepPath = DataName.REP_PATH + d.name + '/';
+                var rep = new MetricSampleGroup()
+                var out_d = readMetrics(reader, domainRepPath + DataName.OUT_D_REP);
+                var mpc = readMetrics(reader, domainRepPath + DataName.MPC_REP);
+                rep.mpcSamples = mpc.mpcSamples;
+                rep.outDegreeSamples = out_d.outDegreeSamples;
+                rep.naSamples = readMetrics(reader, domainRepPath + DataName.NA_REP).naSamples;
+                rep.typedOutDegreeSamples = out_d.typedOutDegreeSamples;
+                rep.edgeTypeSamples = mpc.edgeTypeSamples;
+                
+                //TODO: Parameterize the prior node distribution
+                var nodeTypeSamples = new HashMap<String, Double>();
+                if(d == Domain.Yakindumm){
+                        nodeTypeSamples.put('Entry', 0.04257802080554814);
+                        nodeTypeSamples.put('Choice', 0.1267671379034409);
+                        nodeTypeSamples.put('State', 0.1596092291277674);
+                        nodeTypeSamples.put('Transition', 0.6138636969858629);
+                        nodeTypeSamples.put('Statechart', 0.010136036276340358);
+                        nodeTypeSamples.put('Region', 0.04467858095492131);
+                        nodeTypeSamples.put('Exit', 0.0018338223526273673);
+                        nodeTypeSamples.put('FinalState', 0.0005334755934915977);
+                }else if(d ==Domain.Ecore){
+                        nodeTypeSamples.put('EAttribute', 0.23539778449144008);
+                        nodeTypeSamples.put('EClass', 0.33081570996978854);
+                        nodeTypeSamples.put('EReference', 0.30996978851963747);
+                        nodeTypeSamples.put('EPackage', 0.012789526686807653);
+                        nodeTypeSamples.put('EAnnotation', 0.002517623363544813);
+                        nodeTypeSamples.put('EEnumLiteral', 0.07275931520644502);
+                        nodeTypeSamples.put('EEnum', 0.013645518630412891);
+                        nodeTypeSamples.put('EDataType', 0.004028197381671702);
+                        nodeTypeSamples.put('EParameter', 0.005941591137965764);
+                        nodeTypeSamples.put('EGenericType', 0.002014098690835851);
+                        nodeTypeSamples.put('EOperation', 0.009415911379657605);
+                        nodeTypeSamples.put('ETypeParameter', 0.0007049345417925478);   
+                }else if (d == Domain.Github){
+                        nodeTypeSamples.put('Project', 0.012636538873420432);
+                        nodeTypeSamples.put('Commit', 0.5525808524309276);
+                        nodeTypeSamples.put('User', 0.05847076461769116);
+                        nodeTypeSamples.put('Issue', 0.12743628185907047);
+                        nodeTypeSamples.put('PullRequest', 0.07560505461554937);
+                        nodeTypeSamples.put('IssueEvent', 0.17327050760334123);
+                }
+                
+                
+                
+                rep.nodeTypeSamples = nodeTypeSamples;
+                return rep;
+        }
+        
+        /**
+         * Read representative model
+         */
+        private static def readMetrics(GraphReader r, String path){
+                val model = r.readModels(path).head;
+                if(domain == Domain.Ecore){
+                        var refsToRemove = EcorePackageImpl.eINSTANCE.eAllContents.filter(EReference).filter[
+                                it.name.equals('eGenericType') || it.name.equals('eGenericSuperTypes') || it.name.equals('eFactoryInstance') ||
+                                it.name.equals('eGenericExceptions') || it.name.equals('references') || it.name.equals('contents');
+                        ];
+                        refsToRemove.forEach[model.removeReference(it)];
+                }
+                return model.evaluateAllMetricsToSamples();
+        }
+        
+}
+
+class DataName{
+        public static val REP_PATH = 'data/';
+        public static val MPC_REP = 'mpc_rep';
+        public static val NA_REP = 'na_rep';
+        public static val OUT_D_REP = 'out_d_rep';
+}
+
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/EdgeTypeMetric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/EdgeTypeMetric.xtend
new file mode 100644
index 00000000..0c0fe3b8
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/EdgeTypeMetric.xtend
@@ -0,0 +1,41 @@
+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 EdgeTypeMetric extends Metric {
+        
+        override evaluate(GraphStatistic g) {
+                var map = evaluateSamples(g) as HashMap<String, Double>;
+                var output = new ArrayList<String[]>();
+                output.add(newArrayList('Edge Type'));
+                
+                var keys = map.keySet;
+                var values = newArrayList();
+                for(key : keys){
+                        values.add(map.get(key)+'');
+                }
+                
+                output.add(keys);
+                output.add(values);
+                
+                return output;
+        }
+        
+        override evaluateSamples(GraphStatistic g) {
+                val map = new HashMap<String, Double>();
+                var outgoingEdges = g.outgoingEdges;
+                
+                //get the total number of edges
+                val edgeCount = outgoingEdges.values.fold(0, [r, t| r + t.asMap.values.fold(0, [r1, t1| r1 + t1.size])]) as double;
+                outgoingEdges.forEach[k, v|
+                        var value = v.asMap.values.fold(0, [r, t| r + t.size]) / edgeCount;
+                        map.put(k, value);
+                ]
+                
+                        
+                return map;
+        }
+        
+}
\ 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/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..cb242a5b
--- /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 Object 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..4e25bb86
--- /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,13 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics
+
+import java.util.HashMap
+import java.util.List
+
+class MetricSampleGroup{
+        public var List<Double> mpcSamples;
+        public var List<Double> naSamples;
+        public var List<Double> outDegreeSamples;
+        public var HashMap<String, List<Integer>> typedOutDegreeSamples;
+        public var HashMap<String, Double> nodeTypeSamples;
+        public var HashMap<String, Double> edgeTypeSamples;
+}
\ 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..eafa49b2
--- /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";
+        val formatter = new DecimalFormat("#0.00000");    
+        
+        override evaluate(GraphStatistic g) {
+                //because the precision issue of double, we translate double values into String to be the key
+                 
+                
+                //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 Double.parseDouble(formatter.format(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/NodeTypeMetric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/NodeTypeMetric.xtend
new file mode 100644
index 00000000..7cec2513
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/NodeTypeMetric.xtend
@@ -0,0 +1,42 @@
+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 NodeTypeMetric extends Metric {
+        
+        
+        override evaluate(GraphStatistic g) {
+                var map = evaluateSamples(g) as HashMap<String, Double>;
+                var output = new ArrayList<String[]>();
+                output.add(newArrayList('Node Type'));
+                var keys = map.keySet;
+                var values = newArrayList();
+                
+                for(key : keys){
+                        values.add(map.get(key)+'');
+                }
+                
+                output.add(keys);
+                output.add(values);
+                
+                return output;
+        }
+        
+        override evaluateSamples(GraphStatistic g) {
+                var map = new HashMap<String, Double>();
+                var nodes = g.allNodes;
+                var single = 1.0 / nodes.size();
+                var nodeToType = g.nodeToTypesMap;
+                for(node : nodes){                      
+                        for(cl : nodeToType.get(node)){
+                                var value = map.getOrDefault(cl, 0.0);
+                                map.put(cl, value + single);
+                        }       
+                }
+                
+                return map;
+        }
+        
+}
\ 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/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/TypedClusteringCoefficientMetric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/TypedClusteringCoefficientMetric.xtend
new file mode 100644
index 00000000..0b6d61c6
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/TypedClusteringCoefficientMetric.xtend
@@ -0,0 +1,99 @@
+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 java.util.HashSet
+import org.eclipse.emf.ecore.EObject
+
+class TypedClusteringCoefficientMetric extends Metric {
+        public static val countName = "TCCCount";
+        public static val valueName = "TCCValue";
+        val formatter = new DecimalFormat("#0.00000");    
+        
+        override evaluate(GraphStatistic g) {
+                //because the precision issue of double, we translate double values into String to be the key
+                
+                val map = new HashMap<String, Integer>();
+                //calculate the metric distribution
+                g.allNodes.forEach[n|
+                        var coef = calculateTCC1(n, g);
+                        if(coef > 0){
+                                println(n);
+                        }
+                        //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>();
+                //calculate the metric distribution
+                g.allNodes.forEach[
+                        samples.add(calculateTCC1(it, g));
+                ]
+                
+                return samples;
+        }
+
+        /**
+         * Compute TCC1 metric for node n
+         */     
+        def double calculateTCC1(EObject n, GraphStatistic g){
+                var wedges = 0;
+                var triangles = 0;
+
+                for(type1 : g.allTypes){
+                        val typed1RelatedOfN = new HashSet<EObject>(g.outgoingEdges.get(type1).get(n));
+                        val type1EdgeSourceNodesOfN = new HashSet<EObject>(g.incomingEdges.get(type1).get(n));
+                        
+                        typed1RelatedOfN.addAll(type1EdgeSourceNodesOfN);
+                        
+                        
+                        
+                        // number of wedges
+                        val d = typed1RelatedOfN.size
+                        wedges += d * (d-1) // we will also count each closed triangle twice
+
+                        // pairs of neighbors
+                        for (n1: typed1RelatedOfN) {
+                                for (n2: typed1RelatedOfN) {
+                                        for(type2 : g.allTypes){
+                                                if ((type1 != type2) &&
+                                                        (g.outgoingEdges.get(type2).containsEntry(n1, n2) || 
+                                                         g.outgoingEdges.get(type2).containsEntry(n2, n1)
+                                                        )) {
+                                                        triangles++
+                                                }                                       
+                                        }
+                                }
+                        }
+                }               
+                
+                if (wedges == 0.0) {
+                        return 0.0
+                } else {
+                        return (triangles as double)/wedges
+                }
+        }
+}
\ 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/TypedOutDegree.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/TypedOutDegree.xtend
new file mode 100644
index 00000000..3b5dbcc5
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/metrics/TypedOutDegree.xtend
@@ -0,0 +1,60 @@
+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
+import java.util.List
+
+class TypedOutDegree extends Metric{
+        
+        def private calculateMetric(GraphStatistic g){
+                var outgoingEdges = g.outgoingEdges;
+                //record metric as a list of samples for each node type / edge type pair
+                var metric = new HashMap<String, List<Integer>>();
+                var nodeToTypes = g.nodeToTypesMap;
+                
+                for(edgeType : outgoingEdges.keySet){
+                        for(node : outgoingEdges.get(edgeType).keySet){
+                                //find all classes the node belongs to
+                                var classes = nodeToTypes.get(node);
+                                for(cl : classes){
+                                        // get or create entry for node type / edge type pair
+                                        var key = cl + ' ' + edgeType;
+                                        var typeCount = metric.get(key);
+                                        if(typeCount === null){
+                                                typeCount = new ArrayList<Integer>();
+                                                metric.put(key, typeCount);
+                                        }
+                                        
+                                        // get or create sample list
+                                        typeCount.add(outgoingEdges.get(edgeType).get(node).size);
+                                }
+                        }
+                }
+                
+                return metric;
+        }
+        
+        override evaluate(GraphStatistic g) {
+                var metric = calculateMetric(g);
+                var output = new ArrayList<String[]>();
+                
+                output.add(newArrayList('Typed Out Degree'));
+                for(key : metric.keySet){
+                        var samples = metric.get(key);
+                        var String[] outputForOnePair = newArrayOfSize(samples.size+1);
+                        outputForOnePair.set(0, key);
+                        for(var i = 0; i < samples.size; i++){
+                                outputForOnePair.set(i+1, samples.get(i)+'');
+                        }
+                        output.add(outputForOnePair);
+                }
+                
+                return output;
+        }
+        
+        override evaluateSamples(GraphStatistic g) {
+                return calculateMetric(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/predictor/LinearModel.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/predictor/LinearModel.xtend
new file mode 100644
index 00000000..f0ded347
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/predictor/LinearModel.xtend
@@ -0,0 +1,91 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.predictor
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.StateData
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+import java.util.Map
+import weka.core.matrix.LinearRegression
+import weka.core.matrix.Matrix
+
+class LinearModel {
+        var double ridge;
+        var Map<Object, StateData> stateAndHistory;
+        List<StateData> samples;
+        
+        new(double ridge){
+                this.ridge = ridge;
+                stateAndHistory = new HashMap<Object, StateData>();
+                samples = new ArrayList<StateData>();
+        }
+        
+        /**
+         * reset the current train data for regression to a new trajectory
+         * @param state: the last state of the trajectory
+         */
+        def resetRegression(Object state){
+                samples.clear();
+                
+                if(stateAndHistory.containsKey(state)){
+                        var data = stateAndHistory.get(state);
+                        var curState = state;
+                        
+                        samples.add(data);
+                        
+                        //loop through data until the oldest state in the record
+                        while(stateAndHistory.containsKey(data.lastState) && data.lastState != curState){
+                                curState = data.lastState;
+                                data = stateAndHistory.get(data.lastState);
+                                samples.add(data);
+                        }
+                }
+        }
+        
+        /**
+         * Add a new data point to the current training set
+         * @param state: the state on which the new data point is calculated
+         * @param features: the set of feature value(x)
+         * @param value: the value of the state (y)
+         * @param lastState: the state which transformed to current state, used to record the trajectory
+         */
+        def feedData(Object state, double[] features, double value, Object lastState){
+                var data = new StateData(features, value, lastState);
+                stateAndHistory.put(state, data);
+                samples.add(data);
+        }
+        
+        /**
+         * get prediction for next state, without storing the data point into the training set
+         * @param features: the feature values of current state
+         * @param value: the value of the current state
+         * @param: featuresToPredict: the features of the state wanted to be predected
+         * @return the value of the state to be predicted
+         */
+        def double getPredictionForNextDataSample(double[] features, double value, double[] featuresToPredict){         
+                var data = new StateData(features, value, null);
+                samples.add(data);
+                
+                // create training set from current data                
+                val double[][] xSamples = samples.map[it.features];
+                val double[] ySamples = samples.map[it.value];
+                
+                val x = new Matrix(xSamples);
+                val y = new Matrix(ySamples, ySamples.size());  
+                
+                val regression = new LinearRegression(x, y, ridge);
+                var prediction = predict(regression.coefficients, featuresToPredict);   
+                
+                //remove the last element just added
+                samples.remove(samples.size - 1);
+                return prediction;
+        }
+        
+        def private predict(double[] parameters, double[] featuresToPredict){
+                // the regression will add an initial column for 1's, the first parameter is constant term
+                var result = parameters.get(0);
+                for(var i = 0; i < featuresToPredict.length; i++){
+                        result += parameters.get(i) * featuresToPredict.get(i);
+                }
+                return result;
+        }
+}
\ 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/validation/ConstraintCollection.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/validation/ConstraintCollection.xtend
new file mode 100644
index 00000000..685c5836
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/validation/ConstraintCollection.xtend
@@ -0,0 +1,80 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.validation
+
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+import java.util.Map
+import org.eclipse.emf.common.notify.Notifier
+import org.eclipse.emf.common.util.URI
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedPatternGroup
+import org.eclipse.viatra.query.runtime.emf.EMFScope
+
+class ConstraintCollection{
+        val constraints = new ArrayList<IConstraintSpecification>();
+        var BaseGeneratedPatternGroup patterns;
+        var List<Notifier> resources = new ArrayList<Notifier>(); 
+        
+        
+        new(List<IConstraintSpecification> constraints, List<String> uris, BaseGeneratedPatternGroup patterns){
+                this.constraints.addAll(constraints);
+                this.patterns = patterns;
+                setURIs(uris);
+        }
+        
+        new(List<IConstraintSpecification> constraints, BaseGeneratedPatternGroup patterns){
+                this.constraints.addAll(constraints);
+                this.patterns = patterns;
+        }
+        
+        def addModel(Notifier n ){
+                resources.add(n);
+        }
+        
+        def setURIs(List<String> uris){
+                val resSet = new ResourceSetImpl();
+                
+                for(uri : uris){
+                        var resource = resSet.getResource(URI.createURI(uri), true);
+                        resources.add(resource);
+                }
+        
+                println('reading model finished')
+        }
+        
+        def List<Integer> calculateViolations(){
+                var results = new ArrayList<Integer>();
+                
+                for(resource : resources){
+                        val engine = initEngine(resource);
+                        var matches = constraints.stream.mapToInt([ele| ele.querySpecification.getMatcher(engine).countMatches]).sum();
+                        results.add(matches);
+                }
+                
+                return results;
+        }
+        
+        def ArrayList<Map<String, Integer>> calculateViolationMaps(){
+                val result = new ArrayList<Map<String, Integer>>()
+                
+                for(resource : resources){
+                        val map = new HashMap<String, Integer>();
+                        val engine = initEngine(resource);
+                        constraints.forEach[
+                                var count = it.querySpecification.getMatcher(engine).countMatches;
+                                map.put(it.querySpecification.simpleName, count);
+                        ];
+                        result.add(map);
+                }
+                return result;
+        }
+        
+        private def initEngine(Notifier r){
+                var engine = ViatraQueryEngine.on(new EMFScope(r));
+                //init patterns with the new engine
+                patterns.prepare(engine);
+                return engine;
+        }
+}
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/validation/ViolationCheck.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/validation/ViolationCheck.xtend
new file mode 100644
index 00000000..4db5f940
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/validation/ViolationCheck.xtend
@@ -0,0 +1,66 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.validation
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app.Domain
+import com.google.common.reflect.ClassPath
+import ecore.Ecore
+import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.Patterns
+import java.util.ArrayList
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.viatra.addon.validation.core.api.IConstraintSpecification
+
+class ViolationCheck {
+        /**
+         * Return the total number of violations
+         */
+        def static int calculateViolationCounts(EObject root, Domain d){
+                var packageName = '';
+                if(d == Domain.Yakindumm){
+                        packageName = 'constraints.yakindumm';
+                }else if (d == Domain.Ecore){
+                        packageName = 'constraints.ecore';
+                }else if (d == Domain.Github){
+                        return -1;
+                }
+                
+                var constriants = loadConstraints(packageName);
+                var collections = new ConstraintCollection(constriants, Ecore.instance);
+                collections.addModel(root);
+                var results = collections.calculateViolations();
+                if(results.size > 0){
+                        return results.get(0);
+                }else{
+                        throw new IllegalArgumentException("Calculate Violation Failed");
+                }
+        }
+        
+        /**
+         * return a map contain the count for each type of violation
+         */
+        def static violationMaps(EObject root){
+                var constriants = loadConstraints('hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu');
+                var collections = new ConstraintCollection(constriants, Patterns.instance);
+                collections.addModel(root);
+                var results = collections.calculateViolationMaps();
+                if(results.size > 0){
+                        return results.get(0);
+                }else{
+                        throw new IllegalArgumentException("Calculate Violation Failed");
+                }
+        }
+        
+        def static loadConstraints(String packageName){
+                val constraints = new ArrayList<IConstraintSpecification>();
+                
+                val classPath = ClassPath.from(ClassLoader.systemClassLoader);
+                val classInfos = classPath.getTopLevelClasses(packageName);
+                for(info : classInfos){
+                        if(info.load.interfaces.contains(IConstraintSpecification)){
+                                //IConstraintSpecification only has one constructor with empty argument list
+                                var constructor = info.load.constructors.get(0);
+                                var instance = constructor.newInstance();
+                                constraints.add(instance as IConstraintSpecification);
+                        }
+                }
+                return constraints
+        }
+}