From c0a758eedd457a5d8eb9f1a6c17fc24143aabb3e Mon Sep 17 00:00:00 2001 From: ArenBabikian Date: Sun, 26 Apr 2020 18:23:13 -0400 Subject: Add PLEDGE case study files --- .../xtend-gen/run/.RunGenerator.xtendbin | Bin 0 -> 8707 bytes .../xtend-gen/run/.gitignore | 2 + .../xtend-gen/run/GenerateScenarios.java | 165 +++++++++++++++++++++ 3 files changed, 167 insertions(+) create mode 100644 Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/.RunGenerator.xtendbin create mode 100644 Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/.gitignore create mode 100644 Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/GenerateScenarios.java (limited to 'Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run') diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/.RunGenerator.xtendbin b/Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/.RunGenerator.xtendbin new file mode 100644 index 00000000..325fee79 Binary files /dev/null and b/Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/.RunGenerator.xtendbin differ diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/.gitignore b/Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/.gitignore new file mode 100644 index 00000000..bd13352d --- /dev/null +++ b/Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/.gitignore @@ -0,0 +1,2 @@ +/.GenerateScenarios.java._trace +/.checkQueries.java._trace diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/GenerateScenarios.java b/Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/GenerateScenarios.java new file mode 100644 index 00000000..7ec45124 --- /dev/null +++ b/Tests/MODELS2020-CaseStudies/case.study.pledge.queries/xtend-gen/run/GenerateScenarios.java @@ -0,0 +1,165 @@ +package run; + +import Taxation.TaxationPackage; +import com.google.common.base.Objects; +import com.google.common.collect.Iterables; +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic; +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration; +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace; +import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor; +import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type; +import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem; +import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicResult; +import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor; +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner; +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration; +import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace; +import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace; +import java.text.SimpleDateFormat; +import java.util.Collections; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EEnum; +import org.eclipse.emf.ecore.EEnumLiteral; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.EReference; +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.query.runtime.api.IQueryGroup; +import org.eclipse.viatra.query.runtime.api.IQuerySpecification; +import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation; +import org.eclipse.xtend2.lib.StringConcatenation; +import org.eclipse.xtext.xbase.lib.CollectionLiterals; +import org.eclipse.xtext.xbase.lib.Exceptions; +import org.eclipse.xtext.xbase.lib.Functions.Function1; +import org.eclipse.xtext.xbase.lib.InputOutput; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.eclipse.xtext.xbase.lib.ListExtensions; +import org.eclipse.xtext.xbase.lib.ObjectExtensions; +import org.eclipse.xtext.xbase.lib.Procedures.Procedure1; + +@SuppressWarnings("all") +public class GenerateScenarios { + public static void main(final String[] args) { + try { + final Ecore2Logic ecore2Logic = new Ecore2Logic(); + long _currentTimeMillis = System.currentTimeMillis(); + final Date date = new Date(_currentTimeMillis); + final SimpleDateFormat format = new SimpleDateFormat("dd-HHmm"); + final String formattedDate = format.format(date); + StringConcatenation _builder = new StringConcatenation(); + _builder.append("output/"); + String _plus = (_builder.toString() + formattedDate); + StringConcatenation _builder_1 = new StringConcatenation(); + _builder_1.append("/"); + String _plus_1 = (_plus + _builder_1); + final FileSystemWorkspace workspace = new FileSystemWorkspace(_plus_1, ""); + workspace.initAndClear(); + final Resource.Factory.Registry reg = Resource.Factory.Registry.INSTANCE; + final Map map = reg.getExtensionToFactoryMap(); + XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl(); + map.put("logicproblem", _xMIResourceFactoryImpl); + InputOutput.println("Input and output workspaces are created"); + InputOutput.print(IterableExtensions.toList(Iterables.filter(TaxationPackage.eINSTANCE.getEClassifiers(), EClass.class)).get(0)); + final EcoreMetamodelDescriptor metamodel = GenerateScenarios.loadMetamodel(TaxationPackage.eINSTANCE); + InputOutput.println("DSL loaded"); + final int SIZE = 10; + int REPS = 1; + final int RUNTIME = 300; + Ecore2LogicConfiguration _ecore2LogicConfiguration = new Ecore2LogicConfiguration(); + final TracedOutput modelGenerationProblem = ecore2Logic.transformMetamodel(metamodel, _ecore2LogicConfiguration); + LogicProblem problem = modelGenerationProblem.getOutput(); + workspace.writeModel(problem, "scenario.logicproblem"); + InputOutput.println("Problem created"); + for (int i = 0; (i <= REPS); i++) { + { + ViatraReasoner reasoner = new ViatraReasoner(); + ViatraReasonerConfiguration _viatraReasonerConfiguration = new ViatraReasonerConfiguration(); + final Procedure1 _function = (ViatraReasonerConfiguration it) -> { + it.runtimeLimit = RUNTIME; + it.typeScopes.maxNewElements = SIZE; + it.typeScopes.minNewElements = SIZE; + }; + final ViatraReasonerConfiguration solverConfig = ObjectExtensions.operator_doubleArrow(_viatraReasonerConfiguration, _function); + LogicResult solution = reasoner.solve(problem, solverConfig, workspace); + InputOutput.print("Problem Solved"); + final Runtime r = Runtime.getRuntime(); + r.gc(); + r.gc(); + r.gc(); + Thread.sleep(3000); + } + } + } catch (Throwable _e) { + throw Exceptions.sneakyThrow(_e); + } + } + + public static Map getTypeMap(final Map classMap, final EcoreMetamodelDescriptor metamodel, final Ecore2Logic e2l, final Ecore2Logic_Trace trace) { + final HashMap typeMap = new HashMap(); + final Function1 _function = (EClass s) -> { + return s.getName(); + }; + final Map listMap = IterableExtensions.toMap(metamodel.getClasses(), _function); + Set _keySet = classMap.keySet(); + for (final Class elem : _keySet) { + typeMap.put( + e2l.TypeofEClass(trace, + listMap.get(elem.getSimpleName())), classMap.get(elem)); + } + return typeMap; + } + + public static EcoreMetamodelDescriptor loadMetamodel(final EPackage pckg) { + final List classes = IterableExtensions.toList(Iterables.filter(pckg.getEClassifiers(), EClass.class)); + final List enums = IterableExtensions.toList(Iterables.filter(pckg.getEClassifiers(), EEnum.class)); + final Function1> _function = (EEnum it) -> { + return it.getELiterals(); + }; + final List literals = IterableExtensions.toList(Iterables.concat(ListExtensions.>map(enums, _function))); + final Function1> _function_1 = (EClass it) -> { + return it.getEReferences(); + }; + final List references = IterableExtensions.toList(Iterables.concat(ListExtensions.>map(classes, _function_1))); + final Function1> _function_2 = (EClass it) -> { + return it.getEAttributes(); + }; + final List attributes = IterableExtensions.toList(Iterables.concat(ListExtensions.>map(classes, _function_2))); + return new EcoreMetamodelDescriptor(classes, Collections.unmodifiableSet(CollectionLiterals.newHashSet()), false, enums, literals, references, attributes); + } + + public static EList loadPartialModel(final ReasonerWorkspace inputs, final String path) { + EList _xblockexpression = null; + { + Map _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap(); + XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl(); + _extensionToFactoryMap.put("*", _xMIResourceFactoryImpl); + _xblockexpression = inputs.readModel(EObject.class, path).eResource().getContents(); + } + return _xblockexpression; + } + + public static ViatraQuerySetDescriptor loadQueries(final EcoreMetamodelDescriptor metamodel, final IQueryGroup i) { + final List> patterns = IterableExtensions.>toList(i.getSpecifications()); + final Function1, Boolean> _function = (IQuerySpecification it) -> { + final Function1 _function_1 = (PAnnotation it_1) -> { + String _name = it_1.getName(); + return Boolean.valueOf(Objects.equal(_name, "Constraint")); + }; + return Boolean.valueOf(IterableExtensions.exists(it.getAllAnnotations(), _function_1)); + }; + final Set> wfPatterns = IterableExtensions.>toSet(IterableExtensions.>filter(patterns, _function)); + final Map, EStructuralFeature> derivedFeatures = CollectionLiterals., EStructuralFeature>emptyMap(); + final ViatraQuerySetDescriptor res = new ViatraQuerySetDescriptor(patterns, wfPatterns, derivedFeatures); + return res; + } +} -- cgit v1.2.3-54-g00ecf