VIATRA DSE and COIN-OR CBC implementations of CPS case study

7 files changed, 458 insertions, 0 deletions

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);
+    }
+  }
+}