35 files changed, 13068 insertions, 0 deletions

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/.gitignore b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/.gitignore
new file mode 100644
index 00000000..d3114d9d
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/.gitignore
@@ -0,0 +1,44 @@
+/.CpsApplications.java._trace
+/.CpsQueries.java._trace
+/.CpsHosts.java._trace
+/.TotalMemory.java._trace
+/.TotalHdd.java._trace
+/.AvailableMemory.java._trace
+/.AvailableHdd.java._trace
+/.AllocationWithoutResourceRequirement.java._trace
+/.NotEnoughAvailableMemory.java._trace
+/.NotEnoughAvailableHdd.java._trace
+/.InstanceDoesNotSatisfyRequirement.java._trace
+/.RequirementNotSatisfied.java._trace
+/.AverageFreeMemoryMetric.java._trace
+/.AverageFreeHddMetric.java._trace
+/.CostMetric.java._trace
+/.CpsCost.java._trace
+/.RedundantInstancesOnSameHost.java._trace
+/.Allocate.java._trace
+/.CpsTransformationRules.java._trace
+/.ResourceRequirement.java._trace
+/.CreateInstance.java._trace
+/.CreateHostInstance.java._trace
+/.UnallocatedAppInstance.java._trace
+/.RequiredAppInstances.java._trace
+/.GuidanceObjective.java._trace
+/.RemoveHostInstance.java._trace
+/.UnallocateAppInstance.java._trace
+/Allocate.java
+/AllocationWithoutResourceRequirement.java
+/AverageFreeHddMetric.java
+/AverageFreeMemoryMetric.java
+/CostMetric.java
+/CpsCost.java
+/CpsQueries.java
+/CreateHostInstance.java
+/GuidanceObjective.java
+/InstanceDoesNotSatisfyRequirement.java
+/NotEnoughAvailableHdd.java
+/NotEnoughAvailableMemory.java
+/RedundantInstancesOnSameHost.java
+/RemoveHostInstance.java
+/RequirementNotSatisfied.java
+/ResourceRequirement.java
+/UnallocateAppInstance.java
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/Allocate.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/Allocate.java
new file mode 100644
index 00000000..1fc70124
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/Allocate.java
@@ -0,0 +1,873 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.AvailableHdd;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.AvailableMemory;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.UnallocatedAppInstance;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+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.EDataType;
+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.EDataTypeInSlotsKey;
+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.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+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.basicdeferred.ExpressionEvaluation;
+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>
+ *         //
+ *         // Transformation rule preconditions for rule-based DSE
+ *         //
+ *         
+ *         pattern allocate(App : ApplicationInstance, Host : HostInstance) {
+ *              ApplicationInstance.type.requirements(App, Req);
+ *              ResourceRequirement.hostType.instances(Req, Host);
+ *              find unallocatedAppInstance(App);
+ *              find availableMemory(Host, AvailableMem);
+ *              find availableHdd(Host, AvailableHdd);
+ *              ResourceRequirement.requiredMemory(Req, RequiredMem);
+ *              ResourceRequirement.requiredHdd(Req, RequiredHdd);
+ *              check(AvailableMem {@literal >}= RequiredMem);
+ *              check(AvailableHdd {@literal >}= RequiredHdd);
+ *              neg ApplicationInstance.requirement.instances.allocatedTo(App, Host);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class Allocate extends BaseGeneratedEMFQuerySpecification<Allocate.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.allocate 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 ApplicationInstance fApp;
+    
+    private HostInstance fHost;
+    
+    private static List<String> parameterNames = makeImmutableList("App", "Host");
+    
+    private Match(final ApplicationInstance pApp, final HostInstance pHost) {
+      this.fApp = pApp;
+      this.fHost = pHost;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "App": return this.fApp;
+          case "Host": return this.fHost;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fApp;
+          case 1: return this.fHost;
+          default: return null;
+      }
+    }
+    
+    public ApplicationInstance getApp() {
+      return this.fApp;
+    }
+    
+    public HostInstance getHost() {
+      return this.fHost;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("App".equals(parameterName) ) {
+          this.fApp = (ApplicationInstance) newValue;
+          return true;
+      }
+      if ("Host".equals(parameterName) ) {
+          this.fHost = (HostInstance) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setApp(final ApplicationInstance pApp) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fApp = pApp;
+    }
+    
+    public void setHost(final HostInstance pHost) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fHost = pHost;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.allocate";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return Allocate.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fApp, fHost};
+    }
+    
+    @Override
+    public Allocate.Match toImmutable() {
+      return isMutable() ? newMatch(fApp, fHost) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"App\"=" + prettyPrintValue(fApp) + ", ");
+      result.append("\"Host\"=" + prettyPrintValue(fHost));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fApp, fHost);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof Allocate.Match)) {
+          Allocate.Match other = (Allocate.Match) obj;
+          return Objects.equals(fApp, other.fApp) && Objects.equals(fHost, other.fHost);
+      } 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 Allocate specification() {
+      return Allocate.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 Allocate.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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static Allocate.Match newMutableMatch(final ApplicationInstance pApp, final HostInstance pHost) {
+      return new Mutable(pApp, pHost);
+    }
+    
+    /**
+     * 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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static Allocate.Match newMatch(final ApplicationInstance pApp, final HostInstance pHost) {
+      return new Immutable(pApp, pHost);
+    }
+    
+    private static final class Mutable extends Allocate.Match {
+      Mutable(final ApplicationInstance pApp, final HostInstance pHost) {
+        super(pApp, pHost);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends Allocate.Match {
+      Immutable(final ApplicationInstance pApp, final HostInstance pHost) {
+        super(pApp, pHost);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.allocate 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>
+   * //
+   * // Transformation rule preconditions for rule-based DSE
+   * //
+   * 
+   * pattern allocate(App : ApplicationInstance, Host : HostInstance) {
+   *    ApplicationInstance.type.requirements(App, Req);
+   *    ResourceRequirement.hostType.instances(Req, Host);
+   *    find unallocatedAppInstance(App);
+   *    find availableMemory(Host, AvailableMem);
+   *    find availableHdd(Host, AvailableHdd);
+   *    ResourceRequirement.requiredMemory(Req, RequiredMem);
+   *    ResourceRequirement.requiredHdd(Req, RequiredHdd);
+   *    check(AvailableMem {@literal >}= RequiredMem);
+   *    check(AvailableHdd {@literal >}= RequiredHdd);
+   *    neg ApplicationInstance.requirement.instances.allocatedTo(App, Host);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see Allocate
+   * 
+   */
+  public static class Matcher extends BaseMatcher<Allocate.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 Allocate.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 Allocate.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_APP = 0;
+    
+    private static final int POSITION_HOST = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(Allocate.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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<Allocate.Match> getAllMatches(final ApplicationInstance pApp, final HostInstance pHost) {
+      return rawStreamAllMatches(new Object[]{pApp, pHost}).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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<Allocate.Match> streamAllMatches(final ApplicationInstance pApp, final HostInstance pHost) {
+      return rawStreamAllMatches(new Object[]{pApp, pHost});
+    }
+    
+    /**
+     * 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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<Allocate.Match> getOneArbitraryMatch(final ApplicationInstance pApp, final HostInstance pHost) {
+      return rawGetOneArbitraryMatch(new Object[]{pApp, pHost});
+    }
+    
+    /**
+     * 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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final ApplicationInstance pApp, final HostInstance pHost) {
+      return rawHasMatch(new Object[]{pApp, pHost});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final ApplicationInstance pApp, final HostInstance pHost) {
+      return rawCountMatches(new Object[]{pApp, pHost});
+    }
+    
+    /**
+     * 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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pHost the fixed value of pattern parameter Host, 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 ApplicationInstance pApp, final HostInstance pHost, final Consumer<? super Allocate.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pApp, pHost}, 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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public Allocate.Match newMatch(final ApplicationInstance pApp, final HostInstance pHost) {
+      return Allocate.Match.newMatch(pApp, pHost);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<ApplicationInstance> rawStreamAllValuesOfApp(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_APP, parameters).map(ApplicationInstance.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp() {
+      return rawStreamAllValuesOfApp(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<ApplicationInstance> streamAllValuesOfApp() {
+      return rawStreamAllValuesOfApp(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * </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<ApplicationInstance> streamAllValuesOfApp(final Allocate.Match partialMatch) {
+      return rawStreamAllValuesOfApp(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * </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<ApplicationInstance> streamAllValuesOfApp(final HostInstance pHost) {
+      return rawStreamAllValuesOfApp(new Object[]{null, pHost});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp(final Allocate.Match partialMatch) {
+      return rawStreamAllValuesOfApp(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp(final HostInstance pHost) {
+      return rawStreamAllValuesOfApp(new Object[]{null, pHost}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<HostInstance> rawStreamAllValuesOfHost(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_HOST, parameters).map(HostInstance.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHost() {
+      return rawStreamAllValuesOfHost(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<HostInstance> streamAllValuesOfHost() {
+      return rawStreamAllValuesOfHost(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * </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<HostInstance> streamAllValuesOfHost(final Allocate.Match partialMatch) {
+      return rawStreamAllValuesOfHost(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * </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<HostInstance> streamAllValuesOfHost(final ApplicationInstance pApp) {
+      return rawStreamAllValuesOfHost(new Object[]{pApp, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHost(final Allocate.Match partialMatch) {
+      return rawStreamAllValuesOfHost(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHost(final ApplicationInstance pApp) {
+      return rawStreamAllValuesOfHost(new Object[]{pApp, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected Allocate.Match tupleToMatch(final Tuple t) {
+      try {
+          return Allocate.Match.newMatch((ApplicationInstance) t.get(POSITION_APP), (HostInstance) t.get(POSITION_HOST));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected Allocate.Match arrayToMatch(final Object[] match) {
+      try {
+          return Allocate.Match.newMatch((ApplicationInstance) match[POSITION_APP], (HostInstance) match[POSITION_HOST]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected Allocate.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return Allocate.Match.newMutableMatch((ApplicationInstance) match[POSITION_APP], (HostInstance) match[POSITION_HOST]);
+      } 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<Allocate.Matcher> querySpecification() {
+      return Allocate.instance();
+    }
+  }
+  
+  private Allocate() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static Allocate instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected Allocate.Matcher instantiate(final ViatraQueryEngine engine) {
+    return Allocate.Matcher.on(engine);
+  }
+  
+  @Override
+  public Allocate.Matcher instantiate() {
+    return Allocate.Matcher.create();
+  }
+  
+  @Override
+  public Allocate.Match newEmptyMatch() {
+    return Allocate.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public Allocate.Match newMatch(final Object... parameters) {
+    return Allocate.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance) parameters[0], (hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link Allocate} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link Allocate#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final Allocate INSTANCE = new Allocate();
+    
+    /**
+     * 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 Allocate.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_App = new PParameter("App", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_App, parameter_Host);
+    
+    private class Embedded_1_ApplicationInstance_requirement_instances_allocatedTo extends BaseGeneratedEMFPQuery {
+      private final PParameter parameter_p0 = new PParameter("p0", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+      
+      private final PParameter parameter_p1 = new PParameter("p1", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+      
+      private final List<PParameter> embeddedParameters = Arrays.asList(parameter_p0, parameter_p1);
+      
+      public Embedded_1_ApplicationInstance_requirement_instances_allocatedTo() {
+        super(PVisibility.EMBEDDED);
+      }
+      
+      @Override
+      public String getFullyQualifiedName() {
+        return GeneratedPQuery.this.getFullyQualifiedName() + "$Embedded_1_ApplicationInstance_requirement_instances_allocatedTo";
+      }
+      
+      @Override
+      public List<PParameter> getParameters() {
+        return embeddedParameters;
+      }
+      
+      @Override
+      public Set<PBody> doGetContainedBodies() {
+        PBody body = new PBody(this);
+        PVariable var_p0 = body.getOrCreateVariableByName("p0");
+        PVariable var_p1 = body.getOrCreateVariableByName("p1");
+        body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+           new ExportedParameter(body, var_p0, parameter_p0),
+           new ExportedParameter(body, var_p1, parameter_p1)
+        ));
+        //  ApplicationInstance.requirement.instances.allocatedTo(App, Host)
+        new TypeConstraint(body, Tuples.flatTupleOf(var_p0), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+        PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+        new TypeConstraint(body, Tuples.flatTupleOf(var_p0, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "requirement")));
+        new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+        PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+        new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "Requirement", "instances")));
+        new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+        PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+        new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "allocatedTo")));
+        new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+        new Equality(body, var__virtual_2_, var_p1);
+        return Collections.singleton(body);
+      }
+    }
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.allocate";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("App","Host");
+    }
+    
+    @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_App = body.getOrCreateVariableByName("App");
+          PVariable var_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_Req = body.getOrCreateVariableByName("Req");
+          PVariable var_AvailableMem = body.getOrCreateVariableByName("AvailableMem");
+          PVariable var_AvailableHdd = body.getOrCreateVariableByName("AvailableHdd");
+          PVariable var_RequiredMem = body.getOrCreateVariableByName("RequiredMem");
+          PVariable var_RequiredHdd = body.getOrCreateVariableByName("RequiredHdd");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_App, parameter_App),
+             new ExportedParameter(body, var_Host, parameter_Host)
+          ));
+          //    ApplicationInstance.type.requirements(App, Req)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "type")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationType")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationType", "requirements")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ResourceRequirement")));
+          new Equality(body, var__virtual_1_, var_Req);
+          //    ResourceRequirement.hostType.instances(Req, Host)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ResourceRequirement")));
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ResourceRequirement", "hostType")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostType")));
+          PVariable var__virtual_3_ = body.getOrCreateVariableByName(".virtual{3}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_, var__virtual_3_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "HostType", "instances")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_3_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new Equality(body, var__virtual_3_, var_Host);
+          //    find unallocatedAppInstance(App)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_App), UnallocatedAppInstance.instance().getInternalQueryRepresentation());
+          //    find availableMemory(Host, AvailableMem)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_AvailableMem), AvailableMemory.instance().getInternalQueryRepresentation());
+          //    find availableHdd(Host, AvailableHdd)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_AvailableHdd), AvailableHdd.instance().getInternalQueryRepresentation());
+          //    ResourceRequirement.requiredMemory(Req, RequiredMem)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ResourceRequirement")));
+          PVariable var__virtual_4_ = body.getOrCreateVariableByName(".virtual{4}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_4_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ResourceRequirement", "requiredMemory")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_4_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          new Equality(body, var__virtual_4_, var_RequiredMem);
+          //    ResourceRequirement.requiredHdd(Req, RequiredHdd)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ResourceRequirement")));
+          PVariable var__virtual_5_ = body.getOrCreateVariableByName(".virtual{5}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_5_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ResourceRequirement", "requiredHdd")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_5_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          new Equality(body, var__virtual_5_, var_RequiredHdd);
+          //    check(AvailableMem >= RequiredMem)
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern allocate";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("AvailableMem", "RequiredMem");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer AvailableMem = (Integer) provider.getValue("AvailableMem");
+                  Integer RequiredMem = (Integer) provider.getValue("RequiredMem");
+                  return evaluateExpression_1_1(AvailableMem, RequiredMem);
+              }
+          },  null); 
+          //    check(AvailableHdd >= RequiredHdd)
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern allocate";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("AvailableHdd", "RequiredHdd");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer AvailableHdd = (Integer) provider.getValue("AvailableHdd");
+                  Integer RequiredHdd = (Integer) provider.getValue("RequiredHdd");
+                  return evaluateExpression_1_2(AvailableHdd, RequiredHdd);
+              }
+          },  null); 
+          //    neg ApplicationInstance.requirement.instances.allocatedTo(App, Host)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_App, var_Host), new Allocate.GeneratedPQuery.Embedded_1_ApplicationInstance_requirement_instances_allocatedTo());
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+  
+  private static boolean evaluateExpression_1_1(final Integer AvailableMem, final Integer RequiredMem) {
+    boolean _greaterEqualsThan = (AvailableMem.compareTo(RequiredMem) >= 0);
+    return _greaterEqualsThan;
+  }
+  
+  private static boolean evaluateExpression_1_2(final Integer AvailableHdd, final Integer RequiredHdd) {
+    boolean _greaterEqualsThan = (AvailableHdd.compareTo(RequiredHdd) >= 0);
+    return _greaterEqualsThan;
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/AllocationWithoutResourceRequirement.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/AllocationWithoutResourceRequirement.java
new file mode 100644
index 00000000..b49fee74
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/AllocationWithoutResourceRequirement.java
@@ -0,0 +1,728 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.ResourceRequirement;
+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.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.NegativePatternCall;
+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(severity = "error", key = {Host, App},
+ *              message = "Application instance must be allocated to a supported host type.")
+ *         pattern allocationWithoutResourceRequirement(Host : HostInstance, App : ApplicationInstance) {
+ *              ApplicationInstance.allocatedTo(App, Host);
+ *              neg find resourceRequirement(Host, App, _);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class AllocationWithoutResourceRequirement extends BaseGeneratedEMFQuerySpecification<AllocationWithoutResourceRequirement.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.allocationWithoutResourceRequirement 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 HostInstance fHost;
+    
+    private ApplicationInstance fApp;
+    
+    private static List<String> parameterNames = makeImmutableList("Host", "App");
+    
+    private Match(final HostInstance pHost, final ApplicationInstance pApp) {
+      this.fHost = pHost;
+      this.fApp = pApp;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Host": return this.fHost;
+          case "App": return this.fApp;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fHost;
+          case 1: return this.fApp;
+          default: return null;
+      }
+    }
+    
+    public HostInstance getHost() {
+      return this.fHost;
+    }
+    
+    public ApplicationInstance getApp() {
+      return this.fApp;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Host".equals(parameterName) ) {
+          this.fHost = (HostInstance) newValue;
+          return true;
+      }
+      if ("App".equals(parameterName) ) {
+          this.fApp = (ApplicationInstance) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setHost(final HostInstance pHost) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fHost = pHost;
+    }
+    
+    public void setApp(final ApplicationInstance pApp) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fApp = pApp;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.allocationWithoutResourceRequirement";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return AllocationWithoutResourceRequirement.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fHost, fApp};
+    }
+    
+    @Override
+    public AllocationWithoutResourceRequirement.Match toImmutable() {
+      return isMutable() ? newMatch(fHost, fApp) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Host\"=" + prettyPrintValue(fHost) + ", ");
+      result.append("\"App\"=" + prettyPrintValue(fApp));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fHost, fApp);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof AllocationWithoutResourceRequirement.Match)) {
+          AllocationWithoutResourceRequirement.Match other = (AllocationWithoutResourceRequirement.Match) obj;
+          return Objects.equals(fHost, other.fHost) && Objects.equals(fApp, other.fApp);
+      } 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 AllocationWithoutResourceRequirement specification() {
+      return AllocationWithoutResourceRequirement.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 AllocationWithoutResourceRequirement.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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static AllocationWithoutResourceRequirement.Match newMutableMatch(final HostInstance pHost, final ApplicationInstance pApp) {
+      return new Mutable(pHost, pApp);
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static AllocationWithoutResourceRequirement.Match newMatch(final HostInstance pHost, final ApplicationInstance pApp) {
+      return new Immutable(pHost, pApp);
+    }
+    
+    private static final class Mutable extends AllocationWithoutResourceRequirement.Match {
+      Mutable(final HostInstance pHost, final ApplicationInstance pApp) {
+        super(pHost, pApp);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends AllocationWithoutResourceRequirement.Match {
+      Immutable(final HostInstance pHost, final ApplicationInstance pApp) {
+        super(pHost, pApp);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.allocationWithoutResourceRequirement 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(severity = "error", key = {Host, App},
+   *    message = "Application instance must be allocated to a supported host type.")
+   * pattern allocationWithoutResourceRequirement(Host : HostInstance, App : ApplicationInstance) {
+   *    ApplicationInstance.allocatedTo(App, Host);
+   *    neg find resourceRequirement(Host, App, _);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see AllocationWithoutResourceRequirement
+   * 
+   */
+  public static class Matcher extends BaseMatcher<AllocationWithoutResourceRequirement.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 AllocationWithoutResourceRequirement.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 AllocationWithoutResourceRequirement.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_HOST = 0;
+    
+    private static final int POSITION_APP = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(AllocationWithoutResourceRequirement.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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<AllocationWithoutResourceRequirement.Match> getAllMatches(final HostInstance pHost, final ApplicationInstance pApp) {
+      return rawStreamAllMatches(new Object[]{pHost, pApp}).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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<AllocationWithoutResourceRequirement.Match> streamAllMatches(final HostInstance pHost, final ApplicationInstance pApp) {
+      return rawStreamAllMatches(new Object[]{pHost, pApp});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<AllocationWithoutResourceRequirement.Match> getOneArbitraryMatch(final HostInstance pHost, final ApplicationInstance pApp) {
+      return rawGetOneArbitraryMatch(new Object[]{pHost, pApp});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final HostInstance pHost, final ApplicationInstance pApp) {
+      return rawHasMatch(new Object[]{pHost, pApp});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final HostInstance pHost, final ApplicationInstance pApp) {
+      return rawCountMatches(new Object[]{pHost, pApp});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, 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 HostInstance pHost, final ApplicationInstance pApp, final Consumer<? super AllocationWithoutResourceRequirement.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pHost, pApp}, 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public AllocationWithoutResourceRequirement.Match newMatch(final HostInstance pHost, final ApplicationInstance pApp) {
+      return AllocationWithoutResourceRequirement.Match.newMatch(pHost, pApp);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<HostInstance> rawStreamAllValuesOfHost(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_HOST, parameters).map(HostInstance.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHost() {
+      return rawStreamAllValuesOfHost(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<HostInstance> streamAllValuesOfHost() {
+      return rawStreamAllValuesOfHost(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * </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<HostInstance> streamAllValuesOfHost(final AllocationWithoutResourceRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfHost(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * </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<HostInstance> streamAllValuesOfHost(final ApplicationInstance pApp) {
+      return rawStreamAllValuesOfHost(new Object[]{null, pApp});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHost(final AllocationWithoutResourceRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfHost(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHost(final ApplicationInstance pApp) {
+      return rawStreamAllValuesOfHost(new Object[]{null, pApp}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<ApplicationInstance> rawStreamAllValuesOfApp(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_APP, parameters).map(ApplicationInstance.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp() {
+      return rawStreamAllValuesOfApp(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<ApplicationInstance> streamAllValuesOfApp() {
+      return rawStreamAllValuesOfApp(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * </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<ApplicationInstance> streamAllValuesOfApp(final AllocationWithoutResourceRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfApp(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * </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<ApplicationInstance> streamAllValuesOfApp(final HostInstance pHost) {
+      return rawStreamAllValuesOfApp(new Object[]{pHost, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp(final AllocationWithoutResourceRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfApp(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp(final HostInstance pHost) {
+      return rawStreamAllValuesOfApp(new Object[]{pHost, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected AllocationWithoutResourceRequirement.Match tupleToMatch(final Tuple t) {
+      try {
+          return AllocationWithoutResourceRequirement.Match.newMatch((HostInstance) t.get(POSITION_HOST), (ApplicationInstance) t.get(POSITION_APP));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected AllocationWithoutResourceRequirement.Match arrayToMatch(final Object[] match) {
+      try {
+          return AllocationWithoutResourceRequirement.Match.newMatch((HostInstance) match[POSITION_HOST], (ApplicationInstance) match[POSITION_APP]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected AllocationWithoutResourceRequirement.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return AllocationWithoutResourceRequirement.Match.newMutableMatch((HostInstance) match[POSITION_HOST], (ApplicationInstance) match[POSITION_APP]);
+      } 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<AllocationWithoutResourceRequirement.Matcher> querySpecification() {
+      return AllocationWithoutResourceRequirement.instance();
+    }
+  }
+  
+  private AllocationWithoutResourceRequirement() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static AllocationWithoutResourceRequirement instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected AllocationWithoutResourceRequirement.Matcher instantiate(final ViatraQueryEngine engine) {
+    return AllocationWithoutResourceRequirement.Matcher.on(engine);
+  }
+  
+  @Override
+  public AllocationWithoutResourceRequirement.Matcher instantiate() {
+    return AllocationWithoutResourceRequirement.Matcher.create();
+  }
+  
+  @Override
+  public AllocationWithoutResourceRequirement.Match newEmptyMatch() {
+    return AllocationWithoutResourceRequirement.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public AllocationWithoutResourceRequirement.Match newMatch(final Object... parameters) {
+    return AllocationWithoutResourceRequirement.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance) parameters[0], (hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link AllocationWithoutResourceRequirement} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link AllocationWithoutResourceRequirement#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final AllocationWithoutResourceRequirement INSTANCE = new AllocationWithoutResourceRequirement();
+    
+    /**
+     * 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 AllocationWithoutResourceRequirement.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_App = new PParameter("App", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host, parameter_App);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.allocationWithoutResourceRequirement";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host","App");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_App = body.getOrCreateVariableByName("App");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host),
+             new ExportedParameter(body, var_App, parameter_App)
+          ));
+          //    ApplicationInstance.allocatedTo(App, Host)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "allocatedTo")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new Equality(body, var__virtual_0_, var_Host);
+          //    neg find resourceRequirement(Host, App, _)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_Host, var_App, var___0_), ResourceRequirement.instance().getInternalQueryRepresentation());
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("Host"), 
+                              new ParameterReference("App")
+                              }));
+          annotation.addAttribute("message", "Application instance must be allocated to a supported host type.");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/AverageFreeHddMetric.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/AverageFreeHddMetric.java
new file mode 100644
index 00000000..607854bf
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/AverageFreeHddMetric.java
@@ -0,0 +1,554 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.FreeHddPercentage;
+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.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.matchers.aggregators.avg;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+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.AggregatorConstraint;
+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.TypeFilterConstraint;
+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>
+ *         // Free HDD
+ *         
+ *         pattern averageFreeHddMetric(Average : java Double) {
+ *              Average == avg find freeHddPercentage(_, #_);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class AverageFreeHddMetric extends BaseGeneratedEMFQuerySpecification<AverageFreeHddMetric.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.averageFreeHddMetric 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 Double fAverage;
+    
+    private static List<String> parameterNames = makeImmutableList("Average");
+    
+    private Match(final Double pAverage) {
+      this.fAverage = pAverage;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Average": return this.fAverage;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fAverage;
+          default: return null;
+      }
+    }
+    
+    public Double getAverage() {
+      return this.fAverage;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Average".equals(parameterName) ) {
+          this.fAverage = (Double) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setAverage(final Double pAverage) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fAverage = pAverage;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.averageFreeHddMetric";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return AverageFreeHddMetric.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fAverage};
+    }
+    
+    @Override
+    public AverageFreeHddMetric.Match toImmutable() {
+      return isMutable() ? newMatch(fAverage) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Average\"=" + prettyPrintValue(fAverage));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fAverage);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof AverageFreeHddMetric.Match)) {
+          AverageFreeHddMetric.Match other = (AverageFreeHddMetric.Match) obj;
+          return Objects.equals(fAverage, other.fAverage);
+      } 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 AverageFreeHddMetric specification() {
+      return AverageFreeHddMetric.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 AverageFreeHddMetric.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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static AverageFreeHddMetric.Match newMutableMatch(final Double pAverage) {
+      return new Mutable(pAverage);
+    }
+    
+    /**
+     * 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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static AverageFreeHddMetric.Match newMatch(final Double pAverage) {
+      return new Immutable(pAverage);
+    }
+    
+    private static final class Mutable extends AverageFreeHddMetric.Match {
+      Mutable(final Double pAverage) {
+        super(pAverage);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends AverageFreeHddMetric.Match {
+      Immutable(final Double pAverage) {
+        super(pAverage);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.averageFreeHddMetric 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>
+   * // Free HDD
+   * 
+   * pattern averageFreeHddMetric(Average : java Double) {
+   *    Average == avg find freeHddPercentage(_, #_);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see AverageFreeHddMetric
+   * 
+   */
+  public static class Matcher extends BaseMatcher<AverageFreeHddMetric.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 AverageFreeHddMetric.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 AverageFreeHddMetric.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_AVERAGE = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(AverageFreeHddMetric.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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<AverageFreeHddMetric.Match> getAllMatches(final Double pAverage) {
+      return rawStreamAllMatches(new Object[]{pAverage}).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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<AverageFreeHddMetric.Match> streamAllMatches(final Double pAverage) {
+      return rawStreamAllMatches(new Object[]{pAverage});
+    }
+    
+    /**
+     * 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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<AverageFreeHddMetric.Match> getOneArbitraryMatch(final Double pAverage) {
+      return rawGetOneArbitraryMatch(new Object[]{pAverage});
+    }
+    
+    /**
+     * 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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Double pAverage) {
+      return rawHasMatch(new Object[]{pAverage});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Double pAverage) {
+      return rawCountMatches(new Object[]{pAverage});
+    }
+    
+    /**
+     * 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 pAverage the fixed value of pattern parameter Average, 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 Double pAverage, final Consumer<? super AverageFreeHddMetric.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pAverage}, 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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public AverageFreeHddMetric.Match newMatch(final Double pAverage) {
+      return AverageFreeHddMetric.Match.newMatch(pAverage);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Average.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Double> rawStreamAllValuesOfAverage(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_AVERAGE, parameters).map(Double.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Average.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Double> getAllValuesOfAverage() {
+      return rawStreamAllValuesOfAverage(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Average.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Double> streamAllValuesOfAverage() {
+      return rawStreamAllValuesOfAverage(emptyArray());
+    }
+    
+    @Override
+    protected AverageFreeHddMetric.Match tupleToMatch(final Tuple t) {
+      try {
+          return AverageFreeHddMetric.Match.newMatch((Double) t.get(POSITION_AVERAGE));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected AverageFreeHddMetric.Match arrayToMatch(final Object[] match) {
+      try {
+          return AverageFreeHddMetric.Match.newMatch((Double) match[POSITION_AVERAGE]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected AverageFreeHddMetric.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return AverageFreeHddMetric.Match.newMutableMatch((Double) match[POSITION_AVERAGE]);
+      } 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<AverageFreeHddMetric.Matcher> querySpecification() {
+      return AverageFreeHddMetric.instance();
+    }
+  }
+  
+  private AverageFreeHddMetric() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static AverageFreeHddMetric instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected AverageFreeHddMetric.Matcher instantiate(final ViatraQueryEngine engine) {
+    return AverageFreeHddMetric.Matcher.on(engine);
+  }
+  
+  @Override
+  public AverageFreeHddMetric.Matcher instantiate() {
+    return AverageFreeHddMetric.Matcher.create();
+  }
+  
+  @Override
+  public AverageFreeHddMetric.Match newEmptyMatch() {
+    return AverageFreeHddMetric.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public AverageFreeHddMetric.Match newMatch(final Object... parameters) {
+    return AverageFreeHddMetric.Match.newMatch((java.lang.Double) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link AverageFreeHddMetric} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link AverageFreeHddMetric#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final AverageFreeHddMetric INSTANCE = new AverageFreeHddMetric();
+    
+    /**
+     * 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 AverageFreeHddMetric.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Average = new PParameter("Average", "java.lang.Double", new JavaTransitiveInstancesKey(java.lang.Double.class), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Average);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.averageFreeHddMetric";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Average");
+    }
+    
+    @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_Average = body.getOrCreateVariableByName("Average");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          PVariable var___1_ = body.getOrCreateVariableByName("_<1>");
+          new TypeFilterConstraint(body, Tuples.flatTupleOf(var_Average), new JavaTransitiveInstancesKey(java.lang.Double.class));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Average, parameter_Average)
+          ));
+          //    Average == avg find freeHddPercentage(_, #_)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new AggregatorConstraint(new avg().getAggregatorLogic(Double.class), body, Tuples.flatTupleOf(var___0_, var___1_), FreeHddPercentage.instance().getInternalQueryRepresentation(), var__virtual_0_, 1);
+          new Equality(body, var_Average, var__virtual_0_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/AverageFreeMemoryMetric.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/AverageFreeMemoryMetric.java
new file mode 100644
index 00000000..627a5f89
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/AverageFreeMemoryMetric.java
@@ -0,0 +1,562 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.FreeMemoryPercentage;
+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.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.matchers.aggregators.avg;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+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.AggregatorConstraint;
+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.TypeFilterConstraint;
+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>
+ *         //
+ *         // Metrics
+ *         //
+ *         
+ *         // Free memory
+ *         
+ *         pattern averageFreeMemoryMetric(Average : java Double) {
+ *              Average == avg find freeMemoryPercentage(_, #_);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class AverageFreeMemoryMetric extends BaseGeneratedEMFQuerySpecification<AverageFreeMemoryMetric.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.averageFreeMemoryMetric 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 Double fAverage;
+    
+    private static List<String> parameterNames = makeImmutableList("Average");
+    
+    private Match(final Double pAverage) {
+      this.fAverage = pAverage;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Average": return this.fAverage;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fAverage;
+          default: return null;
+      }
+    }
+    
+    public Double getAverage() {
+      return this.fAverage;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Average".equals(parameterName) ) {
+          this.fAverage = (Double) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setAverage(final Double pAverage) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fAverage = pAverage;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.averageFreeMemoryMetric";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return AverageFreeMemoryMetric.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fAverage};
+    }
+    
+    @Override
+    public AverageFreeMemoryMetric.Match toImmutable() {
+      return isMutable() ? newMatch(fAverage) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Average\"=" + prettyPrintValue(fAverage));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fAverage);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof AverageFreeMemoryMetric.Match)) {
+          AverageFreeMemoryMetric.Match other = (AverageFreeMemoryMetric.Match) obj;
+          return Objects.equals(fAverage, other.fAverage);
+      } 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 AverageFreeMemoryMetric specification() {
+      return AverageFreeMemoryMetric.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 AverageFreeMemoryMetric.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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static AverageFreeMemoryMetric.Match newMutableMatch(final Double pAverage) {
+      return new Mutable(pAverage);
+    }
+    
+    /**
+     * 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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static AverageFreeMemoryMetric.Match newMatch(final Double pAverage) {
+      return new Immutable(pAverage);
+    }
+    
+    private static final class Mutable extends AverageFreeMemoryMetric.Match {
+      Mutable(final Double pAverage) {
+        super(pAverage);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends AverageFreeMemoryMetric.Match {
+      Immutable(final Double pAverage) {
+        super(pAverage);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.averageFreeMemoryMetric 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>
+   * //
+   * // Metrics
+   * //
+   * 
+   * // Free memory
+   * 
+   * pattern averageFreeMemoryMetric(Average : java Double) {
+   *    Average == avg find freeMemoryPercentage(_, #_);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see AverageFreeMemoryMetric
+   * 
+   */
+  public static class Matcher extends BaseMatcher<AverageFreeMemoryMetric.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 AverageFreeMemoryMetric.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 AverageFreeMemoryMetric.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_AVERAGE = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(AverageFreeMemoryMetric.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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<AverageFreeMemoryMetric.Match> getAllMatches(final Double pAverage) {
+      return rawStreamAllMatches(new Object[]{pAverage}).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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<AverageFreeMemoryMetric.Match> streamAllMatches(final Double pAverage) {
+      return rawStreamAllMatches(new Object[]{pAverage});
+    }
+    
+    /**
+     * 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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<AverageFreeMemoryMetric.Match> getOneArbitraryMatch(final Double pAverage) {
+      return rawGetOneArbitraryMatch(new Object[]{pAverage});
+    }
+    
+    /**
+     * 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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Double pAverage) {
+      return rawHasMatch(new Object[]{pAverage});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Double pAverage) {
+      return rawCountMatches(new Object[]{pAverage});
+    }
+    
+    /**
+     * 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 pAverage the fixed value of pattern parameter Average, 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 Double pAverage, final Consumer<? super AverageFreeMemoryMetric.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pAverage}, 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 pAverage the fixed value of pattern parameter Average, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public AverageFreeMemoryMetric.Match newMatch(final Double pAverage) {
+      return AverageFreeMemoryMetric.Match.newMatch(pAverage);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Average.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Double> rawStreamAllValuesOfAverage(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_AVERAGE, parameters).map(Double.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Average.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Double> getAllValuesOfAverage() {
+      return rawStreamAllValuesOfAverage(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Average.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Double> streamAllValuesOfAverage() {
+      return rawStreamAllValuesOfAverage(emptyArray());
+    }
+    
+    @Override
+    protected AverageFreeMemoryMetric.Match tupleToMatch(final Tuple t) {
+      try {
+          return AverageFreeMemoryMetric.Match.newMatch((Double) t.get(POSITION_AVERAGE));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected AverageFreeMemoryMetric.Match arrayToMatch(final Object[] match) {
+      try {
+          return AverageFreeMemoryMetric.Match.newMatch((Double) match[POSITION_AVERAGE]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected AverageFreeMemoryMetric.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return AverageFreeMemoryMetric.Match.newMutableMatch((Double) match[POSITION_AVERAGE]);
+      } 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<AverageFreeMemoryMetric.Matcher> querySpecification() {
+      return AverageFreeMemoryMetric.instance();
+    }
+  }
+  
+  private AverageFreeMemoryMetric() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static AverageFreeMemoryMetric instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected AverageFreeMemoryMetric.Matcher instantiate(final ViatraQueryEngine engine) {
+    return AverageFreeMemoryMetric.Matcher.on(engine);
+  }
+  
+  @Override
+  public AverageFreeMemoryMetric.Matcher instantiate() {
+    return AverageFreeMemoryMetric.Matcher.create();
+  }
+  
+  @Override
+  public AverageFreeMemoryMetric.Match newEmptyMatch() {
+    return AverageFreeMemoryMetric.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public AverageFreeMemoryMetric.Match newMatch(final Object... parameters) {
+    return AverageFreeMemoryMetric.Match.newMatch((java.lang.Double) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link AverageFreeMemoryMetric} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link AverageFreeMemoryMetric#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final AverageFreeMemoryMetric INSTANCE = new AverageFreeMemoryMetric();
+    
+    /**
+     * 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 AverageFreeMemoryMetric.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Average = new PParameter("Average", "java.lang.Double", new JavaTransitiveInstancesKey(java.lang.Double.class), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Average);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.averageFreeMemoryMetric";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Average");
+    }
+    
+    @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_Average = body.getOrCreateVariableByName("Average");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          PVariable var___1_ = body.getOrCreateVariableByName("_<1>");
+          new TypeFilterConstraint(body, Tuples.flatTupleOf(var_Average), new JavaTransitiveInstancesKey(java.lang.Double.class));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Average, parameter_Average)
+          ));
+          //    Average == avg find freeMemoryPercentage(_, #_)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new AggregatorConstraint(new avg().getAggregatorLogic(Double.class), body, Tuples.flatTupleOf(var___0_, var___1_), FreeMemoryPercentage.instance().getInternalQueryRepresentation(), var__virtual_0_, 1);
+          new Equality(body, var_Average, var__virtual_0_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CostMetric.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CostMetric.java
new file mode 100644
index 00000000..eff44f0a
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CostMetric.java
@@ -0,0 +1,554 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.CpsCost;
+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.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.matchers.aggregators.sum;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+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.AggregatorConstraint;
+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.TypeFilterConstraint;
+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>
+ *         // Total cost
+ *         
+ *         pattern costMetric(Cost : java Integer) {
+ *              Cost == sum find cpsCost(_, #_);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class CostMetric extends BaseGeneratedEMFQuerySpecification<CostMetric.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.costMetric 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 Integer fCost;
+    
+    private static List<String> parameterNames = makeImmutableList("Cost");
+    
+    private Match(final Integer pCost) {
+      this.fCost = pCost;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Cost": return this.fCost;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fCost;
+          default: return null;
+      }
+    }
+    
+    public Integer getCost() {
+      return this.fCost;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Cost".equals(parameterName) ) {
+          this.fCost = (Integer) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setCost(final Integer pCost) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fCost = pCost;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.costMetric";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return CostMetric.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fCost};
+    }
+    
+    @Override
+    public CostMetric.Match toImmutable() {
+      return isMutable() ? newMatch(fCost) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Cost\"=" + prettyPrintValue(fCost));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fCost);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof CostMetric.Match)) {
+          CostMetric.Match other = (CostMetric.Match) obj;
+          return Objects.equals(fCost, other.fCost);
+      } 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 CostMetric specification() {
+      return CostMetric.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 CostMetric.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 pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static CostMetric.Match newMutableMatch(final Integer pCost) {
+      return new Mutable(pCost);
+    }
+    
+    /**
+     * 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 pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static CostMetric.Match newMatch(final Integer pCost) {
+      return new Immutable(pCost);
+    }
+    
+    private static final class Mutable extends CostMetric.Match {
+      Mutable(final Integer pCost) {
+        super(pCost);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends CostMetric.Match {
+      Immutable(final Integer pCost) {
+        super(pCost);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.costMetric 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>
+   * // Total cost
+   * 
+   * pattern costMetric(Cost : java Integer) {
+   *    Cost == sum find cpsCost(_, #_);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see CostMetric
+   * 
+   */
+  public static class Matcher extends BaseMatcher<CostMetric.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 CostMetric.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 CostMetric.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_COST = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(CostMetric.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 pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<CostMetric.Match> getAllMatches(final Integer pCost) {
+      return rawStreamAllMatches(new Object[]{pCost}).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 pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<CostMetric.Match> streamAllMatches(final Integer pCost) {
+      return rawStreamAllMatches(new Object[]{pCost});
+    }
+    
+    /**
+     * 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 pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<CostMetric.Match> getOneArbitraryMatch(final Integer pCost) {
+      return rawGetOneArbitraryMatch(new Object[]{pCost});
+    }
+    
+    /**
+     * 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 pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Integer pCost) {
+      return rawHasMatch(new Object[]{pCost});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Integer pCost) {
+      return rawCountMatches(new Object[]{pCost});
+    }
+    
+    /**
+     * 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 pCost the fixed value of pattern parameter Cost, 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 Integer pCost, final Consumer<? super CostMetric.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pCost}, 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 pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public CostMetric.Match newMatch(final Integer pCost) {
+      return CostMetric.Match.newMatch(pCost);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cost.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Integer> rawStreamAllValuesOfCost(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_COST, parameters).map(Integer.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cost.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Integer> getAllValuesOfCost() {
+      return rawStreamAllValuesOfCost(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cost.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Integer> streamAllValuesOfCost() {
+      return rawStreamAllValuesOfCost(emptyArray());
+    }
+    
+    @Override
+    protected CostMetric.Match tupleToMatch(final Tuple t) {
+      try {
+          return CostMetric.Match.newMatch((Integer) t.get(POSITION_COST));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected CostMetric.Match arrayToMatch(final Object[] match) {
+      try {
+          return CostMetric.Match.newMatch((Integer) match[POSITION_COST]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected CostMetric.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return CostMetric.Match.newMutableMatch((Integer) match[POSITION_COST]);
+      } 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<CostMetric.Matcher> querySpecification() {
+      return CostMetric.instance();
+    }
+  }
+  
+  private CostMetric() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static CostMetric instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected CostMetric.Matcher instantiate(final ViatraQueryEngine engine) {
+    return CostMetric.Matcher.on(engine);
+  }
+  
+  @Override
+  public CostMetric.Matcher instantiate() {
+    return CostMetric.Matcher.create();
+  }
+  
+  @Override
+  public CostMetric.Match newEmptyMatch() {
+    return CostMetric.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public CostMetric.Match newMatch(final Object... parameters) {
+    return CostMetric.Match.newMatch((java.lang.Integer) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link CostMetric} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link CostMetric#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final CostMetric INSTANCE = new CostMetric();
+    
+    /**
+     * 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 CostMetric.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Cost = new PParameter("Cost", "java.lang.Integer", new JavaTransitiveInstancesKey(java.lang.Integer.class), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Cost);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.costMetric";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Cost");
+    }
+    
+    @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_Cost = body.getOrCreateVariableByName("Cost");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          PVariable var___1_ = body.getOrCreateVariableByName("_<1>");
+          new TypeFilterConstraint(body, Tuples.flatTupleOf(var_Cost), new JavaTransitiveInstancesKey(java.lang.Integer.class));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Cost, parameter_Cost)
+          ));
+          //    Cost == sum find cpsCost(_, #_)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new AggregatorConstraint(new sum().getAggregatorLogic(Integer.class), body, Tuples.flatTupleOf(var___0_, var___1_), CpsCost.instance().getInternalQueryRepresentation(), var__virtual_0_, 1);
+          new Equality(body, var_Cost, var__virtual_0_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsCost.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsCost.java
new file mode 100644
index 00000000..1cf09b0d
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsCost.java
@@ -0,0 +1,749 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.CpsApplications;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.HostInstanceCost;
+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.aggregators.sum;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+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.AggregatorConstraint;
+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.ExpressionEvaluation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.PatternMatchCounter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint;
+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 cpsCost(Cps : CyberPhysicalSystem, Cost : java Integer) {
+ *              AppCount == count find cpsApplications(Cps, _);
+ *              HostCost == sum find hostInstanceCost(Cps, _, #_);
+ *              Cost == eval(5  AppCount + HostCost);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class CpsCost extends BaseGeneratedEMFQuerySpecification<CpsCost.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.cpsCost 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 CyberPhysicalSystem fCps;
+    
+    private Integer fCost;
+    
+    private static List<String> parameterNames = makeImmutableList("Cps", "Cost");
+    
+    private Match(final CyberPhysicalSystem pCps, final Integer pCost) {
+      this.fCps = pCps;
+      this.fCost = pCost;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Cps": return this.fCps;
+          case "Cost": return this.fCost;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fCps;
+          case 1: return this.fCost;
+          default: return null;
+      }
+    }
+    
+    public CyberPhysicalSystem getCps() {
+      return this.fCps;
+    }
+    
+    public Integer getCost() {
+      return this.fCost;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Cps".equals(parameterName) ) {
+          this.fCps = (CyberPhysicalSystem) newValue;
+          return true;
+      }
+      if ("Cost".equals(parameterName) ) {
+          this.fCost = (Integer) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setCps(final CyberPhysicalSystem pCps) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fCps = pCps;
+    }
+    
+    public void setCost(final Integer pCost) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fCost = pCost;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.cpsCost";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return CpsCost.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fCps, fCost};
+    }
+    
+    @Override
+    public CpsCost.Match toImmutable() {
+      return isMutable() ? newMatch(fCps, fCost) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Cps\"=" + prettyPrintValue(fCps) + ", ");
+      result.append("\"Cost\"=" + prettyPrintValue(fCost));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fCps, fCost);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof CpsCost.Match)) {
+          CpsCost.Match other = (CpsCost.Match) obj;
+          return Objects.equals(fCps, other.fCps) && Objects.equals(fCost, other.fCost);
+      } 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 CpsCost specification() {
+      return CpsCost.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 CpsCost.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 pCps the fixed value of pattern parameter Cps, or null if not bound.
+     * @param pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static CpsCost.Match newMutableMatch(final CyberPhysicalSystem pCps, final Integer pCost) {
+      return new Mutable(pCps, pCost);
+    }
+    
+    /**
+     * 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 pCps the fixed value of pattern parameter Cps, or null if not bound.
+     * @param pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static CpsCost.Match newMatch(final CyberPhysicalSystem pCps, final Integer pCost) {
+      return new Immutable(pCps, pCost);
+    }
+    
+    private static final class Mutable extends CpsCost.Match {
+      Mutable(final CyberPhysicalSystem pCps, final Integer pCost) {
+        super(pCps, pCost);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends CpsCost.Match {
+      Immutable(final CyberPhysicalSystem pCps, final Integer pCost) {
+        super(pCps, pCost);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.cpsCost 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 cpsCost(Cps : CyberPhysicalSystem, Cost : java Integer) {
+   *    AppCount == count find cpsApplications(Cps, _);
+   *    HostCost == sum find hostInstanceCost(Cps, _, #_);
+   *    Cost == eval(5  AppCount + HostCost);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see CpsCost
+   * 
+   */
+  public static class Matcher extends BaseMatcher<CpsCost.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 CpsCost.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 CpsCost.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_CPS = 0;
+    
+    private static final int POSITION_COST = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(CpsCost.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 pCps the fixed value of pattern parameter Cps, or null if not bound.
+     * @param pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<CpsCost.Match> getAllMatches(final CyberPhysicalSystem pCps, final Integer pCost) {
+      return rawStreamAllMatches(new Object[]{pCps, pCost}).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 pCps the fixed value of pattern parameter Cps, or null if not bound.
+     * @param pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<CpsCost.Match> streamAllMatches(final CyberPhysicalSystem pCps, final Integer pCost) {
+      return rawStreamAllMatches(new Object[]{pCps, pCost});
+    }
+    
+    /**
+     * 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 pCps the fixed value of pattern parameter Cps, or null if not bound.
+     * @param pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<CpsCost.Match> getOneArbitraryMatch(final CyberPhysicalSystem pCps, final Integer pCost) {
+      return rawGetOneArbitraryMatch(new Object[]{pCps, pCost});
+    }
+    
+    /**
+     * 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 pCps the fixed value of pattern parameter Cps, or null if not bound.
+     * @param pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final CyberPhysicalSystem pCps, final Integer pCost) {
+      return rawHasMatch(new Object[]{pCps, pCost});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pCps the fixed value of pattern parameter Cps, or null if not bound.
+     * @param pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final CyberPhysicalSystem pCps, final Integer pCost) {
+      return rawCountMatches(new Object[]{pCps, pCost});
+    }
+    
+    /**
+     * 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 pCps the fixed value of pattern parameter Cps, or null if not bound.
+     * @param pCost the fixed value of pattern parameter Cost, 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 CyberPhysicalSystem pCps, final Integer pCost, final Consumer<? super CpsCost.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pCps, pCost}, 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 pCps the fixed value of pattern parameter Cps, or null if not bound.
+     * @param pCost the fixed value of pattern parameter Cost, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public CpsCost.Match newMatch(final CyberPhysicalSystem pCps, final Integer pCost) {
+      return CpsCost.Match.newMatch(pCps, pCost);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cps.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<CyberPhysicalSystem> rawStreamAllValuesOfCps(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_CPS, parameters).map(CyberPhysicalSystem.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cps.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<CyberPhysicalSystem> getAllValuesOfCps() {
+      return rawStreamAllValuesOfCps(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cps.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<CyberPhysicalSystem> streamAllValuesOfCps() {
+      return rawStreamAllValuesOfCps(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cps.
+     * </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<CyberPhysicalSystem> streamAllValuesOfCps(final CpsCost.Match partialMatch) {
+      return rawStreamAllValuesOfCps(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cps.
+     * </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<CyberPhysicalSystem> streamAllValuesOfCps(final Integer pCost) {
+      return rawStreamAllValuesOfCps(new Object[]{null, pCost});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cps.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<CyberPhysicalSystem> getAllValuesOfCps(final CpsCost.Match partialMatch) {
+      return rawStreamAllValuesOfCps(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cps.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<CyberPhysicalSystem> getAllValuesOfCps(final Integer pCost) {
+      return rawStreamAllValuesOfCps(new Object[]{null, pCost}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cost.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Integer> rawStreamAllValuesOfCost(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_COST, parameters).map(Integer.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cost.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Integer> getAllValuesOfCost() {
+      return rawStreamAllValuesOfCost(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cost.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Integer> streamAllValuesOfCost() {
+      return rawStreamAllValuesOfCost(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cost.
+     * </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<Integer> streamAllValuesOfCost(final CpsCost.Match partialMatch) {
+      return rawStreamAllValuesOfCost(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cost.
+     * </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<Integer> streamAllValuesOfCost(final CyberPhysicalSystem pCps) {
+      return rawStreamAllValuesOfCost(new Object[]{pCps, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cost.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Integer> getAllValuesOfCost(final CpsCost.Match partialMatch) {
+      return rawStreamAllValuesOfCost(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Cost.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Integer> getAllValuesOfCost(final CyberPhysicalSystem pCps) {
+      return rawStreamAllValuesOfCost(new Object[]{pCps, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected CpsCost.Match tupleToMatch(final Tuple t) {
+      try {
+          return CpsCost.Match.newMatch((CyberPhysicalSystem) t.get(POSITION_CPS), (Integer) t.get(POSITION_COST));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected CpsCost.Match arrayToMatch(final Object[] match) {
+      try {
+          return CpsCost.Match.newMatch((CyberPhysicalSystem) match[POSITION_CPS], (Integer) match[POSITION_COST]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected CpsCost.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return CpsCost.Match.newMutableMatch((CyberPhysicalSystem) match[POSITION_CPS], (Integer) match[POSITION_COST]);
+      } 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<CpsCost.Matcher> querySpecification() {
+      return CpsCost.instance();
+    }
+  }
+  
+  private CpsCost() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static CpsCost instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected CpsCost.Matcher instantiate(final ViatraQueryEngine engine) {
+    return CpsCost.Matcher.on(engine);
+  }
+  
+  @Override
+  public CpsCost.Matcher instantiate() {
+    return CpsCost.Matcher.create();
+  }
+  
+  @Override
+  public CpsCost.Match newEmptyMatch() {
+    return CpsCost.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public CpsCost.Match newMatch(final Object... parameters) {
+    return CpsCost.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem) parameters[0], (java.lang.Integer) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link CpsCost} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link CpsCost#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final CpsCost INSTANCE = new CpsCost();
+    
+    /**
+     * 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 CpsCost.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Cps = new PParameter("Cps", "hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "CyberPhysicalSystem")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Cost = new PParameter("Cost", "java.lang.Integer", new JavaTransitiveInstancesKey(java.lang.Integer.class), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Cps, parameter_Cost);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.cpsCost";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Cps","Cost");
+    }
+    
+    @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_Cps = body.getOrCreateVariableByName("Cps");
+          PVariable var_Cost = body.getOrCreateVariableByName("Cost");
+          PVariable var_AppCount = body.getOrCreateVariableByName("AppCount");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          PVariable var_HostCost = body.getOrCreateVariableByName("HostCost");
+          PVariable var___1_ = body.getOrCreateVariableByName("_<1>");
+          PVariable var___2_ = body.getOrCreateVariableByName("_<2>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Cps), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "CyberPhysicalSystem")));
+          new TypeFilterConstraint(body, Tuples.flatTupleOf(var_Cost), new JavaTransitiveInstancesKey(java.lang.Integer.class));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Cps, parameter_Cps),
+             new ExportedParameter(body, var_Cost, parameter_Cost)
+          ));
+          //    AppCount == count find cpsApplications(Cps, _)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new PatternMatchCounter(body, Tuples.flatTupleOf(var_Cps, var___0_), CpsApplications.instance().getInternalQueryRepresentation(), var__virtual_0_);
+          new Equality(body, var_AppCount, var__virtual_0_);
+          //    HostCost == sum find hostInstanceCost(Cps, _, #_)
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new AggregatorConstraint(new sum().getAggregatorLogic(Integer.class), body, Tuples.flatTupleOf(var_Cps, var___1_, var___2_), HostInstanceCost.instance().getInternalQueryRepresentation(), var__virtual_1_, 2);
+          new Equality(body, var_HostCost, var__virtual_1_);
+          //    Cost == eval(5 * AppCount + HostCost)
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern cpsCost";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("AppCount", "HostCost");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer AppCount = (Integer) provider.getValue("AppCount");
+                  Integer HostCost = (Integer) provider.getValue("HostCost");
+                  return evaluateExpression_1_1(AppCount, HostCost);
+              }
+          },  var__virtual_2_ ); 
+          new Equality(body, var_Cost, var__virtual_2_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+  
+  private static int evaluateExpression_1_1(final Integer AppCount, final Integer HostCost) {
+    return ((5 * (AppCount).intValue()) + (HostCost).intValue());
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.java
new file mode 100644
index 00000000..c889fbe0
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.java
@@ -0,0 +1,218 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.Allocate;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.AllocationWithoutResourceRequirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.AverageFreeHddMetric;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.AverageFreeMemoryMetric;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.CostMetric;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.CpsCost;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.CreateHostInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.GuidanceObjective;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.InstanceDoesNotSatisfyRequirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.NotEnoughAvailableHdd;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.NotEnoughAvailableMemory;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.RedundantInstancesOnSameHost;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.RemoveHostInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.RequirementNotSatisfied;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.ResourceRequirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.UnallocateAppInstance;
+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 CpsQueries.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 CpsQueries.vql,
+ * in order to achieve better performance than one-by-one on-demand matcher initialization.
+ * 
+ * <p> From package hu.bme.mit.inf.dslreasoner.domains.cps.queries, the group contains the definition of the following patterns: <ul>
+ * <li>resourceRequirement</li>
+ * <li>allocationWithoutResourceRequirement</li>
+ * <li>notEnoughAvailableMemory</li>
+ * <li>notEnoughAvailableHdd</li>
+ * <li>instanceDoesNotSatisfyRequirement</li>
+ * <li>requirementNotSatisfied</li>
+ * <li>redundantInstancesOnSameHost</li>
+ * <li>averageFreeMemoryMetric</li>
+ * <li>averageFreeHddMetric</li>
+ * <li>costMetric</li>
+ * <li>cpsCost</li>
+ * <li>allocate</li>
+ * <li>unallocateAppInstance</li>
+ * <li>createHostInstance</li>
+ * <li>removeHostInstance</li>
+ * <li>guidanceObjective</li>
+ * </ul>
+ * 
+ * @see IQueryGroup
+ * 
+ */
+@SuppressWarnings("all")
+public final class CpsQueries 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 CpsQueries instance() {
+    if (INSTANCE == null) {
+        INSTANCE = new CpsQueries();
+    }
+    return INSTANCE;
+  }
+  
+  private static CpsQueries INSTANCE;
+  
+  private CpsQueries() {
+    querySpecifications.add(ResourceRequirement.instance());
+    querySpecifications.add(AllocationWithoutResourceRequirement.instance());
+    querySpecifications.add(NotEnoughAvailableMemory.instance());
+    querySpecifications.add(NotEnoughAvailableHdd.instance());
+    querySpecifications.add(InstanceDoesNotSatisfyRequirement.instance());
+    querySpecifications.add(RequirementNotSatisfied.instance());
+    querySpecifications.add(RedundantInstancesOnSameHost.instance());
+    querySpecifications.add(AverageFreeMemoryMetric.instance());
+    querySpecifications.add(AverageFreeHddMetric.instance());
+    querySpecifications.add(CostMetric.instance());
+    querySpecifications.add(CpsCost.instance());
+    querySpecifications.add(Allocate.instance());
+    querySpecifications.add(UnallocateAppInstance.instance());
+    querySpecifications.add(CreateHostInstance.instance());
+    querySpecifications.add(RemoveHostInstance.instance());
+    querySpecifications.add(GuidanceObjective.instance());
+  }
+  
+  public ResourceRequirement getResourceRequirement() {
+    return ResourceRequirement.instance();
+  }
+  
+  public ResourceRequirement.Matcher getResourceRequirement(final ViatraQueryEngine engine) {
+    return ResourceRequirement.Matcher.on(engine);
+  }
+  
+  public AllocationWithoutResourceRequirement getAllocationWithoutResourceRequirement() {
+    return AllocationWithoutResourceRequirement.instance();
+  }
+  
+  public AllocationWithoutResourceRequirement.Matcher getAllocationWithoutResourceRequirement(final ViatraQueryEngine engine) {
+    return AllocationWithoutResourceRequirement.Matcher.on(engine);
+  }
+  
+  public NotEnoughAvailableMemory getNotEnoughAvailableMemory() {
+    return NotEnoughAvailableMemory.instance();
+  }
+  
+  public NotEnoughAvailableMemory.Matcher getNotEnoughAvailableMemory(final ViatraQueryEngine engine) {
+    return NotEnoughAvailableMemory.Matcher.on(engine);
+  }
+  
+  public NotEnoughAvailableHdd getNotEnoughAvailableHdd() {
+    return NotEnoughAvailableHdd.instance();
+  }
+  
+  public NotEnoughAvailableHdd.Matcher getNotEnoughAvailableHdd(final ViatraQueryEngine engine) {
+    return NotEnoughAvailableHdd.Matcher.on(engine);
+  }
+  
+  public InstanceDoesNotSatisfyRequirement getInstanceDoesNotSatisfyRequirement() {
+    return InstanceDoesNotSatisfyRequirement.instance();
+  }
+  
+  public InstanceDoesNotSatisfyRequirement.Matcher getInstanceDoesNotSatisfyRequirement(final ViatraQueryEngine engine) {
+    return InstanceDoesNotSatisfyRequirement.Matcher.on(engine);
+  }
+  
+  public RequirementNotSatisfied getRequirementNotSatisfied() {
+    return RequirementNotSatisfied.instance();
+  }
+  
+  public RequirementNotSatisfied.Matcher getRequirementNotSatisfied(final ViatraQueryEngine engine) {
+    return RequirementNotSatisfied.Matcher.on(engine);
+  }
+  
+  public RedundantInstancesOnSameHost getRedundantInstancesOnSameHost() {
+    return RedundantInstancesOnSameHost.instance();
+  }
+  
+  public RedundantInstancesOnSameHost.Matcher getRedundantInstancesOnSameHost(final ViatraQueryEngine engine) {
+    return RedundantInstancesOnSameHost.Matcher.on(engine);
+  }
+  
+  public AverageFreeMemoryMetric getAverageFreeMemoryMetric() {
+    return AverageFreeMemoryMetric.instance();
+  }
+  
+  public AverageFreeMemoryMetric.Matcher getAverageFreeMemoryMetric(final ViatraQueryEngine engine) {
+    return AverageFreeMemoryMetric.Matcher.on(engine);
+  }
+  
+  public AverageFreeHddMetric getAverageFreeHddMetric() {
+    return AverageFreeHddMetric.instance();
+  }
+  
+  public AverageFreeHddMetric.Matcher getAverageFreeHddMetric(final ViatraQueryEngine engine) {
+    return AverageFreeHddMetric.Matcher.on(engine);
+  }
+  
+  public CostMetric getCostMetric() {
+    return CostMetric.instance();
+  }
+  
+  public CostMetric.Matcher getCostMetric(final ViatraQueryEngine engine) {
+    return CostMetric.Matcher.on(engine);
+  }
+  
+  public CpsCost getCpsCost() {
+    return CpsCost.instance();
+  }
+  
+  public CpsCost.Matcher getCpsCost(final ViatraQueryEngine engine) {
+    return CpsCost.Matcher.on(engine);
+  }
+  
+  public Allocate getAllocate() {
+    return Allocate.instance();
+  }
+  
+  public Allocate.Matcher getAllocate(final ViatraQueryEngine engine) {
+    return Allocate.Matcher.on(engine);
+  }
+  
+  public UnallocateAppInstance getUnallocateAppInstance() {
+    return UnallocateAppInstance.instance();
+  }
+  
+  public UnallocateAppInstance.Matcher getUnallocateAppInstance(final ViatraQueryEngine engine) {
+    return UnallocateAppInstance.Matcher.on(engine);
+  }
+  
+  public CreateHostInstance getCreateHostInstance() {
+    return CreateHostInstance.instance();
+  }
+  
+  public CreateHostInstance.Matcher getCreateHostInstance(final ViatraQueryEngine engine) {
+    return CreateHostInstance.Matcher.on(engine);
+  }
+  
+  public RemoveHostInstance getRemoveHostInstance() {
+    return RemoveHostInstance.instance();
+  }
+  
+  public RemoveHostInstance.Matcher getRemoveHostInstance(final ViatraQueryEngine engine) {
+    return RemoveHostInstance.Matcher.on(engine);
+  }
+  
+  public GuidanceObjective getGuidanceObjective() {
+    return GuidanceObjective.instance();
+  }
+  
+  public GuidanceObjective.Matcher getGuidanceObjective(final ViatraQueryEngine engine) {
+    return GuidanceObjective.Matcher.on(engine);
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CreateHostInstance.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CreateHostInstance.java
new file mode 100644
index 00000000..04036e11
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CreateHostInstance.java
@@ -0,0 +1,563 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostType;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.UnallocatedAppInstance;
+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.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>
+ *         pattern createHostInstance(HostType : HostType) {
+ *              find unallocatedAppInstance(App);
+ *              ApplicationInstance.type.requirements.hostType(App, HostType);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class CreateHostInstance extends BaseGeneratedEMFQuerySpecification<CreateHostInstance.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.createHostInstance 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 HostType fHostType;
+    
+    private static List<String> parameterNames = makeImmutableList("HostType");
+    
+    private Match(final HostType pHostType) {
+      this.fHostType = pHostType;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "HostType": return this.fHostType;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fHostType;
+          default: return null;
+      }
+    }
+    
+    public HostType getHostType() {
+      return this.fHostType;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("HostType".equals(parameterName) ) {
+          this.fHostType = (HostType) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setHostType(final HostType pHostType) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fHostType = pHostType;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.createHostInstance";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return CreateHostInstance.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fHostType};
+    }
+    
+    @Override
+    public CreateHostInstance.Match toImmutable() {
+      return isMutable() ? newMatch(fHostType) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"HostType\"=" + prettyPrintValue(fHostType));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fHostType);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof CreateHostInstance.Match)) {
+          CreateHostInstance.Match other = (CreateHostInstance.Match) obj;
+          return Objects.equals(fHostType, other.fHostType);
+      } 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 CreateHostInstance specification() {
+      return CreateHostInstance.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 CreateHostInstance.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 pHostType the fixed value of pattern parameter HostType, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static CreateHostInstance.Match newMutableMatch(final HostType pHostType) {
+      return new Mutable(pHostType);
+    }
+    
+    /**
+     * 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 pHostType the fixed value of pattern parameter HostType, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static CreateHostInstance.Match newMatch(final HostType pHostType) {
+      return new Immutable(pHostType);
+    }
+    
+    private static final class Mutable extends CreateHostInstance.Match {
+      Mutable(final HostType pHostType) {
+        super(pHostType);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends CreateHostInstance.Match {
+      Immutable(final HostType pHostType) {
+        super(pHostType);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.createHostInstance 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 createHostInstance(HostType : HostType) {
+   *    find unallocatedAppInstance(App);
+   *    ApplicationInstance.type.requirements.hostType(App, HostType);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see CreateHostInstance
+   * 
+   */
+  public static class Matcher extends BaseMatcher<CreateHostInstance.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 CreateHostInstance.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 CreateHostInstance.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_HOSTTYPE = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(CreateHostInstance.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 pHostType the fixed value of pattern parameter HostType, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<CreateHostInstance.Match> getAllMatches(final HostType pHostType) {
+      return rawStreamAllMatches(new Object[]{pHostType}).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 pHostType the fixed value of pattern parameter HostType, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<CreateHostInstance.Match> streamAllMatches(final HostType pHostType) {
+      return rawStreamAllMatches(new Object[]{pHostType});
+    }
+    
+    /**
+     * 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 pHostType the fixed value of pattern parameter HostType, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<CreateHostInstance.Match> getOneArbitraryMatch(final HostType pHostType) {
+      return rawGetOneArbitraryMatch(new Object[]{pHostType});
+    }
+    
+    /**
+     * 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 pHostType the fixed value of pattern parameter HostType, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final HostType pHostType) {
+      return rawHasMatch(new Object[]{pHostType});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pHostType the fixed value of pattern parameter HostType, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final HostType pHostType) {
+      return rawCountMatches(new Object[]{pHostType});
+    }
+    
+    /**
+     * 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 pHostType the fixed value of pattern parameter HostType, 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 HostType pHostType, final Consumer<? super CreateHostInstance.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pHostType}, 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 pHostType the fixed value of pattern parameter HostType, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public CreateHostInstance.Match newMatch(final HostType pHostType) {
+      return CreateHostInstance.Match.newMatch(pHostType);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for HostType.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<HostType> rawStreamAllValuesOfHostType(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_HOSTTYPE, parameters).map(HostType.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for HostType.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostType> getAllValuesOfHostType() {
+      return rawStreamAllValuesOfHostType(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for HostType.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<HostType> streamAllValuesOfHostType() {
+      return rawStreamAllValuesOfHostType(emptyArray());
+    }
+    
+    @Override
+    protected CreateHostInstance.Match tupleToMatch(final Tuple t) {
+      try {
+          return CreateHostInstance.Match.newMatch((HostType) t.get(POSITION_HOSTTYPE));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected CreateHostInstance.Match arrayToMatch(final Object[] match) {
+      try {
+          return CreateHostInstance.Match.newMatch((HostType) match[POSITION_HOSTTYPE]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected CreateHostInstance.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return CreateHostInstance.Match.newMutableMatch((HostType) match[POSITION_HOSTTYPE]);
+      } 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<CreateHostInstance.Matcher> querySpecification() {
+      return CreateHostInstance.instance();
+    }
+  }
+  
+  private CreateHostInstance() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static CreateHostInstance instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected CreateHostInstance.Matcher instantiate(final ViatraQueryEngine engine) {
+    return CreateHostInstance.Matcher.on(engine);
+  }
+  
+  @Override
+  public CreateHostInstance.Matcher instantiate() {
+    return CreateHostInstance.Matcher.create();
+  }
+  
+  @Override
+  public CreateHostInstance.Match newEmptyMatch() {
+    return CreateHostInstance.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public CreateHostInstance.Match newMatch(final Object... parameters) {
+    return CreateHostInstance.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.HostType) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link CreateHostInstance} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link CreateHostInstance#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final CreateHostInstance INSTANCE = new CreateHostInstance();
+    
+    /**
+     * 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 CreateHostInstance.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_HostType = new PParameter("HostType", "hu.bme.mit.inf.dslreasoner.domains.cps.HostType", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostType")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_HostType);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.createHostInstance";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("HostType");
+    }
+    
+    @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_HostType = body.getOrCreateVariableByName("HostType");
+          PVariable var_App = body.getOrCreateVariableByName("App");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_HostType), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostType")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_HostType, parameter_HostType)
+          ));
+          //    find unallocatedAppInstance(App)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_App), UnallocatedAppInstance.instance().getInternalQueryRepresentation());
+          //    ApplicationInstance.type.requirements.hostType(App, HostType)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "type")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationType")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationType", "requirements")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ResourceRequirement")));
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ResourceRequirement", "hostType")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostType")));
+          new Equality(body, var__virtual_2_, var_HostType);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/GuidanceObjective.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/GuidanceObjective.java
new file mode 100644
index 00000000..1ed6c9cc
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/GuidanceObjective.java
@@ -0,0 +1,601 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.NoHostToAllocateTo;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.RequiredAppInstances;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.UnallocatedAppInstance;
+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.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.matchers.aggregators.sum;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+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.AggregatorConstraint;
+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.ExpressionEvaluation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.PatternMatchCounter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint;
+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 guidanceObjective(Value : java Integer) {
+ *              UnallocatedInstances == count find unallocatedAppInstance(_);
+ *              RequiredInstances == sum find requiredAppInstances(_, #_);
+ *              NoHostToAllocate == count find noHostToAllocateTo(_);
+ *              Value == eval(2  UnallocatedInstances + 4  RequiredInstances + NoHostToAllocate);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class GuidanceObjective extends BaseGeneratedEMFQuerySpecification<GuidanceObjective.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.guidanceObjective 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 Integer fValue;
+    
+    private static List<String> parameterNames = makeImmutableList("Value");
+    
+    private Match(final Integer pValue) {
+      this.fValue = pValue;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Value": return this.fValue;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fValue;
+          default: return null;
+      }
+    }
+    
+    public Integer getValue() {
+      return this.fValue;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Value".equals(parameterName) ) {
+          this.fValue = (Integer) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setValue(final Integer pValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fValue = pValue;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.guidanceObjective";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return GuidanceObjective.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fValue};
+    }
+    
+    @Override
+    public GuidanceObjective.Match toImmutable() {
+      return isMutable() ? newMatch(fValue) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Value\"=" + prettyPrintValue(fValue));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fValue);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof GuidanceObjective.Match)) {
+          GuidanceObjective.Match other = (GuidanceObjective.Match) obj;
+          return Objects.equals(fValue, other.fValue);
+      } 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 GuidanceObjective specification() {
+      return GuidanceObjective.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 GuidanceObjective.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 pValue the fixed value of pattern parameter Value, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static GuidanceObjective.Match newMutableMatch(final Integer pValue) {
+      return new Mutable(pValue);
+    }
+    
+    /**
+     * 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 pValue the fixed value of pattern parameter Value, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static GuidanceObjective.Match newMatch(final Integer pValue) {
+      return new Immutable(pValue);
+    }
+    
+    private static final class Mutable extends GuidanceObjective.Match {
+      Mutable(final Integer pValue) {
+        super(pValue);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends GuidanceObjective.Match {
+      Immutable(final Integer pValue) {
+        super(pValue);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.guidanceObjective 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 guidanceObjective(Value : java Integer) {
+   *    UnallocatedInstances == count find unallocatedAppInstance(_);
+   *    RequiredInstances == sum find requiredAppInstances(_, #_);
+   *    NoHostToAllocate == count find noHostToAllocateTo(_);
+   *    Value == eval(2  UnallocatedInstances + 4  RequiredInstances + NoHostToAllocate);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see GuidanceObjective
+   * 
+   */
+  public static class Matcher extends BaseMatcher<GuidanceObjective.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 GuidanceObjective.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 GuidanceObjective.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_VALUE = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(GuidanceObjective.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 pValue the fixed value of pattern parameter Value, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<GuidanceObjective.Match> getAllMatches(final Integer pValue) {
+      return rawStreamAllMatches(new Object[]{pValue}).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 pValue the fixed value of pattern parameter Value, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<GuidanceObjective.Match> streamAllMatches(final Integer pValue) {
+      return rawStreamAllMatches(new Object[]{pValue});
+    }
+    
+    /**
+     * 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 pValue the fixed value of pattern parameter Value, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<GuidanceObjective.Match> getOneArbitraryMatch(final Integer pValue) {
+      return rawGetOneArbitraryMatch(new Object[]{pValue});
+    }
+    
+    /**
+     * 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 pValue the fixed value of pattern parameter Value, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Integer pValue) {
+      return rawHasMatch(new Object[]{pValue});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pValue the fixed value of pattern parameter Value, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Integer pValue) {
+      return rawCountMatches(new Object[]{pValue});
+    }
+    
+    /**
+     * 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 pValue the fixed value of pattern parameter Value, 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 Integer pValue, final Consumer<? super GuidanceObjective.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pValue}, 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 pValue the fixed value of pattern parameter Value, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public GuidanceObjective.Match newMatch(final Integer pValue) {
+      return GuidanceObjective.Match.newMatch(pValue);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Value.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Integer> rawStreamAllValuesOfValue(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_VALUE, parameters).map(Integer.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Value.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Integer> getAllValuesOfValue() {
+      return rawStreamAllValuesOfValue(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Value.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Integer> streamAllValuesOfValue() {
+      return rawStreamAllValuesOfValue(emptyArray());
+    }
+    
+    @Override
+    protected GuidanceObjective.Match tupleToMatch(final Tuple t) {
+      try {
+          return GuidanceObjective.Match.newMatch((Integer) t.get(POSITION_VALUE));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected GuidanceObjective.Match arrayToMatch(final Object[] match) {
+      try {
+          return GuidanceObjective.Match.newMatch((Integer) match[POSITION_VALUE]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected GuidanceObjective.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return GuidanceObjective.Match.newMutableMatch((Integer) match[POSITION_VALUE]);
+      } 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<GuidanceObjective.Matcher> querySpecification() {
+      return GuidanceObjective.instance();
+    }
+  }
+  
+  private GuidanceObjective() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static GuidanceObjective instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected GuidanceObjective.Matcher instantiate(final ViatraQueryEngine engine) {
+    return GuidanceObjective.Matcher.on(engine);
+  }
+  
+  @Override
+  public GuidanceObjective.Matcher instantiate() {
+    return GuidanceObjective.Matcher.create();
+  }
+  
+  @Override
+  public GuidanceObjective.Match newEmptyMatch() {
+    return GuidanceObjective.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public GuidanceObjective.Match newMatch(final Object... parameters) {
+    return GuidanceObjective.Match.newMatch((java.lang.Integer) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link GuidanceObjective} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link GuidanceObjective#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final GuidanceObjective INSTANCE = new GuidanceObjective();
+    
+    /**
+     * 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 GuidanceObjective.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Value = new PParameter("Value", "java.lang.Integer", new JavaTransitiveInstancesKey(java.lang.Integer.class), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Value);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.guidanceObjective";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Value");
+    }
+    
+    @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_Value = body.getOrCreateVariableByName("Value");
+          PVariable var_UnallocatedInstances = body.getOrCreateVariableByName("UnallocatedInstances");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          PVariable var_RequiredInstances = body.getOrCreateVariableByName("RequiredInstances");
+          PVariable var___1_ = body.getOrCreateVariableByName("_<1>");
+          PVariable var___2_ = body.getOrCreateVariableByName("_<2>");
+          PVariable var_NoHostToAllocate = body.getOrCreateVariableByName("NoHostToAllocate");
+          PVariable var___3_ = body.getOrCreateVariableByName("_<3>");
+          new TypeFilterConstraint(body, Tuples.flatTupleOf(var_Value), new JavaTransitiveInstancesKey(java.lang.Integer.class));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Value, parameter_Value)
+          ));
+          //    UnallocatedInstances == count find unallocatedAppInstance(_)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new PatternMatchCounter(body, Tuples.flatTupleOf(var___0_), UnallocatedAppInstance.instance().getInternalQueryRepresentation(), var__virtual_0_);
+          new Equality(body, var_UnallocatedInstances, var__virtual_0_);
+          //    RequiredInstances == sum find requiredAppInstances(_, #_)
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new AggregatorConstraint(new sum().getAggregatorLogic(Integer.class), body, Tuples.flatTupleOf(var___1_, var___2_), RequiredAppInstances.instance().getInternalQueryRepresentation(), var__virtual_1_, 1);
+          new Equality(body, var_RequiredInstances, var__virtual_1_);
+          //    NoHostToAllocate == count find noHostToAllocateTo(_)
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new PatternMatchCounter(body, Tuples.flatTupleOf(var___3_), NoHostToAllocateTo.instance().getInternalQueryRepresentation(), var__virtual_2_);
+          new Equality(body, var_NoHostToAllocate, var__virtual_2_);
+          //    Value == eval(2 * UnallocatedInstances + 4 * RequiredInstances + NoHostToAllocate)
+          PVariable var__virtual_3_ = body.getOrCreateVariableByName(".virtual{3}");
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern guidanceObjective";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("NoHostToAllocate", "RequiredInstances", "UnallocatedInstances");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer NoHostToAllocate = (Integer) provider.getValue("NoHostToAllocate");
+                  Integer RequiredInstances = (Integer) provider.getValue("RequiredInstances");
+                  Integer UnallocatedInstances = (Integer) provider.getValue("UnallocatedInstances");
+                  return evaluateExpression_1_1(NoHostToAllocate, RequiredInstances, UnallocatedInstances);
+              }
+          },  var__virtual_3_ ); 
+          new Equality(body, var_Value, var__virtual_3_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+  
+  private static int evaluateExpression_1_1(final Integer NoHostToAllocate, final Integer RequiredInstances, final Integer UnallocatedInstances) {
+    return (((2 * (UnallocatedInstances).intValue()) + (4 * (RequiredInstances).intValue())) + (NoHostToAllocate).intValue());
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/InstanceDoesNotSatisfyRequirement.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/InstanceDoesNotSatisfyRequirement.java
new file mode 100644
index 00000000..932501ff
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/InstanceDoesNotSatisfyRequirement.java
@@ -0,0 +1,727 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.Requirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.SatisfyingInstance;
+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.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.NegativePatternCall;
+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(severity = "error", key = {Req, App},
+ *              message = "Requirement must be satisfied by the required application type.")
+ *         pattern instanceDoesNotSatisfyRequirement(Req : Requirement, App : ApplicationInstance) {
+ *              Requirement.instances(Req, App);
+ *              neg find satisfyingInstance(Req, App);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class InstanceDoesNotSatisfyRequirement extends BaseGeneratedEMFQuerySpecification<InstanceDoesNotSatisfyRequirement.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.instanceDoesNotSatisfyRequirement 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 Requirement fReq;
+    
+    private ApplicationInstance fApp;
+    
+    private static List<String> parameterNames = makeImmutableList("Req", "App");
+    
+    private Match(final Requirement pReq, final ApplicationInstance pApp) {
+      this.fReq = pReq;
+      this.fApp = pApp;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Req": return this.fReq;
+          case "App": return this.fApp;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fReq;
+          case 1: return this.fApp;
+          default: return null;
+      }
+    }
+    
+    public Requirement getReq() {
+      return this.fReq;
+    }
+    
+    public ApplicationInstance getApp() {
+      return this.fApp;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Req".equals(parameterName) ) {
+          this.fReq = (Requirement) newValue;
+          return true;
+      }
+      if ("App".equals(parameterName) ) {
+          this.fApp = (ApplicationInstance) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setReq(final Requirement pReq) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fReq = pReq;
+    }
+    
+    public void setApp(final ApplicationInstance pApp) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fApp = pApp;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.instanceDoesNotSatisfyRequirement";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return InstanceDoesNotSatisfyRequirement.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fReq, fApp};
+    }
+    
+    @Override
+    public InstanceDoesNotSatisfyRequirement.Match toImmutable() {
+      return isMutable() ? newMatch(fReq, fApp) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Req\"=" + prettyPrintValue(fReq) + ", ");
+      result.append("\"App\"=" + prettyPrintValue(fApp));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fReq, fApp);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof InstanceDoesNotSatisfyRequirement.Match)) {
+          InstanceDoesNotSatisfyRequirement.Match other = (InstanceDoesNotSatisfyRequirement.Match) obj;
+          return Objects.equals(fReq, other.fReq) && Objects.equals(fApp, other.fApp);
+      } 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 InstanceDoesNotSatisfyRequirement specification() {
+      return InstanceDoesNotSatisfyRequirement.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 InstanceDoesNotSatisfyRequirement.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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static InstanceDoesNotSatisfyRequirement.Match newMutableMatch(final Requirement pReq, final ApplicationInstance pApp) {
+      return new Mutable(pReq, pApp);
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static InstanceDoesNotSatisfyRequirement.Match newMatch(final Requirement pReq, final ApplicationInstance pApp) {
+      return new Immutable(pReq, pApp);
+    }
+    
+    private static final class Mutable extends InstanceDoesNotSatisfyRequirement.Match {
+      Mutable(final Requirement pReq, final ApplicationInstance pApp) {
+        super(pReq, pApp);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends InstanceDoesNotSatisfyRequirement.Match {
+      Immutable(final Requirement pReq, final ApplicationInstance pApp) {
+        super(pReq, pApp);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.instanceDoesNotSatisfyRequirement 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(severity = "error", key = {Req, App},
+   *    message = "Requirement must be satisfied by the required application type.")
+   * pattern instanceDoesNotSatisfyRequirement(Req : Requirement, App : ApplicationInstance) {
+   *    Requirement.instances(Req, App);
+   *    neg find satisfyingInstance(Req, App);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see InstanceDoesNotSatisfyRequirement
+   * 
+   */
+  public static class Matcher extends BaseMatcher<InstanceDoesNotSatisfyRequirement.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 InstanceDoesNotSatisfyRequirement.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 InstanceDoesNotSatisfyRequirement.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_REQ = 0;
+    
+    private static final int POSITION_APP = 1;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(InstanceDoesNotSatisfyRequirement.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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<InstanceDoesNotSatisfyRequirement.Match> getAllMatches(final Requirement pReq, final ApplicationInstance pApp) {
+      return rawStreamAllMatches(new Object[]{pReq, pApp}).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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<InstanceDoesNotSatisfyRequirement.Match> streamAllMatches(final Requirement pReq, final ApplicationInstance pApp) {
+      return rawStreamAllMatches(new Object[]{pReq, pApp});
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<InstanceDoesNotSatisfyRequirement.Match> getOneArbitraryMatch(final Requirement pReq, final ApplicationInstance pApp) {
+      return rawGetOneArbitraryMatch(new Object[]{pReq, pApp});
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Requirement pReq, final ApplicationInstance pApp) {
+      return rawHasMatch(new Object[]{pReq, pApp});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Requirement pReq, final ApplicationInstance pApp) {
+      return rawCountMatches(new Object[]{pReq, pApp});
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, 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 Requirement pReq, final ApplicationInstance pApp, final Consumer<? super InstanceDoesNotSatisfyRequirement.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pReq, pApp}, 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public InstanceDoesNotSatisfyRequirement.Match newMatch(final Requirement pReq, final ApplicationInstance pApp) {
+      return InstanceDoesNotSatisfyRequirement.Match.newMatch(pReq, pApp);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Requirement> rawStreamAllValuesOfReq(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_REQ, parameters).map(Requirement.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Requirement> getAllValuesOfReq() {
+      return rawStreamAllValuesOfReq(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Requirement> streamAllValuesOfReq() {
+      return rawStreamAllValuesOfReq(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * </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<Requirement> streamAllValuesOfReq(final InstanceDoesNotSatisfyRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfReq(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * </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<Requirement> streamAllValuesOfReq(final ApplicationInstance pApp) {
+      return rawStreamAllValuesOfReq(new Object[]{null, pApp});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Requirement> getAllValuesOfReq(final InstanceDoesNotSatisfyRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfReq(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Requirement> getAllValuesOfReq(final ApplicationInstance pApp) {
+      return rawStreamAllValuesOfReq(new Object[]{null, pApp}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<ApplicationInstance> rawStreamAllValuesOfApp(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_APP, parameters).map(ApplicationInstance.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp() {
+      return rawStreamAllValuesOfApp(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<ApplicationInstance> streamAllValuesOfApp() {
+      return rawStreamAllValuesOfApp(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * </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<ApplicationInstance> streamAllValuesOfApp(final InstanceDoesNotSatisfyRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfApp(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * </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<ApplicationInstance> streamAllValuesOfApp(final Requirement pReq) {
+      return rawStreamAllValuesOfApp(new Object[]{pReq, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp(final InstanceDoesNotSatisfyRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfApp(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp(final Requirement pReq) {
+      return rawStreamAllValuesOfApp(new Object[]{pReq, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected InstanceDoesNotSatisfyRequirement.Match tupleToMatch(final Tuple t) {
+      try {
+          return InstanceDoesNotSatisfyRequirement.Match.newMatch((Requirement) t.get(POSITION_REQ), (ApplicationInstance) t.get(POSITION_APP));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected InstanceDoesNotSatisfyRequirement.Match arrayToMatch(final Object[] match) {
+      try {
+          return InstanceDoesNotSatisfyRequirement.Match.newMatch((Requirement) match[POSITION_REQ], (ApplicationInstance) match[POSITION_APP]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected InstanceDoesNotSatisfyRequirement.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return InstanceDoesNotSatisfyRequirement.Match.newMutableMatch((Requirement) match[POSITION_REQ], (ApplicationInstance) match[POSITION_APP]);
+      } 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<InstanceDoesNotSatisfyRequirement.Matcher> querySpecification() {
+      return InstanceDoesNotSatisfyRequirement.instance();
+    }
+  }
+  
+  private InstanceDoesNotSatisfyRequirement() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static InstanceDoesNotSatisfyRequirement instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected InstanceDoesNotSatisfyRequirement.Matcher instantiate(final ViatraQueryEngine engine) {
+    return InstanceDoesNotSatisfyRequirement.Matcher.on(engine);
+  }
+  
+  @Override
+  public InstanceDoesNotSatisfyRequirement.Matcher instantiate() {
+    return InstanceDoesNotSatisfyRequirement.Matcher.create();
+  }
+  
+  @Override
+  public InstanceDoesNotSatisfyRequirement.Match newEmptyMatch() {
+    return InstanceDoesNotSatisfyRequirement.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public InstanceDoesNotSatisfyRequirement.Match newMatch(final Object... parameters) {
+    return InstanceDoesNotSatisfyRequirement.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.Requirement) parameters[0], (hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance) parameters[1]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link InstanceDoesNotSatisfyRequirement} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link InstanceDoesNotSatisfyRequirement#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final InstanceDoesNotSatisfyRequirement INSTANCE = new InstanceDoesNotSatisfyRequirement();
+    
+    /**
+     * 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 InstanceDoesNotSatisfyRequirement.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Req = new PParameter("Req", "hu.bme.mit.inf.dslreasoner.domains.cps.Requirement", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "Requirement")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_App = new PParameter("App", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Req, parameter_App);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.instanceDoesNotSatisfyRequirement";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Req","App");
+    }
+    
+    @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_Req = body.getOrCreateVariableByName("Req");
+          PVariable var_App = body.getOrCreateVariableByName("App");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Req, parameter_Req),
+             new ExportedParameter(body, var_App, parameter_App)
+          ));
+          //    Requirement.instances(Req, App)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "Requirement", "instances")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          new Equality(body, var__virtual_0_, var_App);
+          //    neg find satisfyingInstance(Req, App)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_Req, var_App), SatisfyingInstance.instance().getInternalQueryRepresentation());
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("Req"), 
+                              new ParameterReference("App")
+                              }));
+          annotation.addAttribute("message", "Requirement must be satisfied by the required application type.");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/NotEnoughAvailableHdd.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/NotEnoughAvailableHdd.java
new file mode 100644
index 00000000..4077c103
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/NotEnoughAvailableHdd.java
@@ -0,0 +1,589 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.AvailableHdd;
+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.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+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.ExpressionEvaluation;
+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(severity = "error", key = {Host},
+ *              message = "Insufficient HDD available on host.")
+ *         pattern notEnoughAvailableHdd(Host : HostInstance) {
+ *              find availableHdd(Host, Hdd);
+ *              check(Hdd {@literal <} 0);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class NotEnoughAvailableHdd extends BaseGeneratedEMFQuerySpecification<NotEnoughAvailableHdd.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.notEnoughAvailableHdd 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 HostInstance fHost;
+    
+    private static List<String> parameterNames = makeImmutableList("Host");
+    
+    private Match(final HostInstance pHost) {
+      this.fHost = pHost;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Host": return this.fHost;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fHost;
+          default: return null;
+      }
+    }
+    
+    public HostInstance getHost() {
+      return this.fHost;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Host".equals(parameterName) ) {
+          this.fHost = (HostInstance) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setHost(final HostInstance pHost) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fHost = pHost;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.notEnoughAvailableHdd";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return NotEnoughAvailableHdd.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fHost};
+    }
+    
+    @Override
+    public NotEnoughAvailableHdd.Match toImmutable() {
+      return isMutable() ? newMatch(fHost) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Host\"=" + prettyPrintValue(fHost));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fHost);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof NotEnoughAvailableHdd.Match)) {
+          NotEnoughAvailableHdd.Match other = (NotEnoughAvailableHdd.Match) obj;
+          return Objects.equals(fHost, other.fHost);
+      } 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 NotEnoughAvailableHdd specification() {
+      return NotEnoughAvailableHdd.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 NotEnoughAvailableHdd.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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static NotEnoughAvailableHdd.Match newMutableMatch(final HostInstance pHost) {
+      return new Mutable(pHost);
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static NotEnoughAvailableHdd.Match newMatch(final HostInstance pHost) {
+      return new Immutable(pHost);
+    }
+    
+    private static final class Mutable extends NotEnoughAvailableHdd.Match {
+      Mutable(final HostInstance pHost) {
+        super(pHost);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends NotEnoughAvailableHdd.Match {
+      Immutable(final HostInstance pHost) {
+        super(pHost);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.notEnoughAvailableHdd 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(severity = "error", key = {Host},
+   *    message = "Insufficient HDD available on host.")
+   * pattern notEnoughAvailableHdd(Host : HostInstance) {
+   *    find availableHdd(Host, Hdd);
+   *    check(Hdd {@literal <} 0);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see NotEnoughAvailableHdd
+   * 
+   */
+  public static class Matcher extends BaseMatcher<NotEnoughAvailableHdd.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 NotEnoughAvailableHdd.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 NotEnoughAvailableHdd.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_HOST = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(NotEnoughAvailableHdd.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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<NotEnoughAvailableHdd.Match> getAllMatches(final HostInstance pHost) {
+      return rawStreamAllMatches(new Object[]{pHost}).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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<NotEnoughAvailableHdd.Match> streamAllMatches(final HostInstance pHost) {
+      return rawStreamAllMatches(new Object[]{pHost});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<NotEnoughAvailableHdd.Match> getOneArbitraryMatch(final HostInstance pHost) {
+      return rawGetOneArbitraryMatch(new Object[]{pHost});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final HostInstance pHost) {
+      return rawHasMatch(new Object[]{pHost});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final HostInstance pHost) {
+      return rawCountMatches(new Object[]{pHost});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, 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 HostInstance pHost, final Consumer<? super NotEnoughAvailableHdd.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pHost}, 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public NotEnoughAvailableHdd.Match newMatch(final HostInstance pHost) {
+      return NotEnoughAvailableHdd.Match.newMatch(pHost);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<HostInstance> rawStreamAllValuesOfHost(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_HOST, parameters).map(HostInstance.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHost() {
+      return rawStreamAllValuesOfHost(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<HostInstance> streamAllValuesOfHost() {
+      return rawStreamAllValuesOfHost(emptyArray());
+    }
+    
+    @Override
+    protected NotEnoughAvailableHdd.Match tupleToMatch(final Tuple t) {
+      try {
+          return NotEnoughAvailableHdd.Match.newMatch((HostInstance) t.get(POSITION_HOST));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected NotEnoughAvailableHdd.Match arrayToMatch(final Object[] match) {
+      try {
+          return NotEnoughAvailableHdd.Match.newMatch((HostInstance) match[POSITION_HOST]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected NotEnoughAvailableHdd.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return NotEnoughAvailableHdd.Match.newMutableMatch((HostInstance) match[POSITION_HOST]);
+      } 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<NotEnoughAvailableHdd.Matcher> querySpecification() {
+      return NotEnoughAvailableHdd.instance();
+    }
+  }
+  
+  private NotEnoughAvailableHdd() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static NotEnoughAvailableHdd instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected NotEnoughAvailableHdd.Matcher instantiate(final ViatraQueryEngine engine) {
+    return NotEnoughAvailableHdd.Matcher.on(engine);
+  }
+  
+  @Override
+  public NotEnoughAvailableHdd.Matcher instantiate() {
+    return NotEnoughAvailableHdd.Matcher.create();
+  }
+  
+  @Override
+  public NotEnoughAvailableHdd.Match newEmptyMatch() {
+    return NotEnoughAvailableHdd.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public NotEnoughAvailableHdd.Match newMatch(final Object... parameters) {
+    return NotEnoughAvailableHdd.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link NotEnoughAvailableHdd} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link NotEnoughAvailableHdd#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final NotEnoughAvailableHdd INSTANCE = new NotEnoughAvailableHdd();
+    
+    /**
+     * 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 NotEnoughAvailableHdd.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.notEnoughAvailableHdd";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_Hdd = body.getOrCreateVariableByName("Hdd");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host)
+          ));
+          //    find availableHdd(Host, Hdd)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_Hdd), AvailableHdd.instance().getInternalQueryRepresentation());
+          //    check(Hdd < 0)
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern notEnoughAvailableHdd";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("Hdd");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer Hdd = (Integer) provider.getValue("Hdd");
+                  return evaluateExpression_1_1(Hdd);
+              }
+          },  null); 
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("Host")
+                              }));
+          annotation.addAttribute("message", "Insufficient HDD available on host.");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+  
+  private static boolean evaluateExpression_1_1(final Integer Hdd) {
+    return ((Hdd).intValue() < 0);
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/NotEnoughAvailableMemory.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/NotEnoughAvailableMemory.java
new file mode 100644
index 00000000..6e52bee8
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/NotEnoughAvailableMemory.java
@@ -0,0 +1,589 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.AvailableMemory;
+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.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+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.ExpressionEvaluation;
+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(severity = "error", key = {Host},
+ *              message = "Insufficient memory available on host.")
+ *         pattern notEnoughAvailableMemory(Host : HostInstance) {
+ *              find availableMemory(Host, Memory);
+ *              check(Memory {@literal <} 0);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class NotEnoughAvailableMemory extends BaseGeneratedEMFQuerySpecification<NotEnoughAvailableMemory.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.notEnoughAvailableMemory 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 HostInstance fHost;
+    
+    private static List<String> parameterNames = makeImmutableList("Host");
+    
+    private Match(final HostInstance pHost) {
+      this.fHost = pHost;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Host": return this.fHost;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fHost;
+          default: return null;
+      }
+    }
+    
+    public HostInstance getHost() {
+      return this.fHost;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Host".equals(parameterName) ) {
+          this.fHost = (HostInstance) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setHost(final HostInstance pHost) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fHost = pHost;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.notEnoughAvailableMemory";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return NotEnoughAvailableMemory.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fHost};
+    }
+    
+    @Override
+    public NotEnoughAvailableMemory.Match toImmutable() {
+      return isMutable() ? newMatch(fHost) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Host\"=" + prettyPrintValue(fHost));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fHost);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof NotEnoughAvailableMemory.Match)) {
+          NotEnoughAvailableMemory.Match other = (NotEnoughAvailableMemory.Match) obj;
+          return Objects.equals(fHost, other.fHost);
+      } 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 NotEnoughAvailableMemory specification() {
+      return NotEnoughAvailableMemory.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 NotEnoughAvailableMemory.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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static NotEnoughAvailableMemory.Match newMutableMatch(final HostInstance pHost) {
+      return new Mutable(pHost);
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static NotEnoughAvailableMemory.Match newMatch(final HostInstance pHost) {
+      return new Immutable(pHost);
+    }
+    
+    private static final class Mutable extends NotEnoughAvailableMemory.Match {
+      Mutable(final HostInstance pHost) {
+        super(pHost);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends NotEnoughAvailableMemory.Match {
+      Immutable(final HostInstance pHost) {
+        super(pHost);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.notEnoughAvailableMemory 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(severity = "error", key = {Host},
+   *    message = "Insufficient memory available on host.")
+   * pattern notEnoughAvailableMemory(Host : HostInstance) {
+   *    find availableMemory(Host, Memory);
+   *    check(Memory {@literal <} 0);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see NotEnoughAvailableMemory
+   * 
+   */
+  public static class Matcher extends BaseMatcher<NotEnoughAvailableMemory.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 NotEnoughAvailableMemory.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 NotEnoughAvailableMemory.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_HOST = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(NotEnoughAvailableMemory.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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<NotEnoughAvailableMemory.Match> getAllMatches(final HostInstance pHost) {
+      return rawStreamAllMatches(new Object[]{pHost}).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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<NotEnoughAvailableMemory.Match> streamAllMatches(final HostInstance pHost) {
+      return rawStreamAllMatches(new Object[]{pHost});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<NotEnoughAvailableMemory.Match> getOneArbitraryMatch(final HostInstance pHost) {
+      return rawGetOneArbitraryMatch(new Object[]{pHost});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final HostInstance pHost) {
+      return rawHasMatch(new Object[]{pHost});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final HostInstance pHost) {
+      return rawCountMatches(new Object[]{pHost});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, 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 HostInstance pHost, final Consumer<? super NotEnoughAvailableMemory.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pHost}, 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public NotEnoughAvailableMemory.Match newMatch(final HostInstance pHost) {
+      return NotEnoughAvailableMemory.Match.newMatch(pHost);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<HostInstance> rawStreamAllValuesOfHost(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_HOST, parameters).map(HostInstance.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHost() {
+      return rawStreamAllValuesOfHost(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<HostInstance> streamAllValuesOfHost() {
+      return rawStreamAllValuesOfHost(emptyArray());
+    }
+    
+    @Override
+    protected NotEnoughAvailableMemory.Match tupleToMatch(final Tuple t) {
+      try {
+          return NotEnoughAvailableMemory.Match.newMatch((HostInstance) t.get(POSITION_HOST));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected NotEnoughAvailableMemory.Match arrayToMatch(final Object[] match) {
+      try {
+          return NotEnoughAvailableMemory.Match.newMatch((HostInstance) match[POSITION_HOST]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected NotEnoughAvailableMemory.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return NotEnoughAvailableMemory.Match.newMutableMatch((HostInstance) match[POSITION_HOST]);
+      } 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<NotEnoughAvailableMemory.Matcher> querySpecification() {
+      return NotEnoughAvailableMemory.instance();
+    }
+  }
+  
+  private NotEnoughAvailableMemory() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static NotEnoughAvailableMemory instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected NotEnoughAvailableMemory.Matcher instantiate(final ViatraQueryEngine engine) {
+    return NotEnoughAvailableMemory.Matcher.on(engine);
+  }
+  
+  @Override
+  public NotEnoughAvailableMemory.Matcher instantiate() {
+    return NotEnoughAvailableMemory.Matcher.create();
+  }
+  
+  @Override
+  public NotEnoughAvailableMemory.Match newEmptyMatch() {
+    return NotEnoughAvailableMemory.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public NotEnoughAvailableMemory.Match newMatch(final Object... parameters) {
+    return NotEnoughAvailableMemory.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link NotEnoughAvailableMemory} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link NotEnoughAvailableMemory#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final NotEnoughAvailableMemory INSTANCE = new NotEnoughAvailableMemory();
+    
+    /**
+     * 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 NotEnoughAvailableMemory.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.notEnoughAvailableMemory";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_Memory = body.getOrCreateVariableByName("Memory");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host)
+          ));
+          //    find availableMemory(Host, Memory)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_Memory), AvailableMemory.instance().getInternalQueryRepresentation());
+          //    check(Memory < 0)
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern notEnoughAvailableMemory";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("Memory");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer Memory = (Integer) provider.getValue("Memory");
+                  return evaluateExpression_1_1(Memory);
+              }
+          },  null); 
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("Host")
+                              }));
+          annotation.addAttribute("message", "Insufficient memory available on host.");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+  
+  private static boolean evaluateExpression_1_1(final Integer Memory) {
+    return ((Memory).intValue() < 0);
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/RedundantInstancesOnSameHost.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/RedundantInstancesOnSameHost.java
new file mode 100644
index 00000000..2a40ac57
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/RedundantInstancesOnSameHost.java
@@ -0,0 +1,597 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.Requirement;
+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.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(severity = "error", key = {Req},
+ *              message = "Redundant instances must not be allocated to the same host.")
+ *         pattern redundantInstancesOnSameHost(Req : Requirement) {
+ *              Requirement.instances(Req, App1);
+ *              Requirement.instances(Req, App2);
+ *              App1 != App2;
+ *              ApplicationInstance.allocatedTo(App1, Host);
+ *              ApplicationInstance.allocatedTo(App2, Host);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class RedundantInstancesOnSameHost extends BaseGeneratedEMFQuerySpecification<RedundantInstancesOnSameHost.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.redundantInstancesOnSameHost 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 Requirement fReq;
+    
+    private static List<String> parameterNames = makeImmutableList("Req");
+    
+    private Match(final Requirement pReq) {
+      this.fReq = pReq;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Req": return this.fReq;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fReq;
+          default: return null;
+      }
+    }
+    
+    public Requirement getReq() {
+      return this.fReq;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Req".equals(parameterName) ) {
+          this.fReq = (Requirement) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setReq(final Requirement pReq) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fReq = pReq;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.redundantInstancesOnSameHost";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return RedundantInstancesOnSameHost.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fReq};
+    }
+    
+    @Override
+    public RedundantInstancesOnSameHost.Match toImmutable() {
+      return isMutable() ? newMatch(fReq) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Req\"=" + prettyPrintValue(fReq));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fReq);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof RedundantInstancesOnSameHost.Match)) {
+          RedundantInstancesOnSameHost.Match other = (RedundantInstancesOnSameHost.Match) obj;
+          return Objects.equals(fReq, other.fReq);
+      } 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 RedundantInstancesOnSameHost specification() {
+      return RedundantInstancesOnSameHost.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 RedundantInstancesOnSameHost.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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static RedundantInstancesOnSameHost.Match newMutableMatch(final Requirement pReq) {
+      return new Mutable(pReq);
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static RedundantInstancesOnSameHost.Match newMatch(final Requirement pReq) {
+      return new Immutable(pReq);
+    }
+    
+    private static final class Mutable extends RedundantInstancesOnSameHost.Match {
+      Mutable(final Requirement pReq) {
+        super(pReq);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends RedundantInstancesOnSameHost.Match {
+      Immutable(final Requirement pReq) {
+        super(pReq);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.redundantInstancesOnSameHost 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(severity = "error", key = {Req},
+   *    message = "Redundant instances must not be allocated to the same host.")
+   * pattern redundantInstancesOnSameHost(Req : Requirement) {
+   *    Requirement.instances(Req, App1);
+   *    Requirement.instances(Req, App2);
+   *    App1 != App2;
+   *    ApplicationInstance.allocatedTo(App1, Host);
+   *    ApplicationInstance.allocatedTo(App2, Host);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see RedundantInstancesOnSameHost
+   * 
+   */
+  public static class Matcher extends BaseMatcher<RedundantInstancesOnSameHost.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 RedundantInstancesOnSameHost.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 RedundantInstancesOnSameHost.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_REQ = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(RedundantInstancesOnSameHost.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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<RedundantInstancesOnSameHost.Match> getAllMatches(final Requirement pReq) {
+      return rawStreamAllMatches(new Object[]{pReq}).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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<RedundantInstancesOnSameHost.Match> streamAllMatches(final Requirement pReq) {
+      return rawStreamAllMatches(new Object[]{pReq});
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<RedundantInstancesOnSameHost.Match> getOneArbitraryMatch(final Requirement pReq) {
+      return rawGetOneArbitraryMatch(new Object[]{pReq});
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Requirement pReq) {
+      return rawHasMatch(new Object[]{pReq});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Requirement pReq) {
+      return rawCountMatches(new Object[]{pReq});
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, 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 Requirement pReq, final Consumer<? super RedundantInstancesOnSameHost.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pReq}, 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public RedundantInstancesOnSameHost.Match newMatch(final Requirement pReq) {
+      return RedundantInstancesOnSameHost.Match.newMatch(pReq);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Requirement> rawStreamAllValuesOfReq(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_REQ, parameters).map(Requirement.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Requirement> getAllValuesOfReq() {
+      return rawStreamAllValuesOfReq(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Requirement> streamAllValuesOfReq() {
+      return rawStreamAllValuesOfReq(emptyArray());
+    }
+    
+    @Override
+    protected RedundantInstancesOnSameHost.Match tupleToMatch(final Tuple t) {
+      try {
+          return RedundantInstancesOnSameHost.Match.newMatch((Requirement) t.get(POSITION_REQ));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected RedundantInstancesOnSameHost.Match arrayToMatch(final Object[] match) {
+      try {
+          return RedundantInstancesOnSameHost.Match.newMatch((Requirement) match[POSITION_REQ]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected RedundantInstancesOnSameHost.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return RedundantInstancesOnSameHost.Match.newMutableMatch((Requirement) match[POSITION_REQ]);
+      } 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<RedundantInstancesOnSameHost.Matcher> querySpecification() {
+      return RedundantInstancesOnSameHost.instance();
+    }
+  }
+  
+  private RedundantInstancesOnSameHost() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static RedundantInstancesOnSameHost instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected RedundantInstancesOnSameHost.Matcher instantiate(final ViatraQueryEngine engine) {
+    return RedundantInstancesOnSameHost.Matcher.on(engine);
+  }
+  
+  @Override
+  public RedundantInstancesOnSameHost.Matcher instantiate() {
+    return RedundantInstancesOnSameHost.Matcher.create();
+  }
+  
+  @Override
+  public RedundantInstancesOnSameHost.Match newEmptyMatch() {
+    return RedundantInstancesOnSameHost.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public RedundantInstancesOnSameHost.Match newMatch(final Object... parameters) {
+    return RedundantInstancesOnSameHost.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.Requirement) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link RedundantInstancesOnSameHost} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link RedundantInstancesOnSameHost#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final RedundantInstancesOnSameHost INSTANCE = new RedundantInstancesOnSameHost();
+    
+    /**
+     * 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 RedundantInstancesOnSameHost.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Req = new PParameter("Req", "hu.bme.mit.inf.dslreasoner.domains.cps.Requirement", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "Requirement")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Req);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.redundantInstancesOnSameHost";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Req");
+    }
+    
+    @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_Req = body.getOrCreateVariableByName("Req");
+          PVariable var_App1 = body.getOrCreateVariableByName("App1");
+          PVariable var_App2 = body.getOrCreateVariableByName("App2");
+          PVariable var_Host = body.getOrCreateVariableByName("Host");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Req, parameter_Req)
+          ));
+          //    Requirement.instances(Req, App1)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "Requirement", "instances")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          new Equality(body, var__virtual_0_, var_App1);
+          //    Requirement.instances(Req, App2)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "Requirement", "instances")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          new Equality(body, var__virtual_1_, var_App2);
+          //    App1 != App2
+          new Inequality(body, var_App1, var_App2);
+          //    ApplicationInstance.allocatedTo(App1, Host)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App1), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App1, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "allocatedTo")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new Equality(body, var__virtual_2_, var_Host);
+          //    ApplicationInstance.allocatedTo(App2, Host)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App2), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          PVariable var__virtual_3_ = body.getOrCreateVariableByName(".virtual{3}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App2, var__virtual_3_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "allocatedTo")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_3_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new Equality(body, var__virtual_3_, var_Host);
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("Req")
+                              }));
+          annotation.addAttribute("message", "Redundant instances must not be allocated to the same host.");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/RemoveHostInstance.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/RemoveHostInstance.java
new file mode 100644
index 00000000..ed3c903c
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/RemoveHostInstance.java
@@ -0,0 +1,589 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+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.basicdeferred.NegativePatternCall;
+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 removeHostInstance(HostInstance : HostInstance) {
+ *              neg HostInstance.applications(HostInstance, _);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class RemoveHostInstance extends BaseGeneratedEMFQuerySpecification<RemoveHostInstance.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.removeHostInstance 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 HostInstance fHostInstance;
+    
+    private static List<String> parameterNames = makeImmutableList("HostInstance");
+    
+    private Match(final HostInstance pHostInstance) {
+      this.fHostInstance = pHostInstance;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "HostInstance": return this.fHostInstance;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fHostInstance;
+          default: return null;
+      }
+    }
+    
+    public HostInstance getHostInstance() {
+      return this.fHostInstance;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("HostInstance".equals(parameterName) ) {
+          this.fHostInstance = (HostInstance) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setHostInstance(final HostInstance pHostInstance) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fHostInstance = pHostInstance;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.removeHostInstance";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return RemoveHostInstance.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fHostInstance};
+    }
+    
+    @Override
+    public RemoveHostInstance.Match toImmutable() {
+      return isMutable() ? newMatch(fHostInstance) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"HostInstance\"=" + prettyPrintValue(fHostInstance));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fHostInstance);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof RemoveHostInstance.Match)) {
+          RemoveHostInstance.Match other = (RemoveHostInstance.Match) obj;
+          return Objects.equals(fHostInstance, other.fHostInstance);
+      } 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 RemoveHostInstance specification() {
+      return RemoveHostInstance.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 RemoveHostInstance.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 pHostInstance the fixed value of pattern parameter HostInstance, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static RemoveHostInstance.Match newMutableMatch(final HostInstance pHostInstance) {
+      return new Mutable(pHostInstance);
+    }
+    
+    /**
+     * 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 pHostInstance the fixed value of pattern parameter HostInstance, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static RemoveHostInstance.Match newMatch(final HostInstance pHostInstance) {
+      return new Immutable(pHostInstance);
+    }
+    
+    private static final class Mutable extends RemoveHostInstance.Match {
+      Mutable(final HostInstance pHostInstance) {
+        super(pHostInstance);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends RemoveHostInstance.Match {
+      Immutable(final HostInstance pHostInstance) {
+        super(pHostInstance);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.removeHostInstance 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 removeHostInstance(HostInstance : HostInstance) {
+   *    neg HostInstance.applications(HostInstance, _);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see RemoveHostInstance
+   * 
+   */
+  public static class Matcher extends BaseMatcher<RemoveHostInstance.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 RemoveHostInstance.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 RemoveHostInstance.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_HOSTINSTANCE = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(RemoveHostInstance.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 pHostInstance the fixed value of pattern parameter HostInstance, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<RemoveHostInstance.Match> getAllMatches(final HostInstance pHostInstance) {
+      return rawStreamAllMatches(new Object[]{pHostInstance}).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 pHostInstance the fixed value of pattern parameter HostInstance, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<RemoveHostInstance.Match> streamAllMatches(final HostInstance pHostInstance) {
+      return rawStreamAllMatches(new Object[]{pHostInstance});
+    }
+    
+    /**
+     * 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 pHostInstance the fixed value of pattern parameter HostInstance, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<RemoveHostInstance.Match> getOneArbitraryMatch(final HostInstance pHostInstance) {
+      return rawGetOneArbitraryMatch(new Object[]{pHostInstance});
+    }
+    
+    /**
+     * 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 pHostInstance the fixed value of pattern parameter HostInstance, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final HostInstance pHostInstance) {
+      return rawHasMatch(new Object[]{pHostInstance});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pHostInstance the fixed value of pattern parameter HostInstance, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final HostInstance pHostInstance) {
+      return rawCountMatches(new Object[]{pHostInstance});
+    }
+    
+    /**
+     * 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 pHostInstance the fixed value of pattern parameter HostInstance, 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 HostInstance pHostInstance, final Consumer<? super RemoveHostInstance.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pHostInstance}, 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 pHostInstance the fixed value of pattern parameter HostInstance, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public RemoveHostInstance.Match newMatch(final HostInstance pHostInstance) {
+      return RemoveHostInstance.Match.newMatch(pHostInstance);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for HostInstance.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<HostInstance> rawStreamAllValuesOfHostInstance(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_HOSTINSTANCE, parameters).map(HostInstance.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for HostInstance.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHostInstance() {
+      return rawStreamAllValuesOfHostInstance(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for HostInstance.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<HostInstance> streamAllValuesOfHostInstance() {
+      return rawStreamAllValuesOfHostInstance(emptyArray());
+    }
+    
+    @Override
+    protected RemoveHostInstance.Match tupleToMatch(final Tuple t) {
+      try {
+          return RemoveHostInstance.Match.newMatch((HostInstance) t.get(POSITION_HOSTINSTANCE));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected RemoveHostInstance.Match arrayToMatch(final Object[] match) {
+      try {
+          return RemoveHostInstance.Match.newMatch((HostInstance) match[POSITION_HOSTINSTANCE]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected RemoveHostInstance.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return RemoveHostInstance.Match.newMutableMatch((HostInstance) match[POSITION_HOSTINSTANCE]);
+      } 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<RemoveHostInstance.Matcher> querySpecification() {
+      return RemoveHostInstance.instance();
+    }
+  }
+  
+  private RemoveHostInstance() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static RemoveHostInstance instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected RemoveHostInstance.Matcher instantiate(final ViatraQueryEngine engine) {
+    return RemoveHostInstance.Matcher.on(engine);
+  }
+  
+  @Override
+  public RemoveHostInstance.Matcher instantiate() {
+    return RemoveHostInstance.Matcher.create();
+  }
+  
+  @Override
+  public RemoveHostInstance.Match newEmptyMatch() {
+    return RemoveHostInstance.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public RemoveHostInstance.Match newMatch(final Object... parameters) {
+    return RemoveHostInstance.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link RemoveHostInstance} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link RemoveHostInstance#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final RemoveHostInstance INSTANCE = new RemoveHostInstance();
+    
+    /**
+     * 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 RemoveHostInstance.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_HostInstance = new PParameter("HostInstance", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_HostInstance);
+    
+    private class Embedded_1_HostInstance_applications extends BaseGeneratedEMFPQuery {
+      private final PParameter parameter_p0 = new PParameter("p0", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+      
+      private final PParameter parameter_p1 = new PParameter("p1", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+      
+      private final List<PParameter> embeddedParameters = Arrays.asList(parameter_p0, parameter_p1);
+      
+      public Embedded_1_HostInstance_applications() {
+        super(PVisibility.EMBEDDED);
+      }
+      
+      @Override
+      public String getFullyQualifiedName() {
+        return GeneratedPQuery.this.getFullyQualifiedName() + "$Embedded_1_HostInstance_applications";
+      }
+      
+      @Override
+      public List<PParameter> getParameters() {
+        return embeddedParameters;
+      }
+      
+      @Override
+      public Set<PBody> doGetContainedBodies() {
+        PBody body = new PBody(this);
+        PVariable var_p0 = body.getOrCreateVariableByName("p0");
+        PVariable var_p1 = body.getOrCreateVariableByName("p1");
+        body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+           new ExportedParameter(body, var_p0, parameter_p0),
+           new ExportedParameter(body, var_p1, parameter_p1)
+        ));
+        //  HostInstance.applications(HostInstance, _)
+        new TypeConstraint(body, Tuples.flatTupleOf(var_p0), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+        PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+        new TypeConstraint(body, Tuples.flatTupleOf(var_p0, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "HostInstance", "applications")));
+        new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+        new Equality(body, var__virtual_0_, var_p1);
+        return Collections.singleton(body);
+      }
+    }
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.removeHostInstance";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("HostInstance");
+    }
+    
+    @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_HostInstance = body.getOrCreateVariableByName("HostInstance");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_HostInstance), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_HostInstance, parameter_HostInstance)
+          ));
+          //    neg HostInstance.applications(HostInstance, _)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_HostInstance, var___0_), new RemoveHostInstance.GeneratedPQuery.Embedded_1_HostInstance_applications());
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/RequirementNotSatisfied.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/RequirementNotSatisfied.java
new file mode 100644
index 00000000..eaceec5f
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/RequirementNotSatisfied.java
@@ -0,0 +1,607 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.Requirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.SatisfyingInstance;
+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.EDataType;
+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.EDataTypeInSlotsKey;
+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.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+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.ExpressionEvaluation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.PatternMatchCounter;
+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(severity = "error", key = {Req},
+ *              message = "Requirement is not satisfied by enough application instances.")
+ *         pattern requirementNotSatisfied(Req : Requirement) {
+ *              Instances == count find satisfyingInstance(Req, _);
+ *              Requirement.count(Req, RequiredCount);
+ *              check(Instances {@literal <} RequiredCount);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class RequirementNotSatisfied extends BaseGeneratedEMFQuerySpecification<RequirementNotSatisfied.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.requirementNotSatisfied 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 Requirement fReq;
+    
+    private static List<String> parameterNames = makeImmutableList("Req");
+    
+    private Match(final Requirement pReq) {
+      this.fReq = pReq;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Req": return this.fReq;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fReq;
+          default: return null;
+      }
+    }
+    
+    public Requirement getReq() {
+      return this.fReq;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Req".equals(parameterName) ) {
+          this.fReq = (Requirement) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setReq(final Requirement pReq) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fReq = pReq;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.requirementNotSatisfied";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return RequirementNotSatisfied.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fReq};
+    }
+    
+    @Override
+    public RequirementNotSatisfied.Match toImmutable() {
+      return isMutable() ? newMatch(fReq) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Req\"=" + prettyPrintValue(fReq));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fReq);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof RequirementNotSatisfied.Match)) {
+          RequirementNotSatisfied.Match other = (RequirementNotSatisfied.Match) obj;
+          return Objects.equals(fReq, other.fReq);
+      } 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 RequirementNotSatisfied specification() {
+      return RequirementNotSatisfied.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 RequirementNotSatisfied.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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static RequirementNotSatisfied.Match newMutableMatch(final Requirement pReq) {
+      return new Mutable(pReq);
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static RequirementNotSatisfied.Match newMatch(final Requirement pReq) {
+      return new Immutable(pReq);
+    }
+    
+    private static final class Mutable extends RequirementNotSatisfied.Match {
+      Mutable(final Requirement pReq) {
+        super(pReq);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends RequirementNotSatisfied.Match {
+      Immutable(final Requirement pReq) {
+        super(pReq);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.requirementNotSatisfied 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(severity = "error", key = {Req},
+   *    message = "Requirement is not satisfied by enough application instances.")
+   * pattern requirementNotSatisfied(Req : Requirement) {
+   *    Instances == count find satisfyingInstance(Req, _);
+   *    Requirement.count(Req, RequiredCount);
+   *    check(Instances {@literal <} RequiredCount);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see RequirementNotSatisfied
+   * 
+   */
+  public static class Matcher extends BaseMatcher<RequirementNotSatisfied.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 RequirementNotSatisfied.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 RequirementNotSatisfied.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_REQ = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(RequirementNotSatisfied.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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<RequirementNotSatisfied.Match> getAllMatches(final Requirement pReq) {
+      return rawStreamAllMatches(new Object[]{pReq}).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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<RequirementNotSatisfied.Match> streamAllMatches(final Requirement pReq) {
+      return rawStreamAllMatches(new Object[]{pReq});
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<RequirementNotSatisfied.Match> getOneArbitraryMatch(final Requirement pReq) {
+      return rawGetOneArbitraryMatch(new Object[]{pReq});
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final Requirement pReq) {
+      return rawHasMatch(new Object[]{pReq});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final Requirement pReq) {
+      return rawCountMatches(new Object[]{pReq});
+    }
+    
+    /**
+     * 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 pReq the fixed value of pattern parameter Req, 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 Requirement pReq, final Consumer<? super RequirementNotSatisfied.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pReq}, 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 pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public RequirementNotSatisfied.Match newMatch(final Requirement pReq) {
+      return RequirementNotSatisfied.Match.newMatch(pReq);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<Requirement> rawStreamAllValuesOfReq(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_REQ, parameters).map(Requirement.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<Requirement> getAllValuesOfReq() {
+      return rawStreamAllValuesOfReq(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<Requirement> streamAllValuesOfReq() {
+      return rawStreamAllValuesOfReq(emptyArray());
+    }
+    
+    @Override
+    protected RequirementNotSatisfied.Match tupleToMatch(final Tuple t) {
+      try {
+          return RequirementNotSatisfied.Match.newMatch((Requirement) t.get(POSITION_REQ));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected RequirementNotSatisfied.Match arrayToMatch(final Object[] match) {
+      try {
+          return RequirementNotSatisfied.Match.newMatch((Requirement) match[POSITION_REQ]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected RequirementNotSatisfied.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return RequirementNotSatisfied.Match.newMutableMatch((Requirement) match[POSITION_REQ]);
+      } 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<RequirementNotSatisfied.Matcher> querySpecification() {
+      return RequirementNotSatisfied.instance();
+    }
+  }
+  
+  private RequirementNotSatisfied() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static RequirementNotSatisfied instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected RequirementNotSatisfied.Matcher instantiate(final ViatraQueryEngine engine) {
+    return RequirementNotSatisfied.Matcher.on(engine);
+  }
+  
+  @Override
+  public RequirementNotSatisfied.Matcher instantiate() {
+    return RequirementNotSatisfied.Matcher.create();
+  }
+  
+  @Override
+  public RequirementNotSatisfied.Match newEmptyMatch() {
+    return RequirementNotSatisfied.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public RequirementNotSatisfied.Match newMatch(final Object... parameters) {
+    return RequirementNotSatisfied.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.Requirement) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link RequirementNotSatisfied} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link RequirementNotSatisfied#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final RequirementNotSatisfied INSTANCE = new RequirementNotSatisfied();
+    
+    /**
+     * 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 RequirementNotSatisfied.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Req = new PParameter("Req", "hu.bme.mit.inf.dslreasoner.domains.cps.Requirement", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "Requirement")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Req);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.requirementNotSatisfied";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Req");
+    }
+    
+    @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_Req = body.getOrCreateVariableByName("Req");
+          PVariable var_Instances = body.getOrCreateVariableByName("Instances");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          PVariable var_RequiredCount = body.getOrCreateVariableByName("RequiredCount");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Req, parameter_Req)
+          ));
+          //    Instances == count find satisfyingInstance(Req, _)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new PatternMatchCounter(body, Tuples.flatTupleOf(var_Req, var___0_), SatisfyingInstance.instance().getInternalQueryRepresentation(), var__virtual_0_);
+          new Equality(body, var_Instances, var__virtual_0_);
+          //    Requirement.count(Req, RequiredCount)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "Requirement", "count")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          new Equality(body, var__virtual_1_, var_RequiredCount);
+          //    check(Instances < RequiredCount)
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern requirementNotSatisfied";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("Instances", "RequiredCount");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer Instances = (Integer) provider.getValue("Instances");
+                  Integer RequiredCount = (Integer) provider.getValue("RequiredCount");
+                  return evaluateExpression_1_1(Instances, RequiredCount);
+              }
+          },  null); 
+          bodies.add(body);
+      }
+      {
+          PAnnotation annotation = new PAnnotation("Constraint");
+          annotation.addAttribute("severity", "error");
+          annotation.addAttribute("key", Arrays.asList(new Object[] {
+                              new ParameterReference("Req")
+                              }));
+          annotation.addAttribute("message", "Requirement is not satisfied by enough application instances.");
+          addAnnotation(annotation);
+      }
+      return bodies;
+    }
+  }
+  
+  private static boolean evaluateExpression_1_1(final Integer Instances, final Integer RequiredCount) {
+    boolean _lessThan = (Instances.compareTo(RequiredCount) < 0);
+    return _lessThan;
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/ResourceRequirement.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/ResourceRequirement.java
new file mode 100644
index 00000000..23b578ea
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/ResourceRequirement.java
@@ -0,0 +1,841 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance;
+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 resourceRequirement(Host : HostInstance, App : ApplicationInstance, Req : ResourceRequirement) {
+ *              ApplicationInstance.allocatedTo(App, Host);
+ *              ApplicationInstance.type.requirements(App, Req);
+ *              HostInstance.type(Host, HostType);
+ *              ResourceRequirement.hostType(Req, HostType);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class ResourceRequirement extends BaseGeneratedEMFQuerySpecification<ResourceRequirement.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.resourceRequirement 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 HostInstance fHost;
+    
+    private ApplicationInstance fApp;
+    
+    private hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement fReq;
+    
+    private static List<String> parameterNames = makeImmutableList("Host", "App", "Req");
+    
+    private Match(final HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      this.fHost = pHost;
+      this.fApp = pApp;
+      this.fReq = pReq;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "Host": return this.fHost;
+          case "App": return this.fApp;
+          case "Req": return this.fReq;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fHost;
+          case 1: return this.fApp;
+          case 2: return this.fReq;
+          default: return null;
+      }
+    }
+    
+    public HostInstance getHost() {
+      return this.fHost;
+    }
+    
+    public ApplicationInstance getApp() {
+      return this.fApp;
+    }
+    
+    public hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement getReq() {
+      return this.fReq;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("Host".equals(parameterName) ) {
+          this.fHost = (HostInstance) newValue;
+          return true;
+      }
+      if ("App".equals(parameterName) ) {
+          this.fApp = (ApplicationInstance) newValue;
+          return true;
+      }
+      if ("Req".equals(parameterName) ) {
+          this.fReq = (hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setHost(final HostInstance pHost) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fHost = pHost;
+    }
+    
+    public void setApp(final ApplicationInstance pApp) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fApp = pApp;
+    }
+    
+    public void setReq(final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fReq = pReq;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.resourceRequirement";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return ResourceRequirement.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fHost, fApp, fReq};
+    }
+    
+    @Override
+    public ResourceRequirement.Match toImmutable() {
+      return isMutable() ? newMatch(fHost, fApp, fReq) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"Host\"=" + prettyPrintValue(fHost) + ", ");
+      result.append("\"App\"=" + prettyPrintValue(fApp) + ", ");
+      result.append("\"Req\"=" + prettyPrintValue(fReq));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fHost, fApp, fReq);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof ResourceRequirement.Match)) {
+          ResourceRequirement.Match other = (ResourceRequirement.Match) obj;
+          return Objects.equals(fHost, other.fHost) && Objects.equals(fApp, other.fApp) && Objects.equals(fReq, other.fReq);
+      } 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 ResourceRequirement specification() {
+      return ResourceRequirement.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 ResourceRequirement.Match newEmptyMatch() {
+      return new Mutable(null, 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static ResourceRequirement.Match newMutableMatch(final HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return new Mutable(pHost, pApp, pReq);
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static ResourceRequirement.Match newMatch(final HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return new Immutable(pHost, pApp, pReq);
+    }
+    
+    private static final class Mutable extends ResourceRequirement.Match {
+      Mutable(final HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+        super(pHost, pApp, pReq);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends ResourceRequirement.Match {
+      Immutable(final HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+        super(pHost, pApp, pReq);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.resourceRequirement 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 resourceRequirement(Host : HostInstance, App : ApplicationInstance, Req : ResourceRequirement) {
+   *    ApplicationInstance.allocatedTo(App, Host);
+   *    ApplicationInstance.type.requirements(App, Req);
+   *    HostInstance.type(Host, HostType);
+   *    ResourceRequirement.hostType(Req, HostType);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see ResourceRequirement
+   * 
+   */
+  public static class Matcher extends BaseMatcher<ResourceRequirement.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 ResourceRequirement.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 ResourceRequirement.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_HOST = 0;
+    
+    private static final int POSITION_APP = 1;
+    
+    private static final int POSITION_REQ = 2;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(ResourceRequirement.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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<ResourceRequirement.Match> getAllMatches(final HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return rawStreamAllMatches(new Object[]{pHost, pApp, pReq}).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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<ResourceRequirement.Match> streamAllMatches(final HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return rawStreamAllMatches(new Object[]{pHost, pApp, pReq});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<ResourceRequirement.Match> getOneArbitraryMatch(final HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return rawGetOneArbitraryMatch(new Object[]{pHost, pApp, pReq});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return rawHasMatch(new Object[]{pHost, pApp, pReq});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return rawCountMatches(new Object[]{pHost, pApp, pReq});
+    }
+    
+    /**
+     * 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pReq the fixed value of pattern parameter Req, 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 HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq, final Consumer<? super ResourceRequirement.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pHost, pApp, pReq}, 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 pHost the fixed value of pattern parameter Host, or null if not bound.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @param pReq the fixed value of pattern parameter Req, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public ResourceRequirement.Match newMatch(final HostInstance pHost, final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return ResourceRequirement.Match.newMatch(pHost, pApp, pReq);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<HostInstance> rawStreamAllValuesOfHost(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_HOST, parameters).map(HostInstance.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHost() {
+      return rawStreamAllValuesOfHost(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<HostInstance> streamAllValuesOfHost() {
+      return rawStreamAllValuesOfHost(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * </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<HostInstance> streamAllValuesOfHost(final ResourceRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfHost(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * </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<HostInstance> streamAllValuesOfHost(final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return rawStreamAllValuesOfHost(new Object[]{null, pApp, pReq});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHost(final ResourceRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfHost(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Host.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<HostInstance> getAllValuesOfHost(final ApplicationInstance pApp, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return rawStreamAllValuesOfHost(new Object[]{null, pApp, pReq}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<ApplicationInstance> rawStreamAllValuesOfApp(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_APP, parameters).map(ApplicationInstance.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp() {
+      return rawStreamAllValuesOfApp(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<ApplicationInstance> streamAllValuesOfApp() {
+      return rawStreamAllValuesOfApp(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * </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<ApplicationInstance> streamAllValuesOfApp(final ResourceRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfApp(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * </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<ApplicationInstance> streamAllValuesOfApp(final HostInstance pHost, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return rawStreamAllValuesOfApp(new Object[]{pHost, null, pReq});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp(final ResourceRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfApp(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp(final HostInstance pHost, final hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement pReq) {
+      return rawStreamAllValuesOfApp(new Object[]{pHost, null, pReq}).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement> rawStreamAllValuesOfReq(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_REQ, parameters).map(hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement> getAllValuesOfReq() {
+      return rawStreamAllValuesOfReq(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement> streamAllValuesOfReq() {
+      return rawStreamAllValuesOfReq(emptyArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * </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<hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement> streamAllValuesOfReq(final ResourceRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfReq(partialMatch.toArray());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * </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<hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement> streamAllValuesOfReq(final HostInstance pHost, final ApplicationInstance pApp) {
+      return rawStreamAllValuesOfReq(new Object[]{pHost, pApp, null});
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement> getAllValuesOfReq(final ResourceRequirement.Match partialMatch) {
+      return rawStreamAllValuesOfReq(partialMatch.toArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for Req.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement> getAllValuesOfReq(final HostInstance pHost, final ApplicationInstance pApp) {
+      return rawStreamAllValuesOfReq(new Object[]{pHost, pApp, null}).collect(Collectors.toSet());
+    }
+    
+    @Override
+    protected ResourceRequirement.Match tupleToMatch(final Tuple t) {
+      try {
+          return ResourceRequirement.Match.newMatch((HostInstance) t.get(POSITION_HOST), (ApplicationInstance) t.get(POSITION_APP), (hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement) t.get(POSITION_REQ));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected ResourceRequirement.Match arrayToMatch(final Object[] match) {
+      try {
+          return ResourceRequirement.Match.newMatch((HostInstance) match[POSITION_HOST], (ApplicationInstance) match[POSITION_APP], (hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement) match[POSITION_REQ]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected ResourceRequirement.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return ResourceRequirement.Match.newMutableMatch((HostInstance) match[POSITION_HOST], (ApplicationInstance) match[POSITION_APP], (hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement) match[POSITION_REQ]);
+      } 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<ResourceRequirement.Matcher> querySpecification() {
+      return ResourceRequirement.instance();
+    }
+  }
+  
+  private ResourceRequirement() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static ResourceRequirement instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected ResourceRequirement.Matcher instantiate(final ViatraQueryEngine engine) {
+    return ResourceRequirement.Matcher.on(engine);
+  }
+  
+  @Override
+  public ResourceRequirement.Matcher instantiate() {
+    return ResourceRequirement.Matcher.create();
+  }
+  
+  @Override
+  public ResourceRequirement.Match newEmptyMatch() {
+    return ResourceRequirement.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public ResourceRequirement.Match newMatch(final Object... parameters) {
+    return ResourceRequirement.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance) parameters[0], (hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance) parameters[1], (hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement) parameters[2]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link ResourceRequirement} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link ResourceRequirement#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final ResourceRequirement INSTANCE = new ResourceRequirement();
+    
+    /**
+     * 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 ResourceRequirement.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_App = new PParameter("App", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Req = new PParameter("Req", "hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ResourceRequirement")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host, parameter_App, parameter_Req);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.resourceRequirement";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host","App","Req");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_App = body.getOrCreateVariableByName("App");
+          PVariable var_Req = body.getOrCreateVariableByName("Req");
+          PVariable var_HostType = body.getOrCreateVariableByName("HostType");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ResourceRequirement")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host),
+             new ExportedParameter(body, var_App, parameter_App),
+             new ExportedParameter(body, var_Req, parameter_Req)
+          ));
+          //    ApplicationInstance.allocatedTo(App, Host)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "allocatedTo")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new Equality(body, var__virtual_0_, var_Host);
+          //    ApplicationInstance.type.requirements(App, Req)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "type")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationType")));
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationType", "requirements")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ResourceRequirement")));
+          new Equality(body, var__virtual_2_, var_Req);
+          //    HostInstance.type(Host, HostType)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          PVariable var__virtual_3_ = body.getOrCreateVariableByName(".virtual{3}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host, var__virtual_3_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "HostInstance", "type")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_3_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostType")));
+          new Equality(body, var__virtual_3_, var_HostType);
+          //    ResourceRequirement.hostType(Req, HostType)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ResourceRequirement")));
+          PVariable var__virtual_4_ = body.getOrCreateVariableByName(".virtual{4}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_4_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ResourceRequirement", "hostType")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_4_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostType")));
+          new Equality(body, var__virtual_4_, var_HostType);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/UnallocateAppInstance.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/UnallocateAppInstance.java
new file mode 100644
index 00000000..9f3d74b6
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/UnallocateAppInstance.java
@@ -0,0 +1,551 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance;
+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 unallocateAppInstance(App : ApplicationInstance) {
+ *              ApplicationInstance.allocatedTo(App, _);
+ *         }
+ * </pre></code>
+ * 
+ * @see Matcher
+ * @see Match
+ * 
+ */
+@SuppressWarnings("all")
+public final class UnallocateAppInstance extends BaseGeneratedEMFQuerySpecification<UnallocateAppInstance.Matcher> {
+  /**
+   * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.unallocateAppInstance 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 ApplicationInstance fApp;
+    
+    private static List<String> parameterNames = makeImmutableList("App");
+    
+    private Match(final ApplicationInstance pApp) {
+      this.fApp = pApp;
+    }
+    
+    @Override
+    public Object get(final String parameterName) {
+      switch(parameterName) {
+          case "App": return this.fApp;
+          default: return null;
+      }
+    }
+    
+    @Override
+    public Object get(final int index) {
+      switch(index) {
+          case 0: return this.fApp;
+          default: return null;
+      }
+    }
+    
+    public ApplicationInstance getApp() {
+      return this.fApp;
+    }
+    
+    @Override
+    public boolean set(final String parameterName, final Object newValue) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      if ("App".equals(parameterName) ) {
+          this.fApp = (ApplicationInstance) newValue;
+          return true;
+      }
+      return false;
+    }
+    
+    public void setApp(final ApplicationInstance pApp) {
+      if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+      this.fApp = pApp;
+    }
+    
+    @Override
+    public String patternName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.unallocateAppInstance";
+    }
+    
+    @Override
+    public List<String> parameterNames() {
+      return UnallocateAppInstance.Match.parameterNames;
+    }
+    
+    @Override
+    public Object[] toArray() {
+      return new Object[]{fApp};
+    }
+    
+    @Override
+    public UnallocateAppInstance.Match toImmutable() {
+      return isMutable() ? newMatch(fApp) : this;
+    }
+    
+    @Override
+    public String prettyPrint() {
+      StringBuilder result = new StringBuilder();
+      result.append("\"App\"=" + prettyPrintValue(fApp));
+      return result.toString();
+    }
+    
+    @Override
+    public int hashCode() {
+      return Objects.hash(fApp);
+    }
+    
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj)
+          return true;
+      if (obj == null) {
+          return false;
+      }
+      if ((obj instanceof UnallocateAppInstance.Match)) {
+          UnallocateAppInstance.Match other = (UnallocateAppInstance.Match) obj;
+          return Objects.equals(fApp, other.fApp);
+      } 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 UnallocateAppInstance specification() {
+      return UnallocateAppInstance.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 UnallocateAppInstance.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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the new, mutable (partial) match object.
+     * 
+     */
+    public static UnallocateAppInstance.Match newMutableMatch(final ApplicationInstance pApp) {
+      return new Mutable(pApp);
+    }
+    
+    /**
+     * 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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public static UnallocateAppInstance.Match newMatch(final ApplicationInstance pApp) {
+      return new Immutable(pApp);
+    }
+    
+    private static final class Mutable extends UnallocateAppInstance.Match {
+      Mutable(final ApplicationInstance pApp) {
+        super(pApp);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return true;
+      }
+    }
+    
+    private static final class Immutable extends UnallocateAppInstance.Match {
+      Immutable(final ApplicationInstance pApp) {
+        super(pApp);
+      }
+      
+      @Override
+      public boolean isMutable() {
+        return false;
+      }
+    }
+  }
+  
+  /**
+   * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.cps.queries.unallocateAppInstance 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 unallocateAppInstance(App : ApplicationInstance) {
+   *    ApplicationInstance.allocatedTo(App, _);
+   * }
+   * </pre></code>
+   * 
+   * @see Match
+   * @see UnallocateAppInstance
+   * 
+   */
+  public static class Matcher extends BaseMatcher<UnallocateAppInstance.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 UnallocateAppInstance.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 UnallocateAppInstance.Matcher create() {
+      return new Matcher();
+    }
+    
+    private static final int POSITION_APP = 0;
+    
+    private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(UnallocateAppInstance.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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return matches represented as a Match object.
+     * 
+     */
+    public Collection<UnallocateAppInstance.Match> getAllMatches(final ApplicationInstance pApp) {
+      return rawStreamAllMatches(new Object[]{pApp}).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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return a stream of matches represented as a Match object.
+     * 
+     */
+    public Stream<UnallocateAppInstance.Match> streamAllMatches(final ApplicationInstance pApp) {
+      return rawStreamAllMatches(new Object[]{pApp});
+    }
+    
+    /**
+     * 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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return a match represented as a Match object, or null if no match is found.
+     * 
+     */
+    public Optional<UnallocateAppInstance.Match> getOneArbitraryMatch(final ApplicationInstance pApp) {
+      return rawGetOneArbitraryMatch(new Object[]{pApp});
+    }
+    
+    /**
+     * 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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return true if the input is a valid (partial) match of the pattern.
+     * 
+     */
+    public boolean hasMatch(final ApplicationInstance pApp) {
+      return rawHasMatch(new Object[]{pApp});
+    }
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     * @param pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the number of pattern matches found.
+     * 
+     */
+    public int countMatches(final ApplicationInstance pApp) {
+      return rawCountMatches(new Object[]{pApp});
+    }
+    
+    /**
+     * 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 pApp the fixed value of pattern parameter App, 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 ApplicationInstance pApp, final Consumer<? super UnallocateAppInstance.Match> processor) {
+      return rawForOneArbitraryMatch(new Object[]{pApp}, 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 pApp the fixed value of pattern parameter App, or null if not bound.
+     * @return the (partial) match object.
+     * 
+     */
+    public UnallocateAppInstance.Match newMatch(final ApplicationInstance pApp) {
+      return UnallocateAppInstance.Match.newMatch(pApp);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    protected Stream<ApplicationInstance> rawStreamAllValuesOfApp(final Object[] parameters) {
+      return rawStreamAllValues(POSITION_APP, parameters).map(ApplicationInstance.class::cast);
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Set<ApplicationInstance> getAllValuesOfApp() {
+      return rawStreamAllValuesOfApp(emptyArray()).collect(Collectors.toSet());
+    }
+    
+    /**
+     * Retrieve the set of values that occur in matches for App.
+     * @return the Set of all values or empty set if there are no matches
+     * 
+     */
+    public Stream<ApplicationInstance> streamAllValuesOfApp() {
+      return rawStreamAllValuesOfApp(emptyArray());
+    }
+    
+    @Override
+    protected UnallocateAppInstance.Match tupleToMatch(final Tuple t) {
+      try {
+          return UnallocateAppInstance.Match.newMatch((ApplicationInstance) t.get(POSITION_APP));
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in tuple not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected UnallocateAppInstance.Match arrayToMatch(final Object[] match) {
+      try {
+          return UnallocateAppInstance.Match.newMatch((ApplicationInstance) match[POSITION_APP]);
+      } catch(ClassCastException e) {
+          LOGGER.error("Element(s) in array not properly typed!",e);
+          return null;
+      }
+    }
+    
+    @Override
+    protected UnallocateAppInstance.Match arrayToMatchMutable(final Object[] match) {
+      try {
+          return UnallocateAppInstance.Match.newMutableMatch((ApplicationInstance) match[POSITION_APP]);
+      } 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<UnallocateAppInstance.Matcher> querySpecification() {
+      return UnallocateAppInstance.instance();
+    }
+  }
+  
+  private UnallocateAppInstance() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static UnallocateAppInstance instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  @Override
+  protected UnallocateAppInstance.Matcher instantiate(final ViatraQueryEngine engine) {
+    return UnallocateAppInstance.Matcher.on(engine);
+  }
+  
+  @Override
+  public UnallocateAppInstance.Matcher instantiate() {
+    return UnallocateAppInstance.Matcher.create();
+  }
+  
+  @Override
+  public UnallocateAppInstance.Match newEmptyMatch() {
+    return UnallocateAppInstance.Match.newEmptyMatch();
+  }
+  
+  @Override
+  public UnallocateAppInstance.Match newMatch(final Object... parameters) {
+    return UnallocateAppInstance.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance) parameters[0]);
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link UnallocateAppInstance} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link UnallocateAppInstance#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final UnallocateAppInstance INSTANCE = new UnallocateAppInstance();
+    
+    /**
+     * 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 UnallocateAppInstance.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_App = new PParameter("App", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_App);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PUBLIC);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.unallocateAppInstance";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("App");
+    }
+    
+    @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_App = body.getOrCreateVariableByName("App");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_App, parameter_App)
+          ));
+          //    ApplicationInstance.allocatedTo(App, _)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "allocatedTo")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new Equality(body, var__virtual_0_, var___0_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/.gitignore b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/.gitignore
new file mode 100644
index 00000000..a4f039d9
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/.gitignore
@@ -0,0 +1,36 @@
+/.CpsQueriesAll.java._trace
+/.ResourceRequirement.java._trace
+/.MemoryRequirement.java._trace
+/.HddRequirement.java._trace
+/.AllocationWithoutResourceRequirement.java._trace
+/.RequiredType.java._trace
+/.SatisfyingInstance.java._trace
+/.FreeMemoryPercentage.java._trace
+/.FreeHddPercentage.java._trace
+/.ApplicationInstance.java._trace
+/.HostInstanceCost.java._trace
+/.AvailableHdd.java._trace
+/.AvailableMemory.java._trace
+/.CpsApplications.java._trace
+/.CpsHosts.java._trace
+/.TotalHdd.java._trace
+/.TotalMemory.java._trace
+/.RequiredAppInstances.java._trace
+/.UnallocatedAppInstance.java._trace
+/.NoHostToAllocateTo.java._trace
+/AvailableHdd.java
+/AvailableMemory.java
+/CpsApplications.java
+/CpsHosts.java
+/CpsQueriesAll.java
+/FreeHddPercentage.java
+/FreeMemoryPercentage.java
+/HddRequirement.java
+/HostInstanceCost.java
+/MemoryRequirement.java
+/NoHostToAllocateTo.java
+/RequiredAppInstances.java
+/SatisfyingInstance.java
+/TotalHdd.java
+/TotalMemory.java
+/UnallocatedAppInstance.java
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/AvailableHdd.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/AvailableHdd.java
new file mode 100644
index 00000000..8a150288
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/AvailableHdd.java
@@ -0,0 +1,178 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.HddRequirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.TotalHdd;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.aggregators.sum;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+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.AggregatorConstraint;
+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.ExpressionEvaluation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint;
+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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern availableHdd(Host : HostInstance, Hdd : java Integer) {
+ *              find totalHdd(Host, TotalHdd);
+ *              RequiredHdd == sum find hddRequirement(Host, _, #_);
+ *              Hdd == eval(TotalHdd - RequiredHdd);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class AvailableHdd extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private AvailableHdd() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static AvailableHdd instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link AvailableHdd} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link AvailableHdd#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final AvailableHdd INSTANCE = new AvailableHdd();
+    
+    /**
+     * 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 AvailableHdd.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Hdd = new PParameter("Hdd", "java.lang.Integer", new JavaTransitiveInstancesKey(java.lang.Integer.class), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host, parameter_Hdd);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.availableHdd";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host","Hdd");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_Hdd = body.getOrCreateVariableByName("Hdd");
+          PVariable var_TotalHdd = body.getOrCreateVariableByName("TotalHdd");
+          PVariable var_RequiredHdd = body.getOrCreateVariableByName("RequiredHdd");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          PVariable var___1_ = body.getOrCreateVariableByName("_<1>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new TypeFilterConstraint(body, Tuples.flatTupleOf(var_Hdd), new JavaTransitiveInstancesKey(java.lang.Integer.class));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host),
+             new ExportedParameter(body, var_Hdd, parameter_Hdd)
+          ));
+          //    find totalHdd(Host, TotalHdd)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_TotalHdd), TotalHdd.instance().getInternalQueryRepresentation());
+          //    RequiredHdd == sum find hddRequirement(Host, _, #_)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new AggregatorConstraint(new sum().getAggregatorLogic(Integer.class), body, Tuples.flatTupleOf(var_Host, var___0_, var___1_), HddRequirement.instance().getInternalQueryRepresentation(), var__virtual_0_, 2);
+          new Equality(body, var_RequiredHdd, var__virtual_0_);
+          //    Hdd == eval(TotalHdd - RequiredHdd)
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern availableHdd";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("RequiredHdd", "TotalHdd");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer RequiredHdd = (Integer) provider.getValue("RequiredHdd");
+                  Integer TotalHdd = (Integer) provider.getValue("TotalHdd");
+                  return evaluateExpression_1_1(RequiredHdd, TotalHdd);
+              }
+          },  var__virtual_1_ ); 
+          new Equality(body, var_Hdd, var__virtual_1_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+  
+  private static int evaluateExpression_1_1(final Integer RequiredHdd, final Integer TotalHdd) {
+    return ((TotalHdd).intValue() - (RequiredHdd).intValue());
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/AvailableMemory.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/AvailableMemory.java
new file mode 100644
index 00000000..c89872e6
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/AvailableMemory.java
@@ -0,0 +1,178 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.MemoryRequirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.TotalMemory;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.aggregators.sum;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+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.AggregatorConstraint;
+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.ExpressionEvaluation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint;
+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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern availableMemory(Host : HostInstance, Memory : java Integer) {
+ *              find totalMemory(Host, TotalMemory);
+ *              RequiredMemory == sum find memoryRequirement(Host, _, #_);
+ *              Memory == eval(TotalMemory - RequiredMemory);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class AvailableMemory extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private AvailableMemory() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static AvailableMemory instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link AvailableMemory} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link AvailableMemory#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final AvailableMemory INSTANCE = new AvailableMemory();
+    
+    /**
+     * 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 AvailableMemory.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Memory = new PParameter("Memory", "java.lang.Integer", new JavaTransitiveInstancesKey(java.lang.Integer.class), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host, parameter_Memory);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.availableMemory";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host","Memory");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_Memory = body.getOrCreateVariableByName("Memory");
+          PVariable var_TotalMemory = body.getOrCreateVariableByName("TotalMemory");
+          PVariable var_RequiredMemory = body.getOrCreateVariableByName("RequiredMemory");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          PVariable var___1_ = body.getOrCreateVariableByName("_<1>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new TypeFilterConstraint(body, Tuples.flatTupleOf(var_Memory), new JavaTransitiveInstancesKey(java.lang.Integer.class));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host),
+             new ExportedParameter(body, var_Memory, parameter_Memory)
+          ));
+          //    find totalMemory(Host, TotalMemory)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_TotalMemory), TotalMemory.instance().getInternalQueryRepresentation());
+          //    RequiredMemory == sum find memoryRequirement(Host, _, #_)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new AggregatorConstraint(new sum().getAggregatorLogic(Integer.class), body, Tuples.flatTupleOf(var_Host, var___0_, var___1_), MemoryRequirement.instance().getInternalQueryRepresentation(), var__virtual_0_, 2);
+          new Equality(body, var_RequiredMemory, var__virtual_0_);
+          //    Memory == eval(TotalMemory - RequiredMemory)
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern availableMemory";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("RequiredMemory", "TotalMemory");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer RequiredMemory = (Integer) provider.getValue("RequiredMemory");
+                  Integer TotalMemory = (Integer) provider.getValue("TotalMemory");
+                  return evaluateExpression_1_1(RequiredMemory, TotalMemory);
+              }
+          },  var__virtual_1_ ); 
+          new Equality(body, var_Memory, var__virtual_1_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+  
+  private static int evaluateExpression_1_1(final Integer RequiredMemory, final Integer TotalMemory) {
+    return ((TotalMemory).intValue() - (RequiredMemory).intValue());
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/CpsApplications.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/CpsApplications.java
new file mode 100644
index 00000000..fe115086
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/CpsApplications.java
@@ -0,0 +1,141 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern cpsApplications(Cps : CyberPhysicalSystem, AppInstance : ApplicationInstance) {
+ *              CyberPhysicalSystem.applicationTypes.instances(Cps, AppInstance);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class CpsApplications extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private CpsApplications() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static CpsApplications instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link CpsApplications} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link CpsApplications#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final CpsApplications INSTANCE = new CpsApplications();
+    
+    /**
+     * 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 CpsApplications.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Cps = new PParameter("Cps", "hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "CyberPhysicalSystem")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_AppInstance = new PParameter("AppInstance", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Cps, parameter_AppInstance);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.cpsApplications";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Cps","AppInstance");
+    }
+    
+    @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_Cps = body.getOrCreateVariableByName("Cps");
+          PVariable var_AppInstance = body.getOrCreateVariableByName("AppInstance");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Cps), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "CyberPhysicalSystem")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_AppInstance), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Cps, parameter_Cps),
+             new ExportedParameter(body, var_AppInstance, parameter_AppInstance)
+          ));
+          //    CyberPhysicalSystem.applicationTypes.instances(Cps, AppInstance)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Cps), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "CyberPhysicalSystem")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Cps, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "CyberPhysicalSystem", "applicationTypes")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationType")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationType", "instances")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          new Equality(body, var__virtual_1_, var_AppInstance);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/CpsHosts.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/CpsHosts.java
new file mode 100644
index 00000000..cea8c097
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/CpsHosts.java
@@ -0,0 +1,141 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern cpsHosts(Cps : CyberPhysicalSystem, HostInstance : HostInstance) {
+ *              CyberPhysicalSystem.hostTypes.instances(Cps, HostInstance);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class CpsHosts extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private CpsHosts() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static CpsHosts instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link CpsHosts} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link CpsHosts#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final CpsHosts INSTANCE = new CpsHosts();
+    
+    /**
+     * 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 CpsHosts.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Cps = new PParameter("Cps", "hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "CyberPhysicalSystem")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_HostInstance = new PParameter("HostInstance", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Cps, parameter_HostInstance);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.cpsHosts";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Cps","HostInstance");
+    }
+    
+    @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_Cps = body.getOrCreateVariableByName("Cps");
+          PVariable var_HostInstance = body.getOrCreateVariableByName("HostInstance");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Cps), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "CyberPhysicalSystem")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_HostInstance), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Cps, parameter_Cps),
+             new ExportedParameter(body, var_HostInstance, parameter_HostInstance)
+          ));
+          //    CyberPhysicalSystem.hostTypes.instances(Cps, HostInstance)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Cps), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "CyberPhysicalSystem")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Cps, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "CyberPhysicalSystem", "hostTypes")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostType")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "HostType", "instances")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new Equality(body, var__virtual_1_, var_HostInstance);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/CpsQueriesAll.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/CpsQueriesAll.java
new file mode 100644
index 00000000..67f75e1d
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/CpsQueriesAll.java
@@ -0,0 +1,132 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.Allocate;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.AllocationWithoutResourceRequirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.AverageFreeHddMetric;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.AverageFreeMemoryMetric;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.CostMetric;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.CpsCost;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.CreateHostInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.GuidanceObjective;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.InstanceDoesNotSatisfyRequirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.NotEnoughAvailableHdd;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.NotEnoughAvailableMemory;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.RedundantInstancesOnSameHost;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.RemoveHostInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.RequirementNotSatisfied;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.ResourceRequirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.UnallocateAppInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.AvailableHdd;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.AvailableMemory;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.CpsApplications;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.CpsHosts;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.FreeHddPercentage;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.FreeMemoryPercentage;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.HddRequirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.HostInstanceCost;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.MemoryRequirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.NoHostToAllocateTo;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.RequiredAppInstances;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.SatisfyingInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.TotalHdd;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.TotalMemory;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.UnallocatedAppInstance;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedPatternGroup;
+
+/**
+ * A pattern group formed of all patterns defined in CpsQueries.vql.
+ * 
+ * <p>A private group that includes private patterns as well. Only intended use case is for pattern testing.
+ * 
+ * <p> From package hu.bme.mit.inf.dslreasoner.domains.cps.queries, the group contains the definition of the following patterns: <ul>
+ * <li>cpsApplications</li>
+ * <li>cpsHosts</li>
+ * <li>totalMemory</li>
+ * <li>totalHdd</li>
+ * <li>availableMemory</li>
+ * <li>memoryRequirement</li>
+ * <li>availableHdd</li>
+ * <li>hddRequirement</li>
+ * <li>resourceRequirement</li>
+ * <li>allocationWithoutResourceRequirement</li>
+ * <li>notEnoughAvailableMemory</li>
+ * <li>notEnoughAvailableHdd</li>
+ * <li>instanceDoesNotSatisfyRequirement</li>
+ * <li>satisfyingInstance</li>
+ * <li>requirementNotSatisfied</li>
+ * <li>redundantInstancesOnSameHost</li>
+ * <li>averageFreeMemoryMetric</li>
+ * <li>freeMemoryPercentage</li>
+ * <li>averageFreeHddMetric</li>
+ * <li>freeHddPercentage</li>
+ * <li>costMetric</li>
+ * <li>cpsCost</li>
+ * <li>hostInstanceCost</li>
+ * <li>allocate</li>
+ * <li>unallocateAppInstance</li>
+ * <li>createHostInstance</li>
+ * <li>removeHostInstance</li>
+ * <li>unallocatedAppInstance</li>
+ * <li>requiredAppInstances</li>
+ * <li>noHostToAllocateTo</li>
+ * <li>guidanceObjective</li>
+ * </ul>
+ * 
+ * @see IQueryGroup
+ * 
+ */
+@SuppressWarnings("all")
+public final class CpsQueriesAll 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 CpsQueriesAll instance() {
+    if (INSTANCE == null) {
+        INSTANCE = new CpsQueriesAll();
+    }
+    return INSTANCE;
+  }
+  
+  private static CpsQueriesAll INSTANCE;
+  
+  private CpsQueriesAll() {
+    querySpecifications.add(CpsApplications.instance());
+    querySpecifications.add(CpsHosts.instance());
+    querySpecifications.add(TotalMemory.instance());
+    querySpecifications.add(TotalHdd.instance());
+    querySpecifications.add(AvailableMemory.instance());
+    querySpecifications.add(MemoryRequirement.instance());
+    querySpecifications.add(AvailableHdd.instance());
+    querySpecifications.add(HddRequirement.instance());
+    querySpecifications.add(ResourceRequirement.instance());
+    querySpecifications.add(AllocationWithoutResourceRequirement.instance());
+    querySpecifications.add(NotEnoughAvailableMemory.instance());
+    querySpecifications.add(NotEnoughAvailableHdd.instance());
+    querySpecifications.add(InstanceDoesNotSatisfyRequirement.instance());
+    querySpecifications.add(SatisfyingInstance.instance());
+    querySpecifications.add(RequirementNotSatisfied.instance());
+    querySpecifications.add(RedundantInstancesOnSameHost.instance());
+    querySpecifications.add(AverageFreeMemoryMetric.instance());
+    querySpecifications.add(FreeMemoryPercentage.instance());
+    querySpecifications.add(AverageFreeHddMetric.instance());
+    querySpecifications.add(FreeHddPercentage.instance());
+    querySpecifications.add(CostMetric.instance());
+    querySpecifications.add(CpsCost.instance());
+    querySpecifications.add(HostInstanceCost.instance());
+    querySpecifications.add(Allocate.instance());
+    querySpecifications.add(UnallocateAppInstance.instance());
+    querySpecifications.add(CreateHostInstance.instance());
+    querySpecifications.add(RemoveHostInstance.instance());
+    querySpecifications.add(UnallocatedAppInstance.instance());
+    querySpecifications.add(RequiredAppInstances.instance());
+    querySpecifications.add(NoHostToAllocateTo.instance());
+    querySpecifications.add(GuidanceObjective.instance());
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/FreeHddPercentage.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/FreeHddPercentage.java
new file mode 100644
index 00000000..ed5c9cda
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/FreeHddPercentage.java
@@ -0,0 +1,172 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.AvailableHdd;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.TotalHdd;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+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.context.common.JavaTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+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.basicdeferred.ExpressionEvaluation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint;
+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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern freeHddPercentage(Host : HostInstance, Free : java Double) {
+ *              find totalHdd(Host, Total);
+ *              find availableHdd(Host, Available);
+ *              Free == eval((Available as double) / Total);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class FreeHddPercentage extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private FreeHddPercentage() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static FreeHddPercentage instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link FreeHddPercentage} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link FreeHddPercentage#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final FreeHddPercentage INSTANCE = new FreeHddPercentage();
+    
+    /**
+     * 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 FreeHddPercentage.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Free = new PParameter("Free", "java.lang.Double", new JavaTransitiveInstancesKey(java.lang.Double.class), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host, parameter_Free);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.freeHddPercentage";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host","Free");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_Free = body.getOrCreateVariableByName("Free");
+          PVariable var_Total = body.getOrCreateVariableByName("Total");
+          PVariable var_Available = body.getOrCreateVariableByName("Available");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new TypeFilterConstraint(body, Tuples.flatTupleOf(var_Free), new JavaTransitiveInstancesKey(java.lang.Double.class));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host),
+             new ExportedParameter(body, var_Free, parameter_Free)
+          ));
+          //    find totalHdd(Host, Total)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_Total), TotalHdd.instance().getInternalQueryRepresentation());
+          //    find availableHdd(Host, Available)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_Available), AvailableHdd.instance().getInternalQueryRepresentation());
+          //    Free == eval((Available as double) / Total)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern freeHddPercentage";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("Available", "Total");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer Available = (Integer) provider.getValue("Available");
+                  Integer Total = (Integer) provider.getValue("Total");
+                  return evaluateExpression_1_1(Available, Total);
+              }
+          },  var__virtual_0_ ); 
+          new Equality(body, var_Free, var__virtual_0_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+  
+  private static double evaluateExpression_1_1(final Integer Available, final Integer Total) {
+    return (((double) (Available).intValue()) / (Total).intValue());
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/FreeMemoryPercentage.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/FreeMemoryPercentage.java
new file mode 100644
index 00000000..b5923ba9
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/FreeMemoryPercentage.java
@@ -0,0 +1,172 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.AvailableMemory;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.TotalMemory;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+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.context.common.JavaTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+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.basicdeferred.ExpressionEvaluation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint;
+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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern freeMemoryPercentage(Host : HostInstance, Free : java Double) {
+ *              find totalMemory(Host, Total);
+ *              find availableMemory(Host, Available);
+ *              Free == eval((Available as double) / Total);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class FreeMemoryPercentage extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private FreeMemoryPercentage() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static FreeMemoryPercentage instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link FreeMemoryPercentage} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link FreeMemoryPercentage#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final FreeMemoryPercentage INSTANCE = new FreeMemoryPercentage();
+    
+    /**
+     * 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 FreeMemoryPercentage.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Free = new PParameter("Free", "java.lang.Double", new JavaTransitiveInstancesKey(java.lang.Double.class), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host, parameter_Free);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.freeMemoryPercentage";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host","Free");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_Free = body.getOrCreateVariableByName("Free");
+          PVariable var_Total = body.getOrCreateVariableByName("Total");
+          PVariable var_Available = body.getOrCreateVariableByName("Available");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new TypeFilterConstraint(body, Tuples.flatTupleOf(var_Free), new JavaTransitiveInstancesKey(java.lang.Double.class));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host),
+             new ExportedParameter(body, var_Free, parameter_Free)
+          ));
+          //    find totalMemory(Host, Total)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_Total), TotalMemory.instance().getInternalQueryRepresentation());
+          //    find availableMemory(Host, Available)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_Available), AvailableMemory.instance().getInternalQueryRepresentation());
+          //    Free == eval((Available as double) / Total)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern freeMemoryPercentage";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("Available", "Total");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer Available = (Integer) provider.getValue("Available");
+                  Integer Total = (Integer) provider.getValue("Total");
+                  return evaluateExpression_1_1(Available, Total);
+              }
+          },  var__virtual_0_ ); 
+          new Equality(body, var_Free, var__virtual_0_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+  
+  private static double evaluateExpression_1_1(final Integer Available, final Integer Total) {
+    return (((double) (Available).intValue()) / (Total).intValue());
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/HddRequirement.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/HddRequirement.java
new file mode 100644
index 00000000..4e6a2d10
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/HddRequirement.java
@@ -0,0 +1,151 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.ResourceRequirement;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+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.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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern hddRequirement(Host : HostInstance, App : ApplicationInstance, Hdd : EInt) {
+ *              find resourceRequirement(Host, App, Req);
+ *              ResourceRequirement.requiredHdd(Req, Hdd);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class HddRequirement extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private HddRequirement() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static HddRequirement instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link HddRequirement} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link HddRequirement#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final HddRequirement INSTANCE = new HddRequirement();
+    
+    /**
+     * 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 HddRequirement.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_App = new PParameter("App", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Hdd = new PParameter("Hdd", "java.lang.Integer", new EDataTypeInSlotsKey((EDataType)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EInt")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host, parameter_App, parameter_Hdd);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.hddRequirement";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host","App","Hdd");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_App = body.getOrCreateVariableByName("App");
+          PVariable var_Hdd = body.getOrCreateVariableByName("Hdd");
+          PVariable var_Req = body.getOrCreateVariableByName("Req");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Hdd), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host),
+             new ExportedParameter(body, var_App, parameter_App),
+             new ExportedParameter(body, var_Hdd, parameter_Hdd)
+          ));
+          //    find resourceRequirement(Host, App, Req)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_App, var_Req), ResourceRequirement.instance().getInternalQueryRepresentation());
+          //    ResourceRequirement.requiredHdd(Req, Hdd)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ResourceRequirement")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ResourceRequirement", "requiredHdd")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          new Equality(body, var__virtual_0_, var_Hdd);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/HostInstanceCost.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/HostInstanceCost.java
new file mode 100644
index 00000000..429817ce
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/HostInstanceCost.java
@@ -0,0 +1,153 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.CpsHosts;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+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.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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern hostInstanceCost(Cps : CyberPhysicalSystem, Host : HostInstance, Cost : EInt) {
+ *              find cpsHosts(Cps, Host);
+ *              HostInstance.type.cost(Host, Cost);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class HostInstanceCost extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private HostInstanceCost() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static HostInstanceCost instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link HostInstanceCost} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link HostInstanceCost#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final HostInstanceCost INSTANCE = new HostInstanceCost();
+    
+    /**
+     * 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 HostInstanceCost.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Cps = new PParameter("Cps", "hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "CyberPhysicalSystem")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Cost = new PParameter("Cost", "java.lang.Integer", new EDataTypeInSlotsKey((EDataType)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EInt")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Cps, parameter_Host, parameter_Cost);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.hostInstanceCost";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Cps","Host","Cost");
+    }
+    
+    @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_Cps = body.getOrCreateVariableByName("Cps");
+          PVariable var_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_Cost = body.getOrCreateVariableByName("Cost");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Cps), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "CyberPhysicalSystem")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Cost), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Cps, parameter_Cps),
+             new ExportedParameter(body, var_Host, parameter_Host),
+             new ExportedParameter(body, var_Cost, parameter_Cost)
+          ));
+          //    find cpsHosts(Cps, Host)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Cps, var_Host), CpsHosts.instance().getInternalQueryRepresentation());
+          //    HostInstance.type.cost(Host, Cost)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "HostInstance", "type")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostType")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "HostType", "cost")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          new Equality(body, var__virtual_1_, var_Cost);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/MemoryRequirement.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/MemoryRequirement.java
new file mode 100644
index 00000000..98924467
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/MemoryRequirement.java
@@ -0,0 +1,151 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.ResourceRequirement;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+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.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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern memoryRequirement(Host : HostInstance, App : ApplicationInstance, Memory : EInt) {
+ *              find resourceRequirement(Host, App, Req);
+ *              ResourceRequirement.requiredMemory(Req, Memory);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class MemoryRequirement extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private MemoryRequirement() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static MemoryRequirement instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link MemoryRequirement} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link MemoryRequirement#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final MemoryRequirement INSTANCE = new MemoryRequirement();
+    
+    /**
+     * 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 MemoryRequirement.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_App = new PParameter("App", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Memory = new PParameter("Memory", "java.lang.Integer", new EDataTypeInSlotsKey((EDataType)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EInt")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host, parameter_App, parameter_Memory);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.memoryRequirement";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host","App","Memory");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_App = body.getOrCreateVariableByName("App");
+          PVariable var_Memory = body.getOrCreateVariableByName("Memory");
+          PVariable var_Req = body.getOrCreateVariableByName("Req");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Memory), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host),
+             new ExportedParameter(body, var_App, parameter_App),
+             new ExportedParameter(body, var_Memory, parameter_Memory)
+          ));
+          //    find resourceRequirement(Host, App, Req)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_Host, var_App, var_Req), ResourceRequirement.instance().getInternalQueryRepresentation());
+          //    ResourceRequirement.requiredMemory(Req, Memory)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ResourceRequirement")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ResourceRequirement", "requiredMemory")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          new Equality(body, var__virtual_0_, var_Memory);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/NoHostToAllocateTo.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/NoHostToAllocateTo.java
new file mode 100644
index 00000000..155ed09b
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/NoHostToAllocateTo.java
@@ -0,0 +1,135 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.Allocate;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.UnallocatedAppInstance;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+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.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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern noHostToAllocateTo(App : ApplicationInstance) {
+ *              find unallocatedAppInstance(App);
+ *              neg find allocate(App, _);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class NoHostToAllocateTo extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private NoHostToAllocateTo() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static NoHostToAllocateTo instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link NoHostToAllocateTo} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link NoHostToAllocateTo#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final NoHostToAllocateTo INSTANCE = new NoHostToAllocateTo();
+    
+    /**
+     * 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 NoHostToAllocateTo.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_App = new PParameter("App", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_App);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.noHostToAllocateTo";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("App");
+    }
+    
+    @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_App = body.getOrCreateVariableByName("App");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_App, parameter_App)
+          ));
+          //    find unallocatedAppInstance(App)
+          new PositivePatternCall(body, Tuples.flatTupleOf(var_App), UnallocatedAppInstance.instance().getInternalQueryRepresentation());
+          //    neg find allocate(App, _)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_App, var___0_), Allocate.instance().getInternalQueryRepresentation());
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/RequiredAppInstances.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/RequiredAppInstances.java
new file mode 100644
index 00000000..ffce9148
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/RequiredAppInstances.java
@@ -0,0 +1,181 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal.SatisfyingInstance;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+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.context.common.JavaTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+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.basicdeferred.ExpressionEvaluation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.PatternMatchCounter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint;
+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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern requiredAppInstances(Req : Requirement, Remaining : java Integer) {
+ *              Instances == count find satisfyingInstance(Req, _);
+ *              Requirement.count(Req, RequiredCount);
+ *              Remaining == eval(RequiredCount - Instances);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class RequiredAppInstances extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private RequiredAppInstances() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static RequiredAppInstances instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link RequiredAppInstances} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link RequiredAppInstances#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final RequiredAppInstances INSTANCE = new RequiredAppInstances();
+    
+    /**
+     * 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 RequiredAppInstances.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Req = new PParameter("Req", "hu.bme.mit.inf.dslreasoner.domains.cps.Requirement", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "Requirement")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Remaining = new PParameter("Remaining", "java.lang.Integer", new JavaTransitiveInstancesKey(java.lang.Integer.class), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Req, parameter_Remaining);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.requiredAppInstances";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Req","Remaining");
+    }
+    
+    @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_Req = body.getOrCreateVariableByName("Req");
+          PVariable var_Remaining = body.getOrCreateVariableByName("Remaining");
+          PVariable var_Instances = body.getOrCreateVariableByName("Instances");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          PVariable var_RequiredCount = body.getOrCreateVariableByName("RequiredCount");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          new TypeFilterConstraint(body, Tuples.flatTupleOf(var_Remaining), new JavaTransitiveInstancesKey(java.lang.Integer.class));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Req, parameter_Req),
+             new ExportedParameter(body, var_Remaining, parameter_Remaining)
+          ));
+          //    Instances == count find satisfyingInstance(Req, _)
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new PatternMatchCounter(body, Tuples.flatTupleOf(var_Req, var___0_), SatisfyingInstance.instance().getInternalQueryRepresentation(), var__virtual_0_);
+          new Equality(body, var_Instances, var__virtual_0_);
+          //    Requirement.count(Req, RequiredCount)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "Requirement", "count")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          new Equality(body, var__virtual_1_, var_RequiredCount);
+          //    Remaining == eval(RequiredCount - Instances)
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new ExpressionEvaluation(body, new IExpressionEvaluator() {
+          
+              @Override
+              public String getShortDescription() {
+                  return "Expression evaluation from pattern requiredAppInstances";
+              }
+              
+              @Override
+              public Iterable<String> getInputParameterNames() {
+                  return Arrays.asList("Instances", "RequiredCount");}
+          
+              @Override
+              public Object evaluateExpression(IValueProvider provider) throws Exception {
+                  Integer Instances = (Integer) provider.getValue("Instances");
+                  Integer RequiredCount = (Integer) provider.getValue("RequiredCount");
+                  return evaluateExpression_1_1(Instances, RequiredCount);
+              }
+          },  var__virtual_2_ ); 
+          new Equality(body, var_Remaining, var__virtual_2_);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+  
+  private static int evaluateExpression_1_1(final Integer Instances, final Integer RequiredCount) {
+    return ((RequiredCount).intValue() - (Instances).intValue());
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/SatisfyingInstance.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/SatisfyingInstance.java
new file mode 100644
index 00000000..dea68f94
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/SatisfyingInstance.java
@@ -0,0 +1,153 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern satisfyingInstance(Req : Requirement, App : ApplicationInstance) {
+ *              Requirement.instances(Req, App);
+ *              Requirement.type(Req, Type);
+ *              ApplicationInstance.type(App, Type);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class SatisfyingInstance extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private SatisfyingInstance() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static SatisfyingInstance instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link SatisfyingInstance} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link SatisfyingInstance#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final SatisfyingInstance INSTANCE = new SatisfyingInstance();
+    
+    /**
+     * 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 SatisfyingInstance.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Req = new PParameter("Req", "hu.bme.mit.inf.dslreasoner.domains.cps.Requirement", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "Requirement")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_App = new PParameter("App", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Req, parameter_App);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.satisfyingInstance";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Req","App");
+    }
+    
+    @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_Req = body.getOrCreateVariableByName("Req");
+          PVariable var_App = body.getOrCreateVariableByName("App");
+          PVariable var_Type = body.getOrCreateVariableByName("Type");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Req, parameter_Req),
+             new ExportedParameter(body, var_App, parameter_App)
+          ));
+          //    Requirement.instances(Req, App)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "Requirement", "instances")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          new Equality(body, var__virtual_0_, var_App);
+          //    Requirement.type(Req, Type)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "Requirement")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Req, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "Requirement", "type")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationType")));
+          new Equality(body, var__virtual_1_, var_Type);
+          //    ApplicationInstance.type(App, Type)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "type")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationType")));
+          new Equality(body, var__virtual_2_, var_Type);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/TotalHdd.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/TotalHdd.java
new file mode 100644
index 00000000..efa13033
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/TotalHdd.java
@@ -0,0 +1,143 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern totalHdd(Host : HostInstance, Hdd : EInt) {
+ *              HostInstance.type.defaultHdd(Host, Hdd);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class TotalHdd extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private TotalHdd() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static TotalHdd instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link TotalHdd} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link TotalHdd#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final TotalHdd INSTANCE = new TotalHdd();
+    
+    /**
+     * 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 TotalHdd.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Hdd = new PParameter("Hdd", "java.lang.Integer", new EDataTypeInSlotsKey((EDataType)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EInt")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host, parameter_Hdd);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.totalHdd";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host","Hdd");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_Hdd = body.getOrCreateVariableByName("Hdd");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Hdd), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host),
+             new ExportedParameter(body, var_Hdd, parameter_Hdd)
+          ));
+          //    HostInstance.type.defaultHdd(Host, Hdd)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "HostInstance", "type")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostType")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "HostType", "defaultHdd")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          new Equality(body, var__virtual_1_, var_Hdd);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/TotalMemory.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/TotalMemory.java
new file mode 100644
index 00000000..2fe3e741
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/TotalMemory.java
@@ -0,0 +1,143 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern totalMemory(Host : HostInstance, Memory : EInt) {
+ *              HostInstance.type.defaultMemory(Host, Memory);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class TotalMemory extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private TotalMemory() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static TotalMemory instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link TotalMemory} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link TotalMemory#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final TotalMemory INSTANCE = new TotalMemory();
+    
+    /**
+     * 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 TotalMemory.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_Host = new PParameter("Host", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+    
+    private final PParameter parameter_Memory = new PParameter("Memory", "java.lang.Integer", new EDataTypeInSlotsKey((EDataType)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EInt")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_Host, parameter_Memory);
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.totalMemory";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("Host","Memory");
+    }
+    
+    @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_Host = body.getOrCreateVariableByName("Host");
+          PVariable var_Memory = body.getOrCreateVariableByName("Memory");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Memory), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_Host, parameter_Host),
+             new ExportedParameter(body, var_Memory, parameter_Memory)
+          ));
+          //    HostInstance.type.defaultMemory(Host, Memory)
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+          PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_Host, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "HostInstance", "type")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostType")));
+          PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "HostType", "defaultMemory")));
+          new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+          new Equality(body, var__virtual_1_, var_Memory);
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/UnallocatedAppInstance.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/UnallocatedAppInstance.java
new file mode 100644
index 00000000..66b315f4
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/src-gen/hu/bme/mit/inf/dslreasoner/domains/cps/queries/internal/UnallocatedAppInstance.java
@@ -0,0 +1,172 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.cps/src/hu/bme/mit/inf/dslreasoner/domains/cps/queries/CpsQueries.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.cps.queries.internal;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecificationWithGenericMatcher;
+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.basicdeferred.NegativePatternCall;
+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.Tuples;
+
+/**
+ * A pattern-specific query specification that can instantiate GenericPatternMatcher in a type-safe way.
+ * 
+ * <p>Original source:
+ *         <code><pre>
+ *         private pattern unallocatedAppInstance(App : ApplicationInstance) {
+ *              neg ApplicationInstance.allocatedTo(App, _);
+ *         }
+ * </pre></code>
+ * 
+ * @see GenericPatternMatcher
+ * @see GenericPatternMatch
+ * 
+ */
+@SuppressWarnings("all")
+public final class UnallocatedAppInstance extends BaseGeneratedEMFQuerySpecificationWithGenericMatcher {
+  private UnallocatedAppInstance() {
+    super(GeneratedPQuery.INSTANCE);
+  }
+  
+  /**
+   * @return the singleton instance of the query specification
+   * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+   * 
+   */
+  public static UnallocatedAppInstance instance() {
+    try{
+        return LazyHolder.INSTANCE;
+    } catch (ExceptionInInitializerError err) {
+        throw processInitializerError(err);
+    }
+  }
+  
+  /**
+   * Inner class allowing the singleton instance of {@link UnallocatedAppInstance} to be created 
+   *     <b>not</b> at the class load time of the outer class, 
+   *     but rather at the first call to {@link UnallocatedAppInstance#instance()}.
+   * 
+   * <p> This workaround is required e.g. to support recursion.
+   * 
+   */
+  private static class LazyHolder {
+    private static final UnallocatedAppInstance INSTANCE = new UnallocatedAppInstance();
+    
+    /**
+     * 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 UnallocatedAppInstance.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+    
+    private final PParameter parameter_App = new PParameter("App", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+    
+    private final List<PParameter> parameters = Arrays.asList(parameter_App);
+    
+    private class Embedded_1_ApplicationInstance_allocatedTo extends BaseGeneratedEMFPQuery {
+      private final PParameter parameter_p0 = new PParameter("p0", "hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "ApplicationInstance")), PParameterDirection.INOUT);
+      
+      private final PParameter parameter_p1 = new PParameter("p1", "hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/cps", "HostInstance")), PParameterDirection.INOUT);
+      
+      private final List<PParameter> embeddedParameters = Arrays.asList(parameter_p0, parameter_p1);
+      
+      public Embedded_1_ApplicationInstance_allocatedTo() {
+        super(PVisibility.EMBEDDED);
+      }
+      
+      @Override
+      public String getFullyQualifiedName() {
+        return GeneratedPQuery.this.getFullyQualifiedName() + "$Embedded_1_ApplicationInstance_allocatedTo";
+      }
+      
+      @Override
+      public List<PParameter> getParameters() {
+        return embeddedParameters;
+      }
+      
+      @Override
+      public Set<PBody> doGetContainedBodies() {
+        PBody body = new PBody(this);
+        PVariable var_p0 = body.getOrCreateVariableByName("p0");
+        PVariable var_p1 = body.getOrCreateVariableByName("p1");
+        body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+           new ExportedParameter(body, var_p0, parameter_p0),
+           new ExportedParameter(body, var_p1, parameter_p1)
+        ));
+        //  ApplicationInstance.allocatedTo(App, _)
+        new TypeConstraint(body, Tuples.flatTupleOf(var_p0), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+        PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+        new TypeConstraint(body, Tuples.flatTupleOf(var_p0, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/cps", "ApplicationInstance", "allocatedTo")));
+        new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "HostInstance")));
+        new Equality(body, var__virtual_0_, var_p1);
+        return Collections.singleton(body);
+      }
+    }
+    
+    private GeneratedPQuery() {
+      super(PVisibility.PRIVATE);
+    }
+    
+    @Override
+    public String getFullyQualifiedName() {
+      return "hu.bme.mit.inf.dslreasoner.domains.cps.queries.unallocatedAppInstance";
+    }
+    
+    @Override
+    public List<String> getParameterNames() {
+      return Arrays.asList("App");
+    }
+    
+    @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_App = body.getOrCreateVariableByName("App");
+          PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+          new TypeConstraint(body, Tuples.flatTupleOf(var_App), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/cps", "ApplicationInstance")));
+          body.setSymbolicParameters(Arrays.<ExportedParameter>asList(
+             new ExportedParameter(body, var_App, parameter_App)
+          ));
+          //    neg ApplicationInstance.allocatedTo(App, _)
+          new NegativePatternCall(body, Tuples.flatTupleOf(var_App, var___0_), new UnallocatedAppInstance.GeneratedPQuery.Embedded_1_ApplicationInstance_allocatedTo());
+          bodies.add(body);
+      }
+      return bodies;
+    }
+  }
+}