14 files changed, 1196 insertions, 0 deletions

diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CbcCpsMain.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CbcCpsMain.xtendbin
new file mode 100644
index 00000000..3f9e895d
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CbcCpsMain.xtendbin
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CpsToLpTranslator.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CpsToLpTranslator.xtendbin
new file mode 100644
index 00000000..d8814a3b
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.CpsToLpTranslator.xtendbin
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.gitignore b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.gitignore
new file mode 100644
index 00000000..9f908c7a
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/.gitignore
@@ -0,0 +1,2 @@
+/.CpsToLpTranslator.java._trace
+/.CbcCpsMain.java._trace
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CbcCpsMain.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CbcCpsMain.java
new file mode 100644
index 00000000..d36cdccd
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CbcCpsMain.java
@@ -0,0 +1,77 @@
+package hu.bme.mit.inf.dslreasoner.domains.cps.cplex;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.CpsPackage;
+import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem;
+import hu.bme.mit.inf.dslreasoner.domains.cps.cplex.CpsToLpTranslator;
+import hu.bme.mit.inf.dslreasoner.domains.cps.generator.CpsGenerator;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
+import org.eclipse.xtext.xbase.lib.Exceptions;
+import org.eclipse.xtext.xbase.lib.InputOutput;
+
+@SuppressWarnings("all")
+public class CbcCpsMain {
+  private static final String PROBLEM_FILE = "problem.lp";
+  
+  private static final String SOLUTION_FILE = "solution.txt";
+  
+  private CbcCpsMain() {
+    new IllegalStateException("This is a static utility class and should not be instantiated directly.");
+  }
+  
+  public static void main(final String[] args) {
+    try {
+      Map<String, Object> _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
+      XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl();
+      _extensionToFactoryMap.put(Resource.Factory.Registry.DEFAULT_EXTENSION, _xMIResourceFactoryImpl);
+      EPackage.Registry.INSTANCE.put(CpsPackage.eNS_URI, CpsPackage.eINSTANCE);
+      final CpsGenerator generator = new CpsGenerator(1, 4, 1);
+      final CyberPhysicalSystem problem = generator.generateCpsProblem();
+      final CpsToLpTranslator toLp = new CpsToLpTranslator(problem, 10, true);
+      final CharSequence lp = toLp.getLpProblem();
+      FileWriter _fileWriter = new FileWriter(CbcCpsMain.PROBLEM_FILE);
+      final BufferedWriter writer = new BufferedWriter(_fileWriter);
+      try {
+        writer.append(lp);
+      } finally {
+        writer.close();
+      }
+      final Process process = new ProcessBuilder().inheritIO().command("cbc", CbcCpsMain.PROBLEM_FILE, "solve", "solu", CbcCpsMain.SOLUTION_FILE).start();
+      boolean _waitFor = process.waitFor(120, TimeUnit.SECONDS);
+      boolean _not = (!_waitFor);
+      if (_not) {
+        System.err.println("Timeout reached");
+        process.destroyForcibly();
+        System.exit((-1));
+      }
+      int _exitValue = process.exitValue();
+      boolean _notEquals = (_exitValue != 0);
+      if (_notEquals) {
+        int _exitValue_1 = process.exitValue();
+        String _plus = ("Unexpected exit value " + Integer.valueOf(_exitValue_1));
+        System.err.println(_plus);
+        System.exit((-1));
+      }
+      FileReader _fileReader = new FileReader(CbcCpsMain.SOLUTION_FILE);
+      final BufferedReader reader = new BufferedReader(_fileReader);
+      try {
+        final Consumer<String> _function = (String it) -> {
+          InputOutput.<String>println(it);
+        };
+        reader.lines().forEach(_function);
+      } finally {
+        reader.close();
+      }
+    } catch (Throwable _e) {
+      throw Exceptions.sneakyThrow(_e);
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CpsToLpTranslator.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CpsToLpTranslator.java
new file mode 100644
index 00000000..20afeee6
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/cplex/CpsToLpTranslator.java
@@ -0,0 +1,505 @@
+package hu.bme.mit.inf.dslreasoner.domains.cps.cplex;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationType;
+import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem;
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostType;
+import hu.bme.mit.inf.dslreasoner.domains.cps.Request;
+import hu.bme.mit.inf.dslreasoner.domains.cps.Requirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.ExclusiveRange;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.eclipse.xtext.xbase.lib.ListExtensions;
+import org.eclipse.xtext.xbase.lib.Pair;
+
+@SuppressWarnings("all")
+public class CpsToLpTranslator {
+  private static final double MINIMUM_MEMORY_USAGE = 0.25;
+  
+  private static final double MINIMUM_HDD_USAGE = 0.25;
+  
+  private final CyberPhysicalSystem cps;
+  
+  private final Map<Requirement, ? extends List<String>> appInstances;
+  
+  private final Map<HostType, ? extends List<String>> hostInstances;
+  
+  private final boolean breakSymmetry;
+  
+  public CpsToLpTranslator(final CyberPhysicalSystem cps, final int hostInstanceCount, final boolean breakSymmetry) {
+    this.cps = cps;
+    this.appInstances = this.createAppInstances();
+    this.hostInstances = this.createHostInstances(hostInstanceCount);
+    this.breakSymmetry = breakSymmetry;
+  }
+  
+  private ImmutableMap<Requirement, ImmutableList<String>> createAppInstances() {
+    ImmutableMap<Requirement, ImmutableList<String>> _xblockexpression = null;
+    {
+      final ImmutableMap.Builder<Requirement, ImmutableList<String>> builder = ImmutableMap.<Requirement, ImmutableList<String>>builder();
+      int i = 0;
+      Iterable<Requirement> _requirements = this.getRequirements();
+      for (final Requirement req : _requirements) {
+        {
+          final ImmutableList.Builder<String> listBuilder = ImmutableList.<String>builder();
+          for (int j = 0; (j < req.getCount()); j++) {
+            StringConcatenation _builder = new StringConcatenation();
+            _builder.append("r");
+            _builder.append(i);
+            _builder.append("a");
+            _builder.append(j);
+            listBuilder.add(_builder.toString());
+          }
+          builder.put(req, listBuilder.build());
+          i++;
+        }
+      }
+      _xblockexpression = builder.build();
+    }
+    return _xblockexpression;
+  }
+  
+  private ImmutableMap<HostType, ImmutableList<String>> createHostInstances(final int hostInstanceCount) {
+    ImmutableMap<HostType, ImmutableList<String>> _xblockexpression = null;
+    {
+      final ImmutableMap.Builder<HostType, ImmutableList<String>> builder = ImmutableMap.<HostType, ImmutableList<String>>builder();
+      int i = 0;
+      EList<HostType> _hostTypes = this.cps.getHostTypes();
+      for (final HostType hostType : _hostTypes) {
+        {
+          final ImmutableList.Builder<String> listBuilder = ImmutableList.<String>builder();
+          for (int j = 0; (j < hostInstanceCount); j++) {
+            StringConcatenation _builder = new StringConcatenation();
+            _builder.append("h");
+            _builder.append(i);
+            _builder.append("i");
+            _builder.append(j);
+            listBuilder.add(_builder.toString());
+          }
+          builder.put(hostType, listBuilder.build());
+          i++;
+        }
+      }
+      _xblockexpression = builder.build();
+    }
+    return _xblockexpression;
+  }
+  
+  public CharSequence getLpProblem() {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("Minimize");
+    _builder.newLine();
+    _builder.append("\t");
+    _builder.append("total_cost: ");
+    CharSequence _objective = this.getObjective();
+    _builder.append(_objective, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("Subject To");
+    _builder.newLine();
+    _builder.append("\t");
+    CharSequence _constraints = this.getConstraints();
+    _builder.append(_constraints, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("Bounds");
+    _builder.newLine();
+    _builder.append("\t");
+    CharSequence _bounds = this.getBounds();
+    _builder.append(_bounds, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("Binary");
+    _builder.newLine();
+    _builder.append("\t");
+    CharSequence _binaryVariables = this.getBinaryVariables();
+    _builder.append(_binaryVariables, "\t");
+    _builder.newLineIfNotEmpty();
+    _builder.append("End");
+    _builder.newLine();
+    return _builder;
+  }
+  
+  private CharSequence getObjective() {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      Iterable<Pair<HostType, String>> _hostInstancesWithType = this.getHostInstancesWithType();
+      boolean _hasElements = false;
+      for(final Pair<HostType, String> pair : _hostInstancesWithType) {
+        if (!_hasElements) {
+          _hasElements = true;
+        } else {
+          _builder.appendImmediate(" + ", "");
+        }
+        int _cost = pair.getKey().getCost();
+        _builder.append(_cost);
+        _builder.append(" ");
+        CharSequence _existsVariable = this.getExistsVariable(pair.getValue());
+        _builder.append(_existsVariable);
+      }
+    }
+    return _builder;
+  }
+  
+  private CharSequence getConstraints() {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      Iterable<Pair<ApplicationType, String>> _appInstancesWithType = this.getAppInstancesWithType();
+      for(final Pair<ApplicationType, String> appPair : _appInstancesWithType) {
+        String _value = appPair.getValue();
+        _builder.append(_value);
+        _builder.append("_allocated: ");
+        {
+          Iterable<String> _possibleHostInstances = this.getPossibleHostInstances(appPair.getKey());
+          boolean _hasElements = false;
+          for(final String host : _possibleHostInstances) {
+            if (!_hasElements) {
+              _hasElements = true;
+            } else {
+              _builder.appendImmediate(" + ", "");
+            }
+            CharSequence _allocatedToVariable = this.getAllocatedToVariable(appPair.getValue(), host);
+            _builder.append(_allocatedToVariable);
+          }
+        }
+        _builder.append(" = 1");
+        _builder.newLineIfNotEmpty();
+        {
+          Iterable<String> _possibleHostInstances_1 = this.getPossibleHostInstances(appPair.getKey());
+          for(final String host_1 : _possibleHostInstances_1) {
+            String _value_1 = appPair.getValue();
+            _builder.append(_value_1);
+            _builder.append("_to_");
+            _builder.append(host_1);
+            _builder.append("_exists: ");
+            CharSequence _existsVariable = this.getExistsVariable(host_1);
+            _builder.append(_existsVariable);
+            _builder.append(" - ");
+            CharSequence _allocatedToVariable_1 = this.getAllocatedToVariable(appPair.getValue(), host_1);
+            _builder.append(_allocatedToVariable_1);
+            _builder.append(" >= 0");
+            _builder.newLineIfNotEmpty();
+          }
+        }
+      }
+    }
+    {
+      Iterable<Pair<HostType, String>> _hostInstancesWithType = this.getHostInstancesWithType();
+      for(final Pair<HostType, String> hostPair : _hostInstancesWithType) {
+        String _value_2 = hostPair.getValue();
+        _builder.append(_value_2);
+        _builder.append("_mem_use: ");
+        {
+          Iterable<Pair<ResourceRequirement, String>> _possibleAppInstancesWithRequirements = this.getPossibleAppInstancesWithRequirements(hostPair.getKey());
+          boolean _hasElements_1 = false;
+          for(final Pair<ResourceRequirement, String> appPair_1 : _possibleAppInstancesWithRequirements) {
+            if (!_hasElements_1) {
+              _hasElements_1 = true;
+            } else {
+              _builder.appendImmediate(" + ", "");
+            }
+            int _requiredMemory = appPair_1.getKey().getRequiredMemory();
+            _builder.append(_requiredMemory);
+            _builder.append(" ");
+            CharSequence _allocatedToVariable_2 = this.getAllocatedToVariable(appPair_1.getValue(), hostPair.getValue());
+            _builder.append(_allocatedToVariable_2);
+          }
+        }
+        _builder.append(" - ");
+        int _defaultMemory = hostPair.getKey().getDefaultMemory();
+        _builder.append(_defaultMemory);
+        _builder.append(" ");
+        CharSequence _memoryUsageVariable = this.getMemoryUsageVariable(hostPair.getValue());
+        _builder.append(_memoryUsageVariable);
+        _builder.append(" = 0");
+        _builder.newLineIfNotEmpty();
+        String _value_3 = hostPair.getValue();
+        _builder.append(_value_3);
+        _builder.append("_hdd_use: ");
+        {
+          Iterable<Pair<ResourceRequirement, String>> _possibleAppInstancesWithRequirements_1 = this.getPossibleAppInstancesWithRequirements(hostPair.getKey());
+          boolean _hasElements_2 = false;
+          for(final Pair<ResourceRequirement, String> appPair_2 : _possibleAppInstancesWithRequirements_1) {
+            if (!_hasElements_2) {
+              _hasElements_2 = true;
+            } else {
+              _builder.appendImmediate(" + ", "");
+            }
+            int _requiredHdd = appPair_2.getKey().getRequiredHdd();
+            _builder.append(_requiredHdd);
+            _builder.append(" ");
+            CharSequence _allocatedToVariable_3 = this.getAllocatedToVariable(appPair_2.getValue(), hostPair.getValue());
+            _builder.append(_allocatedToVariable_3);
+          }
+        }
+        _builder.append(" - ");
+        int _defaultHdd = hostPair.getKey().getDefaultHdd();
+        _builder.append(_defaultHdd);
+        _builder.append(" ");
+        CharSequence _hddUsageVariable = this.getHddUsageVariable(hostPair.getValue());
+        _builder.append(_hddUsageVariable);
+        _builder.append(" = 0");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    _builder.append("average_mem: ");
+    {
+      Iterable<String> _allHostInstances = this.getAllHostInstances();
+      boolean _hasElements_3 = false;
+      for(final String host_2 : _allHostInstances) {
+        if (!_hasElements_3) {
+          _hasElements_3 = true;
+        } else {
+          _builder.appendImmediate(" + ", "");
+        }
+        CharSequence _memoryUsageVariable_1 = this.getMemoryUsageVariable(host_2);
+        _builder.append(_memoryUsageVariable_1);
+        _builder.append(" - ");
+        _builder.append(CpsToLpTranslator.MINIMUM_MEMORY_USAGE);
+        _builder.append(" ");
+        CharSequence _existsVariable_1 = this.getExistsVariable(host_2);
+        _builder.append(_existsVariable_1);
+      }
+    }
+    _builder.append(" >= 0");
+    _builder.newLineIfNotEmpty();
+    _builder.append("average_hdd: ");
+    {
+      Iterable<String> _allHostInstances_1 = this.getAllHostInstances();
+      boolean _hasElements_4 = false;
+      for(final String host_3 : _allHostInstances_1) {
+        if (!_hasElements_4) {
+          _hasElements_4 = true;
+        } else {
+          _builder.appendImmediate(" + ", "");
+        }
+        CharSequence _memoryUsageVariable_2 = this.getMemoryUsageVariable(host_3);
+        _builder.append(_memoryUsageVariable_2);
+        _builder.append(" - ");
+        _builder.append(CpsToLpTranslator.MINIMUM_HDD_USAGE);
+        _builder.append(" ");
+        CharSequence _existsVariable_2 = this.getExistsVariable(host_3);
+        _builder.append(_existsVariable_2);
+      }
+    }
+    _builder.append(" >= 0");
+    _builder.newLineIfNotEmpty();
+    {
+      final Function1<Requirement, Boolean> _function = (Requirement it) -> {
+        int _count = it.getCount();
+        return Boolean.valueOf((_count > 1));
+      };
+      Iterable<Pair<Integer, Requirement>> _indexed = IterableExtensions.<Requirement>indexed(IterableExtensions.<Requirement>filter(this.getRequirements(), _function));
+      for(final Pair<Integer, Requirement> reqPair : _indexed) {
+        {
+          final Function1<ResourceRequirement, List<String>> _function_1 = (ResourceRequirement it) -> {
+            return this.hostInstances.get(it.getHostType());
+          };
+          Iterable<String> _flatMap = IterableExtensions.<ResourceRequirement, String>flatMap(reqPair.getValue().getType().getRequirements(), _function_1);
+          for(final String host_4 : _flatMap) {
+            _builder.append("r");
+            Integer _key = reqPair.getKey();
+            _builder.append(_key);
+            _builder.append("_");
+            _builder.append(host_4);
+            _builder.append("_redundant: ");
+            {
+              List<String> _get = this.appInstances.get(reqPair.getValue());
+              boolean _hasElements_5 = false;
+              for(final String app : _get) {
+                if (!_hasElements_5) {
+                  _hasElements_5 = true;
+                } else {
+                  _builder.appendImmediate(" + ", "");
+                }
+                CharSequence _allocatedToVariable_4 = this.getAllocatedToVariable(app, host_4);
+                _builder.append(_allocatedToVariable_4);
+              }
+            }
+            _builder.append(" <= 1");
+            _builder.newLineIfNotEmpty();
+          }
+        }
+      }
+    }
+    {
+      if (this.breakSymmetry) {
+        {
+          Collection<? extends List<String>> _values = this.hostInstances.values();
+          for(final List<String> hosts : _values) {
+            {
+              int _size = hosts.size();
+              int _minus = (_size - 1);
+              ExclusiveRange _doubleDotLessThan = new ExclusiveRange(0, _minus, true);
+              for(final Integer i : _doubleDotLessThan) {
+                String _get_1 = hosts.get(((i).intValue() + 1));
+                _builder.append(_get_1);
+                _builder.append("_after_");
+                String _get_2 = hosts.get((i).intValue());
+                _builder.append(_get_2);
+                _builder.append(": ");
+                CharSequence _existsVariable_3 = this.getExistsVariable(hosts.get((i).intValue()));
+                _builder.append(_existsVariable_3);
+                _builder.append(" - ");
+                CharSequence _existsVariable_4 = this.getExistsVariable(hosts.get(((i).intValue() + 1)));
+                _builder.append(_existsVariable_4);
+                _builder.append(" >= 0");
+                _builder.newLineIfNotEmpty();
+              }
+            }
+          }
+        }
+      }
+    }
+    return _builder;
+  }
+  
+  private CharSequence getBounds() {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      Iterable<String> _allHostInstances = this.getAllHostInstances();
+      for(final String host : _allHostInstances) {
+        _builder.append("0 <= ");
+        CharSequence _memoryUsageVariable = this.getMemoryUsageVariable(host);
+        _builder.append(_memoryUsageVariable);
+        _builder.append(" <= 1");
+        _builder.newLineIfNotEmpty();
+        _builder.append("0 <= ");
+        CharSequence _hddUsageVariable = this.getHddUsageVariable(host);
+        _builder.append(_hddUsageVariable);
+        _builder.append(" <= 1");
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    return _builder;
+  }
+  
+  private CharSequence getBinaryVariables() {
+    StringConcatenation _builder = new StringConcatenation();
+    {
+      Iterable<String> _allHostInstances = this.getAllHostInstances();
+      for(final String host : _allHostInstances) {
+        CharSequence _existsVariable = this.getExistsVariable(host);
+        _builder.append(_existsVariable);
+        _builder.newLineIfNotEmpty();
+      }
+    }
+    {
+      Iterable<Pair<ApplicationType, String>> _appInstancesWithType = this.getAppInstancesWithType();
+      for(final Pair<ApplicationType, String> appPair : _appInstancesWithType) {
+        {
+          Iterable<String> _possibleHostInstances = this.getPossibleHostInstances(appPair.getKey());
+          for(final String host_1 : _possibleHostInstances) {
+            CharSequence _allocatedToVariable = this.getAllocatedToVariable(appPair.getValue(), host_1);
+            _builder.append(_allocatedToVariable);
+            _builder.newLineIfNotEmpty();
+          }
+        }
+      }
+    }
+    return _builder;
+  }
+  
+  private Iterable<Requirement> getRequirements() {
+    final Function1<Request, EList<Requirement>> _function = (Request it) -> {
+      return it.getRequirements();
+    };
+    return IterableExtensions.<Request, Requirement>flatMap(this.cps.getRequests(), _function);
+  }
+  
+  private Iterable<String> getAllHostInstances() {
+    final Function1<List<String>, List<String>> _function = (List<String> it) -> {
+      return it;
+    };
+    return IterableExtensions.flatMap(this.hostInstances.values(), _function);
+  }
+  
+  private Iterable<Pair<HostType, String>> getHostInstancesWithType() {
+    final Function1<Map.Entry<HostType, ? extends List<String>>, List<Pair<HostType, String>>> _function = (Map.Entry<HostType, ? extends List<String>> pair) -> {
+      final Function1<String, Pair<HostType, String>> _function_1 = (String it) -> {
+        HostType _key = pair.getKey();
+        return Pair.<HostType, String>of(_key, it);
+      };
+      return ListExtensions.<String, Pair<HostType, String>>map(pair.getValue(), _function_1);
+    };
+    return IterableExtensions.flatMap(this.hostInstances.entrySet(), _function);
+  }
+  
+  private Iterable<Pair<ApplicationType, String>> getAppInstancesWithType() {
+    final Function1<Map.Entry<Requirement, ? extends List<String>>, List<Pair<ApplicationType, String>>> _function = (Map.Entry<Requirement, ? extends List<String>> pair) -> {
+      final Function1<String, Pair<ApplicationType, String>> _function_1 = (String it) -> {
+        ApplicationType _type = pair.getKey().getType();
+        return Pair.<ApplicationType, String>of(_type, it);
+      };
+      return ListExtensions.<String, Pair<ApplicationType, String>>map(pair.getValue(), _function_1);
+    };
+    return IterableExtensions.flatMap(this.appInstances.entrySet(), _function);
+  }
+  
+  private Iterable<String> getPossibleHostInstances(final ApplicationType appType) {
+    final Function1<ResourceRequirement, List<String>> _function = (ResourceRequirement req) -> {
+      return this.hostInstances.get(req.getHostType());
+    };
+    return IterableExtensions.<ResourceRequirement, String>flatMap(appType.getRequirements(), _function);
+  }
+  
+  private Iterable<Pair<ResourceRequirement, String>> getPossibleAppInstancesWithRequirements(final HostType hostType) {
+    final Function1<Map.Entry<Requirement, ? extends List<String>>, List<Pair<ResourceRequirement, String>>> _function = (Map.Entry<Requirement, ? extends List<String>> pair) -> {
+      List<Pair<ResourceRequirement, String>> _xblockexpression = null;
+      {
+        final Function1<ResourceRequirement, Boolean> _function_1 = (ResourceRequirement it) -> {
+          HostType _hostType = it.getHostType();
+          return Boolean.valueOf(Objects.equal(_hostType, hostType));
+        };
+        final ResourceRequirement resourceReq = IterableExtensions.<ResourceRequirement>findFirst(pair.getKey().getType().getRequirements(), _function_1);
+        List<Pair<ResourceRequirement, String>> _xifexpression = null;
+        if ((resourceReq == null)) {
+          _xifexpression = CollectionLiterals.<Pair<ResourceRequirement, String>>emptyList();
+        } else {
+          final Function1<String, Pair<ResourceRequirement, String>> _function_2 = (String it) -> {
+            return Pair.<ResourceRequirement, String>of(resourceReq, it);
+          };
+          _xifexpression = ListExtensions.<String, Pair<ResourceRequirement, String>>map(pair.getValue(), _function_2);
+        }
+        _xblockexpression = _xifexpression;
+      }
+      return _xblockexpression;
+    };
+    return IterableExtensions.flatMap(this.appInstances.entrySet(), _function);
+  }
+  
+  private CharSequence getExistsVariable(final String hostInstance) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append(hostInstance);
+    _builder.append("_exists");
+    return _builder;
+  }
+  
+  private CharSequence getMemoryUsageVariable(final String hostInstance) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append(hostInstance);
+    _builder.append("_mem");
+    return _builder;
+  }
+  
+  private CharSequence getHddUsageVariable(final String hostInstance) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append(hostInstance);
+    _builder.append("_hdd");
+    return _builder;
+  }
+  
+  private CharSequence getAllocatedToVariable(final String appInstance, final String hostInstance) {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append(appInstance);
+    _builder.append("_to_");
+    _builder.append(hostInstance);
+    return _builder;
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.CpsStateCoder.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.CpsStateCoder.xtendbin
new file mode 100644
index 00000000..cdfe3921
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.CpsStateCoder.xtendbin
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsMain.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsMain.xtendbin
new file mode 100644
index 00000000..9be64b30
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsMain.xtendbin
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsSolver.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsSolver.xtendbin
new file mode 100644
index 00000000..02fb74ef
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.RuleBasedCpsSolver.xtendbin
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.gitignore b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.gitignore
new file mode 100644
index 00000000..e24f10f4
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/.gitignore
@@ -0,0 +1,3 @@
+/.RuleBasedCpsSolver.java._trace
+/.RuleBasedCpsMain.java._trace
+/.CpsStateCoder.java._trace
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/CpsStateCoder.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/CpsStateCoder.java
new file mode 100644
index 00000000..3ae8e828
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/CpsStateCoder.java
@@ -0,0 +1,316 @@
+package hu.bme.mit.inf.dslreasoner.domains.cps.dse;
+
+import com.google.common.base.Objects;
+import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem;
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostType;
+import hu.bme.mit.inf.dslreasoner.domains.cps.Request;
+import hu.bme.mit.inf.dslreasoner.domains.cps.Requirement;
+import java.util.Arrays;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.viatra.dse.statecode.IStateCoder;
+import org.eclipse.viatra.dse.statecode.IStateCoderFactory;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtend2.lib.StringConcatenationClient;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+
+@SuppressWarnings("all")
+public class CpsStateCoder implements IStateCoder {
+  public static class Factory implements IStateCoderFactory {
+    @Override
+    public IStateCoder createStateCoder() {
+      return new CpsStateCoder();
+    }
+  }
+  
+  private CyberPhysicalSystem cps;
+  
+  protected CpsStateCoder() {
+  }
+  
+  @Override
+  public void init(final Notifier notifier) {
+    CyberPhysicalSystem _switchResult = null;
+    boolean _matched = false;
+    if (notifier instanceof ResourceSet) {
+      _matched=true;
+      _switchResult = this.getCpsFromResourceSet(((ResourceSet)notifier));
+    }
+    if (!_matched) {
+      if (notifier instanceof Resource) {
+        _matched=true;
+        _switchResult = this.getCpsFromResource(((Resource)notifier));
+      }
+    }
+    if (!_matched) {
+      if (notifier instanceof CyberPhysicalSystem) {
+        _matched=true;
+        _switchResult = ((CyberPhysicalSystem)notifier);
+      }
+    }
+    if (!_matched) {
+      throw new IllegalArgumentException("notifier is not a CyberPhysicalSystem");
+    }
+    this.cps = _switchResult;
+  }
+  
+  private CyberPhysicalSystem getCpsFromResourceSet(final ResourceSet resourceSet) {
+    CyberPhysicalSystem _xblockexpression = null;
+    {
+      boolean _isEmpty = resourceSet.getResources().isEmpty();
+      if (_isEmpty) {
+        throw new IllegalArgumentException("No Resource in ResourceSet");
+      }
+      final Resource resource = IterableExtensions.<Resource>head(resourceSet.getResources());
+      _xblockexpression = this.getCpsFromResource(resource);
+    }
+    return _xblockexpression;
+  }
+  
+  private CyberPhysicalSystem getCpsFromResource(final Resource resource) {
+    CyberPhysicalSystem _xblockexpression = null;
+    {
+      boolean _isEmpty = resource.getContents().isEmpty();
+      if (_isEmpty) {
+        throw new IllegalArgumentException("No EObject in Resource");
+      }
+      final EObject cps = IterableExtensions.<EObject>head(resource.getContents());
+      CyberPhysicalSystem _xifexpression = null;
+      if ((cps instanceof CyberPhysicalSystem)) {
+        _xifexpression = ((CyberPhysicalSystem)cps);
+      } else {
+        throw new IllegalArgumentException("EObject in Resource is not a CyberPhysicalSystem");
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  @Override
+  public String createStateCode() {
+    StringConcatenation _builder = new StringConcatenation();
+    StringConcatenationClient _createRequestsCode = this.createRequestsCode();
+    _builder.append(_createRequestsCode);
+    CharSequence _createHostTypesCode = this.createHostTypesCode();
+    _builder.append(_createHostTypesCode);
+    return _builder.toString();
+  }
+  
+  private StringConcatenationClient createRequestsCode() {
+    StringConcatenationClient _client = new StringConcatenationClient() {
+      @Override
+      protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) {
+        {
+          EList<Request> _requests = CpsStateCoder.this.cps.getRequests();
+          for(final Request request : _requests) {
+            StringConcatenationClient _createRequestCode = CpsStateCoder.this.createRequestCode(request);
+            _builder.append(_createRequestCode);
+          }
+        }
+      }
+    };
+    return _client;
+  }
+  
+  private StringConcatenationClient createRequestCode(final Request request) {
+    StringConcatenationClient _client = new StringConcatenationClient() {
+      @Override
+      protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) {
+        _builder.append("[");
+        {
+          EList<Requirement> _requirements = request.getRequirements();
+          for(final Requirement requirement : _requirements) {
+            StringConcatenationClient _createRequirementCode = CpsStateCoder.this.createRequirementCode(requirement);
+            _builder.append(_createRequirementCode);
+          }
+        }
+        _builder.append("]");
+      }
+    };
+    return _client;
+  }
+  
+  private StringConcatenationClient createRequirementCode(final Requirement requirement) {
+    StringConcatenationClient _client = new StringConcatenationClient() {
+      @Override
+      protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) {
+        _builder.append("[");
+        {
+          EList<ApplicationInstance> _instances = requirement.getInstances();
+          boolean _hasElements = false;
+          for(final ApplicationInstance app : _instances) {
+            if (!_hasElements) {
+              _hasElements = true;
+            } else {
+              _builder.appendImmediate(",", "");
+            }
+            String _createAppCode = CpsStateCoder.this.createAppCode(app);
+            _builder.append(_createAppCode);
+          }
+        }
+        _builder.append("]");
+      }
+    };
+    return _client;
+  }
+  
+  private String createAppCode(final ApplicationInstance app) {
+    String _xifexpression = null;
+    HostInstance _allocatedTo = app.getAllocatedTo();
+    boolean _tripleEquals = (_allocatedTo == null);
+    if (_tripleEquals) {
+      _xifexpression = "-";
+    } else {
+      _xifexpression = this.createMatchArgumentCode(app.getAllocatedTo());
+    }
+    return _xifexpression;
+  }
+  
+  private CharSequence createHostTypesCode() {
+    StringConcatenation _builder = new StringConcatenation();
+    _builder.append("(");
+    {
+      EList<HostType> _hostTypes = this.cps.getHostTypes();
+      boolean _hasElements = false;
+      for(final HostType hostType : _hostTypes) {
+        if (!_hasElements) {
+          _hasElements = true;
+        } else {
+          _builder.appendImmediate(",", "");
+        }
+        int _size = hostType.getInstances().size();
+        _builder.append(_size);
+      }
+    }
+    _builder.append(")");
+    return _builder;
+  }
+  
+  @Override
+  public String createActivationCode(final IPatternMatch match) {
+    StringConcatenation _builder = new StringConcatenation();
+    String _simpleName = match.specification().getSimpleName();
+    _builder.append(_simpleName);
+    _builder.append("(");
+    {
+      Object[] _array = match.toArray();
+      boolean _hasElements = false;
+      for(final Object arg : _array) {
+        if (!_hasElements) {
+          _hasElements = true;
+        } else {
+          _builder.appendImmediate(",", "");
+        }
+        String _createMatchArgumentCode = this.createMatchArgumentCode(arg);
+        _builder.append(_createMatchArgumentCode);
+      }
+    }
+    _builder.append(")");
+    return _builder.toString();
+  }
+  
+  protected String _createMatchArgumentCode(final Requirement requirement) {
+    String _xblockexpression = null;
+    {
+      final EObject request = requirement.eContainer();
+      String _xifexpression = null;
+      if ((request instanceof Request)) {
+        String _xblockexpression_1 = null;
+        {
+          EObject _eContainer = ((Request)request).eContainer();
+          boolean _notEquals = (!Objects.equal(_eContainer, this.cps));
+          if (_notEquals) {
+            throw new IllegalArgumentException("Request is not contained in the CPS");
+          }
+          final int requestIndex = this.cps.getRequests().indexOf(request);
+          final int requirementIndex = ((Request)request).getRequirements().indexOf(requirement);
+          String _plus = (Integer.valueOf(requestIndex) + ".");
+          _xblockexpression_1 = (_plus + Integer.valueOf(requirementIndex));
+        }
+        _xifexpression = _xblockexpression_1;
+      } else {
+        throw new IllegalArgumentException("Requirement is not contained in a request");
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  protected String _createMatchArgumentCode(final ApplicationInstance app) {
+    String _xblockexpression = null;
+    {
+      final Requirement requirement = app.getRequirement();
+      if ((requirement == null)) {
+        throw new IllegalArgumentException("Application instance is not associated with a requirement");
+      }
+      final int instanceIndex = requirement.getInstances().indexOf(app);
+      String _createMatchArgumentCode = this.createMatchArgumentCode(requirement);
+      String _plus = (_createMatchArgumentCode + ".");
+      _xblockexpression = (_plus + Integer.valueOf(instanceIndex));
+    }
+    return _xblockexpression;
+  }
+  
+  protected String _createMatchArgumentCode(final HostInstance host) {
+    String _xblockexpression = null;
+    {
+      final EObject hostType = host.eContainer();
+      String _xifexpression = null;
+      if ((hostType instanceof HostType)) {
+        String _xblockexpression_1 = null;
+        {
+          final int hostIndex = ((HostType)hostType).getInstances().indexOf(host);
+          String _createMatchArgumentCode = this.createMatchArgumentCode(hostType);
+          String _plus = (_createMatchArgumentCode + ".");
+          _xblockexpression_1 = (_plus + Integer.valueOf(hostIndex));
+        }
+        _xifexpression = _xblockexpression_1;
+      } else {
+        throw new IllegalArgumentException("Host is not contained in a host type");
+      }
+      _xblockexpression = _xifexpression;
+    }
+    return _xblockexpression;
+  }
+  
+  protected String _createMatchArgumentCode(final HostType hostType) {
+    String _xblockexpression = null;
+    {
+      EObject _eContainer = hostType.eContainer();
+      boolean _notEquals = (!Objects.equal(_eContainer, this.cps));
+      if (_notEquals) {
+        throw new IllegalArgumentException("Host type is not contained in the CPS");
+      }
+      final int hostTypeIndex = this.cps.getHostTypes().indexOf(hostType);
+      _xblockexpression = Integer.valueOf(hostTypeIndex).toString();
+    }
+    return _xblockexpression;
+  }
+  
+  protected String _createMatchArgumentCode(final Object object) {
+    throw new IllegalArgumentException("Unknown match argument: ");
+  }
+  
+  protected String createMatchArgumentCode(final Object app) {
+    if (app instanceof ApplicationInstance) {
+      return _createMatchArgumentCode((ApplicationInstance)app);
+    } else if (app instanceof HostInstance) {
+      return _createMatchArgumentCode((HostInstance)app);
+    } else if (app instanceof HostType) {
+      return _createMatchArgumentCode((HostType)app);
+    } else if (app instanceof Requirement) {
+      return _createMatchArgumentCode((Requirement)app);
+    } else if (app != null) {
+      return _createMatchArgumentCode(app);
+    } else {
+      throw new IllegalArgumentException("Unhandled parameter types: " +
+        Arrays.<Object>asList(app).toString());
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsMain.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsMain.java
new file mode 100644
index 00000000..7d81f84b
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsMain.java
@@ -0,0 +1,46 @@
+package hu.bme.mit.inf.dslreasoner.domains.cps.dse;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.CpsPackage;
+import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem;
+import hu.bme.mit.inf.dslreasoner.domains.cps.dse.RuleBasedCpsSolver;
+import hu.bme.mit.inf.dslreasoner.domains.cps.generator.CpsGenerator;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.CpsQueries;
+import java.util.Map;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
+import org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory;
+import org.eclipse.viatra.addon.querybasedfeatures.runtime.handler.QueryBasedFeatures;
+import org.eclipse.viatra.dse.api.DesignSpaceExplorer;
+import org.eclipse.viatra.query.runtime.extensibility.SingletonQueryGroupProvider;
+import org.eclipse.viatra.query.runtime.registry.IQuerySpecificationRegistry;
+import org.eclipse.viatra.query.runtime.registry.QuerySpecificationRegistry;
+import org.eclipse.viatra.query.runtime.registry.connector.QueryGroupProviderSourceConnector;
+
+@SuppressWarnings("all")
+public class RuleBasedCpsMain {
+  private RuleBasedCpsMain() {
+    new IllegalStateException("This is a static utility class and should not be instantiated directly.");
+  }
+  
+  public static void main(final String[] args) {
+    DesignSpaceExplorer.turnOnLogging(DesignSpaceExplorer.DseLoggingLevel.VERBOSE_FULL);
+    Map<String, Object> _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
+    XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl();
+    _extensionToFactoryMap.put(Resource.Factory.Registry.DEFAULT_EXTENSION, _xMIResourceFactoryImpl);
+    QueryBasedFeatureSettingDelegateFactory _queryBasedFeatureSettingDelegateFactory = new QueryBasedFeatureSettingDelegateFactory();
+    EStructuralFeature.Internal.SettingDelegate.Factory.Registry.INSTANCE.put(QueryBasedFeatures.ANNOTATION_SOURCE, _queryBasedFeatureSettingDelegateFactory);
+    EPackage.Registry.INSTANCE.put(CpsPackage.eNS_URI, CpsPackage.eINSTANCE);
+    IQuerySpecificationRegistry _instance = QuerySpecificationRegistry.getInstance();
+    CpsQueries _instance_1 = CpsQueries.instance();
+    SingletonQueryGroupProvider _singletonQueryGroupProvider = new SingletonQueryGroupProvider(_instance_1);
+    QueryGroupProviderSourceConnector _queryGroupProviderSourceConnector = new QueryGroupProviderSourceConnector("CpsQueries", _singletonQueryGroupProvider, 
+      true);
+    _instance.addSource(_queryGroupProviderSourceConnector);
+    final CpsGenerator generator = new CpsGenerator(1, 4, 1);
+    final CyberPhysicalSystem problem = generator.generateCpsProblem();
+    final RuleBasedCpsSolver solver = new RuleBasedCpsSolver();
+    solver.solve(problem);
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsSolver.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsSolver.java
new file mode 100644
index 00000000..fd348752
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/dse/RuleBasedCpsSolver.java
@@ -0,0 +1,93 @@
+package hu.bme.mit.inf.dslreasoner.domains.cps.dse;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.CpsFactory;
+import hu.bme.mit.inf.dslreasoner.domains.cps.CpsPackage;
+import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem;
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.dse.CpsStateCoder;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.Allocate;
+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.CreateHostInstance;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.GuidanceObjective;
+import hu.bme.mit.inf.dslreasoner.domains.cps.queries.RequirementNotSatisfied;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CompositeDirectionalThresholdObjective;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveKind;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveThreshold;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.QueryBasedObjective;
+import java.util.Collection;
+import java.util.function.Consumer;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.viatra.dse.api.DesignSpaceExplorer;
+import org.eclipse.viatra.dse.api.Solution;
+import org.eclipse.viatra.dse.evolutionary.EvolutionaryStrategy;
+import org.eclipse.viatra.dse.evolutionary.EvolutionaryStrategyBuilder;
+import org.eclipse.viatra.dse.objectives.Fitness;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRuleFactory;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.InputOutput;
+
+@SuppressWarnings("all")
+public class RuleBasedCpsSolver {
+  @Extension
+  private final BatchTransformationRuleFactory _batchTransformationRuleFactory = new BatchTransformationRuleFactory();
+  
+  @Extension
+  private final CpsFactory _cpsFactory = CpsFactory.eINSTANCE;
+  
+  public void solve(final CyberPhysicalSystem problem) {
+    final DesignSpaceExplorer dse = new DesignSpaceExplorer();
+    dse.addMetaModelPackage(CpsPackage.eINSTANCE);
+    dse.setInitialModel(problem.eResource().getResourceSet());
+    final Consumer<RequirementNotSatisfied.Match> _function = (RequirementNotSatisfied.Match it) -> {
+      final ApplicationInstance app = this._cpsFactory.createApplicationInstance();
+      EList<ApplicationInstance> _instances = it.getReq().getType().getInstances();
+      _instances.add(app);
+      EList<ApplicationInstance> _instances_1 = it.getReq().getInstances();
+      _instances_1.add(app);
+    };
+    dse.addTransformationRule(this._batchTransformationRuleFactory.<RequirementNotSatisfied.Match, RequirementNotSatisfied.Matcher>createRule(RequirementNotSatisfied.instance()).action(_function).build());
+    final Consumer<Allocate.Match> _function_1 = (Allocate.Match it) -> {
+      ApplicationInstance _app = it.getApp();
+      _app.setAllocatedTo(it.getHost());
+    };
+    dse.addTransformationRule(this._batchTransformationRuleFactory.<Allocate.Match, Allocate.Matcher>createRule(Allocate.instance()).action(_function_1).build());
+    final Consumer<CreateHostInstance.Match> _function_2 = (CreateHostInstance.Match it) -> {
+      EList<HostInstance> _instances = it.getHostType().getInstances();
+      HostInstance _createHostInstance = this._cpsFactory.createHostInstance();
+      _instances.add(_createHostInstance);
+    };
+    dse.addTransformationRule(this._batchTransformationRuleFactory.<CreateHostInstance.Match, CreateHostInstance.Matcher>createRule(CreateHostInstance.instance()).action(_function_2).build());
+    GuidanceObjective _instance = GuidanceObjective.instance();
+    ObjectiveThreshold.Inclusive _inclusive = new ObjectiveThreshold.Inclusive(0);
+    QueryBasedObjective _queryBasedObjective = new QueryBasedObjective(_instance, ObjectiveKind.LOWER_IS_BETTER, _inclusive, 0);
+    AverageFreeMemoryMetric _instance_1 = AverageFreeMemoryMetric.instance();
+    ObjectiveThreshold.Inclusive _inclusive_1 = new ObjectiveThreshold.Inclusive(0.75);
+    QueryBasedObjective _queryBasedObjective_1 = new QueryBasedObjective(_instance_1, ObjectiveKind.LOWER_IS_BETTER, _inclusive_1, 0);
+    AverageFreeHddMetric _instance_2 = AverageFreeHddMetric.instance();
+    ObjectiveThreshold.Inclusive _inclusive_2 = new ObjectiveThreshold.Inclusive(0.75);
+    QueryBasedObjective _queryBasedObjective_2 = new QueryBasedObjective(_instance_2, ObjectiveKind.LOWER_IS_BETTER, _inclusive_2, 0);
+    CompositeDirectionalThresholdObjective _compositeDirectionalThresholdObjective = new CompositeDirectionalThresholdObjective("Composite", _queryBasedObjective, _queryBasedObjective_1, _queryBasedObjective_2);
+    dse.addObjective(_compositeDirectionalThresholdObjective);
+    CostMetric _instance_3 = CostMetric.instance();
+    QueryBasedObjective _queryBasedObjective_3 = new QueryBasedObjective(_instance_3, ObjectiveKind.LOWER_IS_BETTER, 
+      ObjectiveThreshold.NO_THRESHOLD, 0);
+    dse.addObjective(_queryBasedObjective_3);
+    dse.setMaxNumberOfThreads(1);
+    CpsStateCoder.Factory _factory = new CpsStateCoder.Factory();
+    dse.setStateCoderFactory(_factory);
+    final EvolutionaryStrategy strategy = EvolutionaryStrategyBuilder.createNsga2Strategy(25);
+    dse.startExplorationWithTimeout(strategy, ((2 * 60) * 1000));
+    Collection<Solution> _solutions = dse.getSolutions();
+    for (final Solution solution : _solutions) {
+      Object _stateCode = solution.getStateCode();
+      String _plus = ("Found solution: " + _stateCode);
+      String _plus_1 = (_plus + " ");
+      Fitness _fitness = solution.getArbitraryTrajectory().getFitness();
+      String _plus_2 = (_plus_1 + _fitness);
+      InputOutput.<String>println(_plus_2);
+    }
+  }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/.CpsGenerator.xtendbin b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/.CpsGenerator.xtendbin
new file mode 100644
index 00000000..d975ffab
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/.CpsGenerator.xtendbin
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.java
new file mode 100644
index 00000000..e59ef004
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.cps/xtend-gen/hu/bme/mit/inf/dslreasoner/domains/cps/generator/CpsGenerator.java
@@ -0,0 +1,154 @@
+package hu.bme.mit.inf.dslreasoner.domains.cps.generator;
+
+import hu.bme.mit.inf.dslreasoner.domains.cps.ApplicationType;
+import hu.bme.mit.inf.dslreasoner.domains.cps.CpsFactory;
+import hu.bme.mit.inf.dslreasoner.domains.cps.CyberPhysicalSystem;
+import hu.bme.mit.inf.dslreasoner.domains.cps.HostType;
+import hu.bme.mit.inf.dslreasoner.domains.cps.Request;
+import hu.bme.mit.inf.dslreasoner.domains.cps.Requirement;
+import hu.bme.mit.inf.dslreasoner.domains.cps.ResourceRequirement;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Extension;
+import org.eclipse.xtext.xbase.lib.ObjectExtensions;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class CpsGenerator {
+  @Extension
+  private final CpsFactory _cpsFactory = CpsFactory.eINSTANCE;
+  
+  private static final int MIN_MEMORY = 1;
+  
+  private static final int MAX_MEMORY = 6;
+  
+  private static final int MIN_HDD = 1;
+  
+  private static final int MAX_HDD = 30;
+  
+  private static final int HIGH_CPU_FRACTION = 4;
+  
+  private static final int MIN_REPLICAS = 1;
+  
+  private static final int MAX_REPLICAS = 4;
+  
+  private final Random random;
+  
+  private final int applicationTypeCount;
+  
+  private final int demandFactor;
+  
+  public CpsGenerator(final long randomSeed, final int applicationTypeCount, final int demandFactor) {
+    Random _random = new Random(randomSeed);
+    this.random = _random;
+    this.applicationTypeCount = applicationTypeCount;
+    this.demandFactor = demandFactor;
+  }
+  
+  public CyberPhysicalSystem generateCpsProblem() {
+    CyberPhysicalSystem _xblockexpression = null;
+    {
+      final ResourceSetImpl resourceSet = new ResourceSetImpl();
+      final Resource resource = resourceSet.createResource(URI.createFileURI("dummy.dummyext"));
+      CyberPhysicalSystem _createCyberPhysicalSystem = this._cpsFactory.createCyberPhysicalSystem();
+      final Procedure1<CyberPhysicalSystem> _function = (CyberPhysicalSystem it) -> {
+        final CyberPhysicalSystem cps = it;
+        EList<EObject> _contents = resource.getContents();
+        _contents.add(cps);
+        this.createLowCpuHostTypes(it);
+        final List<HostType> highCpuHostTypes = this.createHighCpuHostTypes(it);
+        for (int i = 0; (i < this.applicationTypeCount); i++) {
+          if (((i % CpsGenerator.HIGH_CPU_FRACTION) == 0)) {
+            this.createRandomApplicationType(it, highCpuHostTypes);
+          } else {
+            this.createRandomApplicationType(it, it.getHostTypes());
+          }
+        }
+        for (int i = 0; (i < this.demandFactor); i++) {
+          EList<Request> _requests = it.getRequests();
+          Request _createRequest = this._cpsFactory.createRequest();
+          final Procedure1<Request> _function_1 = (Request it_1) -> {
+            EList<ApplicationType> _applicationTypes = cps.getApplicationTypes();
+            for (final ApplicationType appType : _applicationTypes) {
+              EList<Requirement> _requirements = it_1.getRequirements();
+              Requirement _createRequirement = this._cpsFactory.createRequirement();
+              final Procedure1<Requirement> _function_2 = (Requirement it_2) -> {
+                it_2.setCount(this.nextInt(CpsGenerator.MIN_REPLICAS, CpsGenerator.MAX_REPLICAS));
+                it_2.setType(appType);
+              };
+              Requirement _doubleArrow = ObjectExtensions.<Requirement>operator_doubleArrow(_createRequirement, _function_2);
+              _requirements.add(_doubleArrow);
+            }
+          };
+          Request _doubleArrow = ObjectExtensions.<Request>operator_doubleArrow(_createRequest, _function_1);
+          _requests.add(_doubleArrow);
+        }
+      };
+      _xblockexpression = ObjectExtensions.<CyberPhysicalSystem>operator_doubleArrow(_createCyberPhysicalSystem, _function);
+    }
+    return _xblockexpression;
+  }
+  
+  private void createRandomApplicationType(final CyberPhysicalSystem it, final Collection<HostType> allowedHostTypes) {
+    final ApplicationType appType = this._cpsFactory.createApplicationType();
+    final int memory = this.nextInt(CpsGenerator.MIN_MEMORY, CpsGenerator.MAX_MEMORY);
+    final int hdd = this.nextInt(CpsGenerator.MIN_HDD, CpsGenerator.MAX_HDD);
+    for (final HostType hostType : allowedHostTypes) {
+      EList<ResourceRequirement> _requirements = appType.getRequirements();
+      ResourceRequirement _createResourceRequirement = this._cpsFactory.createResourceRequirement();
+      final Procedure1<ResourceRequirement> _function = (ResourceRequirement it_1) -> {
+        it_1.setHostType(hostType);
+        it_1.setRequiredMemory(memory);
+        it_1.setRequiredHdd(hdd);
+      };
+      ResourceRequirement _doubleArrow = ObjectExtensions.<ResourceRequirement>operator_doubleArrow(_createResourceRequirement, _function);
+      _requirements.add(_doubleArrow);
+    }
+    EList<ApplicationType> _applicationTypes = it.getApplicationTypes();
+    _applicationTypes.add(appType);
+  }
+  
+  private List<HostType> createLowCpuHostTypes(final CyberPhysicalSystem it) {
+    HostType _createHostType = this.createHostType(it, 2, 8, 75);
+    HostType _createHostType_1 = this.createHostType(it, 4, 16, 150);
+    HostType _createHostType_2 = this.createHostType(it, 3, 16, 75);
+    HostType _createHostType_3 = this.createHostType(it, 6, 32, 150);
+    return Collections.<HostType>unmodifiableList(CollectionLiterals.<HostType>newArrayList(_createHostType, _createHostType_1, _createHostType_2, _createHostType_3));
+  }
+  
+  private List<HostType> createHighCpuHostTypes(final CyberPhysicalSystem it) {
+    HostType _createHostType = this.createHostType(it, 2, 4, 50);
+    HostType _createHostType_1 = this.createHostType(it, 4, 8, 100);
+    return Collections.<HostType>unmodifiableList(CollectionLiterals.<HostType>newArrayList(_createHostType, _createHostType_1));
+  }
+  
+  private HostType createHostType(final CyberPhysicalSystem it, final int cost, final int memory, final int hdd) {
+    HostType _xblockexpression = null;
+    {
+      HostType _createHostType = this._cpsFactory.createHostType();
+      final Procedure1<HostType> _function = (HostType it_1) -> {
+        it_1.setCost(cost);
+        it_1.setDefaultMemory(memory);
+        it_1.setDefaultHdd(hdd);
+      };
+      final HostType hostType = ObjectExtensions.<HostType>operator_doubleArrow(_createHostType, _function);
+      EList<HostType> _hostTypes = it.getHostTypes();
+      _hostTypes.add(hostType);
+      _xblockexpression = hostType;
+    }
+    return _xblockexpression;
+  }
+  
+  private int nextInt(final int lower, final int upper) {
+    int _nextInt = this.random.nextInt(((upper - lower) + 1));
+    return (lower + _nextInt);
+  }
+}