From 269d5cc271f4fa203db64ba46345e4616d771b51 Mon Sep 17 00:00:00 2001 From: ArenBabikian Date: Tue, 28 Apr 2020 12:29:49 -0400 Subject: Rename pledge case study file --- .../case.study.pledge.run/plugin.xml | 43 ++- .../src/run/GeneratePledgeModels.xtend | 243 +++++++++++++++++ .../src/run/GenerateScenarios.xtend | 243 ----------------- .../xtend-gen/run/.GeneratePledgeModels.xtendbin | Bin 0 -> 12504 bytes .../case.study.pledge.run/xtend-gen/run/.gitignore | 1 + .../xtend-gen/run/GeneratePledgeModels.java | 296 +++++++++++++++++++++ 6 files changed, 582 insertions(+), 244 deletions(-) create mode 100644 Tests/MODELS2020-CaseStudies/case.study.pledge.run/src/run/GeneratePledgeModels.xtend delete mode 100644 Tests/MODELS2020-CaseStudies/case.study.pledge.run/src/run/GenerateScenarios.xtend create mode 100644 Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.GeneratePledgeModels.xtendbin create mode 100644 Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/GeneratePledgeModels.java (limited to 'Tests/MODELS2020-CaseStudies') diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/plugin.xml b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/plugin.xml index 2f4febdb..63aa0b02 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/plugin.xml +++ b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/plugin.xml @@ -1 +1,42 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/src/run/GeneratePledgeModels.xtend b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/src/run/GeneratePledgeModels.xtend new file mode 100644 index 00000000..be641c87 --- /dev/null +++ b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/src/run/GeneratePledgeModels.xtend @@ -0,0 +1,243 @@ +package run + +import Taxation.TaxationPackage +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.logic.model.logicresult.ModelResult +import hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore +import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic +import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicConfiguration +import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration +import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualiser +import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace +import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace +import java.math.BigDecimal +import java.text.SimpleDateFormat +import java.util.Date +import java.util.HashMap +import java.util.List +import java.util.Map +import java.util.TreeSet +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.resource.Resource +import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl +import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetup +import org.eclipse.viatra.query.runtime.api.IQueryGroup +import org.eclipse.viatra.query.runtime.rete.matcher.ReteEngine +import queries.Case_study_A + +class GeneratePledgeModels { + def static void main(String[] args) { + val x = (new EMFPatternLanguageStandaloneSetup).createInjectorAndDoEMFRegistration +// //PatternLanguageWithRSSetup.createInjectorAndDoEMFRegistration +// ApplicationConfigurationStandaloneSetup.doSetup + Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("xmi", new XMIResourceFactoryImpl) + Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("logicproblem", new XMIResourceFactoryImpl) + Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("partialmodel", new XMIResourceFactoryImpl) + ReteEngine.getClass + + val Ecore2Logic ecore2Logic = new Ecore2Logic + val Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic) + val Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic) + val InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic + + // Workspace setup + val Date date = new Date(System.currentTimeMillis) + val SimpleDateFormat format = new SimpleDateFormat("dd-HHmm"); + val formattedDate = format.format(date) + + val inputs = new FileSystemWorkspace('''inputs/''', "") + val workspace = new FileSystemWorkspace('''output/''' + formattedDate + '''/''', "") + workspace.initAndClear + + println("Input and output workspaces are created") + +// print(TaxationPackage.eINSTANCE.getEClassifiers.filter(EClass).toList.get(0)) + + //* + val metamodel = loadMetamodel(TaxationPackage.eINSTANCE) + val partialModel = loadPartialModel(inputs, "Household.xmi") + val queries = loadQueries(metamodel, Case_study_A.instance) + /*/ + val metamodel = loadMetamodel(FamilytreePackage.eINSTANCE) +// val partialModel = loadPartialModel(inputs, "yakindu/Yakindu.xmi") + val queries = loadQueries(metamodel, FamilyTreeConstraints.instance) + //*/ + println("DSL loaded") + + val SIZE = 10 + var REPS = 1 + val RUNTIME = 600 + + // ///////////////////////// + // Prepare Problem + val modelGenerationProblem = ecore2Logic.transformMetamodel(metamodel, new Ecore2LogicConfiguration()) + var problem = modelGenerationProblem.output + +// val modelExtensionProblem = instanceModel2Logic.transform(modelGenerationProblem, partialModel) +// problem = modelExtensionProblem.output + + val validModelExtensionProblem = viatra2Logic.transformQueries(queries, modelGenerationProblem, + new Viatra2LogicConfiguration) + problem = validModelExtensionProblem.output + + workspace.writeModel(problem, "problem.logicproblem") + println("Problem created") + + for (var i = 0; i < REPS; i++) { + + println("Run #" + i + ":") + + var ViatraReasoner reasoner = new ViatraReasoner + + // ///////////////////////////////////////////////////// + // Define Config File + val knownIntegers = new TreeSet + knownIntegers.addAll(0) + + val knownReals = new TreeSet + knownReals.addAll(new BigDecimal("0.0")) + + val knownStrings = new TreeSet + knownStrings.addAll("r0", "r1", "r2") + + + val solverConfig = new ViatraReasonerConfiguration => [ + it.runtimeLimit = RUNTIME + it.typeScopes.maxNewElements = SIZE +// it.typeScopes.minNewElements = SIZE + if(!knownIntegers.isEmpty) it.typeScopes.knownIntegers = knownIntegers + if(!knownReals.isEmpty) it.typeScopes.knownReals = knownReals +// if(!knownStrings.isEmpty) it.typeScopes.knownStrings = knownStrings + ] + + val startTime = System.currentTimeMillis + var solution = reasoner.solve(problem, solverConfig, workspace) + val totalTime = System.currentTimeMillis-startTime + + println(" Problem Solved") + solution.writeStats(totalTime) + + if (solution instanceof ModelResult) { + solution.writeRepresentation(workspace, i) +// solution.writeInterpretation(logic2Ecore, workspace, i, reasoner, modelGenerationProblem) + println(" Solution saved and visualised") + } else + println(" Returned: " + solution.class.simpleName.toString) + + +// println("Stats Created") + // Run Garbage Collector + val Runtime r = Runtime.getRuntime(); + r.gc(); + r.gc(); + r.gc(); + Thread.sleep(3000) + } + println("---End---") + + } + + def static Map getTypeMap(Map classMap, EcoreMetamodelDescriptor metamodel, + Ecore2Logic e2l, Ecore2Logic_Trace trace) { + val typeMap = new HashMap + val listMap = metamodel.classes.toMap[s|s.name] + + for (Class elem : classMap.keySet) { + typeMap.put(e2l.TypeofEClass( + trace, + listMap.get(elem.simpleName) + ), classMap.get(elem)) + } + return typeMap + } + + def static loadMetamodel(EPackage pckg) { + val List classes = pckg.getEClassifiers.filter(EClass).toList + val List enums = pckg.getEClassifiers.filter(EEnum).toList + val List literals = enums.map[getELiterals].flatten.toList + val List references = classes.map[getEReferences].flatten.toList + val List attributes = classes.map[getEAttributes].flatten.toList + return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes) + } + + def static loadPartialModel(ReasonerWorkspace inputs, String path) { + Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("*", new XMIResourceFactoryImpl()) + inputs.readModel(EObject, path).eResource.contents +// inputs.readModel(EObject,"FamInstance.xmi").eResource.allContents.toList + } + + def static loadQueries(EcoreMetamodelDescriptor metamodel, IQueryGroup i) { + val patterns = i.specifications.toList + val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet + val derivedFeatures = emptyMap + // NO DERIVED FEATURES +// val derivedFeatures = new LinkedHashMap +// derivedFeatures.put(i.type,metamodel.attributes.filter[it.name == "type"].head) +// derivedFeatures.put(i.model,metamodel.references.filter[it.name == "model"].head) + val res = new ViatraQuerySetDescriptor( + patterns, + wfPatterns, + derivedFeatures + ) + return res + } + + def static writeInterpretation(LogicResult solution, Logic2Ecore logic2Ecore, ReasonerWorkspace workspace, int i, + ViatraReasoner reasoner, TracedOutput mgProb) { + val interpretations = reasoner.getInterpretations(solution as ModelResult) + for (interpIndex : 0 ..< interpretations.size) { +// val extension b = new LogicStructureBuilder +// val extension a = new LogicProblemBuilder + val interpretation = interpretations.get(interpIndex) + val model = logic2Ecore.transformInterpretation(interpretation, mgProb.trace) + workspace.writeModel(model, '''solution«i»_«interpIndex».xmi''') + } + } + + def static writeRepresentation(LogicResult solution, ReasonerWorkspace workspace, int i) { + val representations = solution.representation + for (representationIndex : 0 ..< representations.size) { + val representation = representations.get(representationIndex) + if (representation instanceof PartialInterpretation) { + val gml = (new PartialInterpretation2Gml).transform(representation) + workspace.writeText('''solution«i»_«representationIndex».gml''', gml) + + val png = (new GraphvizVisualiser).visualiseConcretization(representation) + png.writeToFile(workspace, '''solution«i»_«representationIndex».png''') + +// workspace.writeModel(representation, '''solution«representationIndex».partialintrpretation''') + } else { + workspace.writeText('''solution«representationIndex».txt''', representation.toString) + } + } + } + + def static writeStats(LogicResult solution, long time) { + val stats = solution.statistics + println(" Statistics:") +// for (e : stats.entries.filter[name.substring(0, 9) == "_Solution"]) { +// println(" " + e.name + ": " + (e as IntStatisticEntry).value + " ms") +// } + println(" \"solve\" time: " + time as double/1000 + " s") + +// println("<>") + } +} diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/src/run/GenerateScenarios.xtend b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/src/run/GenerateScenarios.xtend deleted file mode 100644 index 8445130a..00000000 --- a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/src/run/GenerateScenarios.xtend +++ /dev/null @@ -1,243 +0,0 @@ -package run - -import Taxation.TaxationPackage -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.logic.model.logicresult.ModelResult -import hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore -import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic -import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicConfiguration -import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor -import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic -import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation -import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml -import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner -import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration -import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualiser -import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace -import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace -import java.math.BigDecimal -import java.text.SimpleDateFormat -import java.util.Date -import java.util.HashMap -import java.util.List -import java.util.Map -import java.util.TreeSet -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.resource.Resource -import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl -import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetup -import org.eclipse.viatra.query.runtime.api.IQueryGroup -import org.eclipse.viatra.query.runtime.rete.matcher.ReteEngine -import queries.Case_study_A - -class GenerateScenarios { - def static void main(String[] args) { - val x = (new EMFPatternLanguageStandaloneSetup).createInjectorAndDoEMFRegistration -// //PatternLanguageWithRSSetup.createInjectorAndDoEMFRegistration -// ApplicationConfigurationStandaloneSetup.doSetup - Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("xmi", new XMIResourceFactoryImpl) - Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("logicproblem", new XMIResourceFactoryImpl) - Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("partialmodel", new XMIResourceFactoryImpl) - ReteEngine.getClass - - val Ecore2Logic ecore2Logic = new Ecore2Logic - val Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic) - val Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic) - val InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic - - // Workspace setup - val Date date = new Date(System.currentTimeMillis) - val SimpleDateFormat format = new SimpleDateFormat("dd-HHmm"); - val formattedDate = format.format(date) - - val inputs = new FileSystemWorkspace('''inputs/''', "") - val workspace = new FileSystemWorkspace('''output/''' + formattedDate + '''/''', "") - workspace.initAndClear - - println("Input and output workspaces are created") - -// print(TaxationPackage.eINSTANCE.getEClassifiers.filter(EClass).toList.get(0)) - - //* - val metamodel = loadMetamodel(TaxationPackage.eINSTANCE) - val partialModel = loadPartialModel(inputs, "Household.xmi") - val queries = loadQueries(metamodel, Case_study_A.instance) - /*/ - val metamodel = loadMetamodel(FamilytreePackage.eINSTANCE) -// val partialModel = loadPartialModel(inputs, "yakindu/Yakindu.xmi") - val queries = loadQueries(metamodel, FamilyTreeConstraints.instance) - //*/ - println("DSL loaded") - - val SIZE = 10 - var REPS = 1 - val RUNTIME = 600 - - // ///////////////////////// - // Prepare Problem - val modelGenerationProblem = ecore2Logic.transformMetamodel(metamodel, new Ecore2LogicConfiguration()) - var problem = modelGenerationProblem.output - -// val modelExtensionProblem = instanceModel2Logic.transform(modelGenerationProblem, partialModel) -// problem = modelExtensionProblem.output - - val validModelExtensionProblem = viatra2Logic.transformQueries(queries, modelGenerationProblem, - new Viatra2LogicConfiguration) - problem = validModelExtensionProblem.output - - workspace.writeModel(problem, "problem.logicproblem") - println("Problem created") - - for (var i = 0; i < REPS; i++) { - - println("Run #" + i + ":") - - var ViatraReasoner reasoner = new ViatraReasoner - - // ///////////////////////////////////////////////////// - // Define Config File - val knownIntegers = new TreeSet - knownIntegers.addAll(0) - - val knownReals = new TreeSet - knownReals.addAll(new BigDecimal("0.0")) - - val knownStrings = new TreeSet - knownStrings.addAll("r0", "r1", "r2") - - - val solverConfig = new ViatraReasonerConfiguration => [ - it.runtimeLimit = RUNTIME - it.typeScopes.maxNewElements = SIZE -// it.typeScopes.minNewElements = SIZE - if(!knownIntegers.isEmpty) it.typeScopes.knownIntegers = knownIntegers - if(!knownReals.isEmpty) it.typeScopes.knownReals = knownReals -// if(!knownStrings.isEmpty) it.typeScopes.knownStrings = knownStrings - ] - - val startTime = System.currentTimeMillis - var solution = reasoner.solve(problem, solverConfig, workspace) - val totalTime = System.currentTimeMillis-startTime - - println(" Problem Solved") - solution.writeStats(totalTime) - - if (solution instanceof ModelResult) { - solution.writeRepresentation(workspace, i) -// solution.writeInterpretation(logic2Ecore, workspace, i, reasoner, modelGenerationProblem) - println(" Solution saved and visualised") - } else - println(" Returned: " + solution.class.simpleName.toString) - - -// println("Stats Created") - // Run Garbage Collector - val Runtime r = Runtime.getRuntime(); - r.gc(); - r.gc(); - r.gc(); - Thread.sleep(3000) - } - println("---End---") - - } - - def static Map getTypeMap(Map classMap, EcoreMetamodelDescriptor metamodel, - Ecore2Logic e2l, Ecore2Logic_Trace trace) { - val typeMap = new HashMap - val listMap = metamodel.classes.toMap[s|s.name] - - for (Class elem : classMap.keySet) { - typeMap.put(e2l.TypeofEClass( - trace, - listMap.get(elem.simpleName) - ), classMap.get(elem)) - } - return typeMap - } - - def static loadMetamodel(EPackage pckg) { - val List classes = pckg.getEClassifiers.filter(EClass).toList - val List enums = pckg.getEClassifiers.filter(EEnum).toList - val List literals = enums.map[getELiterals].flatten.toList - val List references = classes.map[getEReferences].flatten.toList - val List attributes = classes.map[getEAttributes].flatten.toList - return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes) - } - - def static loadPartialModel(ReasonerWorkspace inputs, String path) { - Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("*", new XMIResourceFactoryImpl()) - inputs.readModel(EObject, path).eResource.contents -// inputs.readModel(EObject,"FamInstance.xmi").eResource.allContents.toList - } - - def static loadQueries(EcoreMetamodelDescriptor metamodel, IQueryGroup i) { - val patterns = i.specifications.toList - val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet - val derivedFeatures = emptyMap - // NO DERIVED FEATURES -// val derivedFeatures = new LinkedHashMap -// derivedFeatures.put(i.type,metamodel.attributes.filter[it.name == "type"].head) -// derivedFeatures.put(i.model,metamodel.references.filter[it.name == "model"].head) - val res = new ViatraQuerySetDescriptor( - patterns, - wfPatterns, - derivedFeatures - ) - return res - } - - def static writeInterpretation(LogicResult solution, Logic2Ecore logic2Ecore, ReasonerWorkspace workspace, int i, - ViatraReasoner reasoner, TracedOutput mgProb) { - val interpretations = reasoner.getInterpretations(solution as ModelResult) - for (interpIndex : 0 ..< interpretations.size) { -// val extension b = new LogicStructureBuilder -// val extension a = new LogicProblemBuilder - val interpretation = interpretations.get(interpIndex) - val model = logic2Ecore.transformInterpretation(interpretation, mgProb.trace) - workspace.writeModel(model, '''solution«i»_«interpIndex».xmi''') - } - } - - def static writeRepresentation(LogicResult solution, ReasonerWorkspace workspace, int i) { - val representations = solution.representation - for (representationIndex : 0 ..< representations.size) { - val representation = representations.get(representationIndex) - if (representation instanceof PartialInterpretation) { - val gml = (new PartialInterpretation2Gml).transform(representation) - workspace.writeText('''solution«i»_«representationIndex».gml''', gml) - - val png = (new GraphvizVisualiser).visualiseConcretization(representation) - png.writeToFile(workspace, '''solution«i»_«representationIndex».png''') - -// workspace.writeModel(representation, '''solution«representationIndex».partialintrpretation''') - } else { - workspace.writeText('''solution«representationIndex».txt''', representation.toString) - } - } - } - - def static writeStats(LogicResult solution, long time) { - val stats = solution.statistics - println(" Statistics:") -// for (e : stats.entries.filter[name.substring(0, 9) == "_Solution"]) { -// println(" " + e.name + ": " + (e as IntStatisticEntry).value + " ms") -// } - println(" \"solve\" time: " + time as double/1000 + " s") - -// println("<>") - } -} diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.GeneratePledgeModels.xtendbin b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.GeneratePledgeModels.xtendbin new file mode 100644 index 00000000..7c005ae3 Binary files /dev/null and b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.GeneratePledgeModels.xtendbin differ diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.gitignore b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.gitignore index 01244e82..01940246 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.gitignore +++ b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.gitignore @@ -3,3 +3,4 @@ /.RunGenerator.xtendbin /GenerateScenarios.java /.GenerateScenarios.xtendbin +/.GeneratePledgeModels.java._trace diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/GeneratePledgeModels.java b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/GeneratePledgeModels.java new file mode 100644 index 00000000..24f2b9b4 --- /dev/null +++ b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/GeneratePledgeModels.java @@ -0,0 +1,296 @@ +package run; + +import Taxation.TaxationPackage; +import com.google.common.base.Objects; +import com.google.common.collect.Iterables; +import com.google.inject.Injector; +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.LogicModelInterpretation; +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.logic.model.logicresult.ModelResult; +import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.Statistics; +import hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore; +import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic; +import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicConfiguration; +import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicTrace; +import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor; +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic; +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation; +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml; +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualisation; +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner; +import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration; +import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualiser; +import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace; +import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace; +import java.math.BigDecimal; +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 java.util.TreeSet; +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.patternlanguage.emf.EMFPatternLanguageStandaloneSetup; +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.viatra.query.runtime.rete.matcher.ReteEngine; +import org.eclipse.xtend2.lib.StringConcatenation; +import org.eclipse.xtext.xbase.lib.CollectionExtensions; +import org.eclipse.xtext.xbase.lib.CollectionLiterals; +import org.eclipse.xtext.xbase.lib.Exceptions; +import org.eclipse.xtext.xbase.lib.ExclusiveRange; +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; +import queries.Case_study_A; + +@SuppressWarnings("all") +public class GeneratePledgeModels { + public static void main(final String[] args) { + try { + final Injector x = new EMFPatternLanguageStandaloneSetup().createInjectorAndDoEMFRegistration(); + Map _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap(); + XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl(); + _extensionToFactoryMap.put("xmi", _xMIResourceFactoryImpl); + Map _extensionToFactoryMap_1 = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap(); + XMIResourceFactoryImpl _xMIResourceFactoryImpl_1 = new XMIResourceFactoryImpl(); + _extensionToFactoryMap_1.put("logicproblem", _xMIResourceFactoryImpl_1); + Map _extensionToFactoryMap_2 = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap(); + XMIResourceFactoryImpl _xMIResourceFactoryImpl_2 = new XMIResourceFactoryImpl(); + _extensionToFactoryMap_2.put("partialmodel", _xMIResourceFactoryImpl_2); + ReteEngine.class.getClass(); + final Ecore2Logic ecore2Logic = new Ecore2Logic(); + final Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic); + final Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic); + final InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic(); + 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("inputs/"); + final FileSystemWorkspace inputs = new FileSystemWorkspace(_builder.toString(), ""); + StringConcatenation _builder_1 = new StringConcatenation(); + _builder_1.append("output/"); + String _plus = (_builder_1.toString() + formattedDate); + StringConcatenation _builder_2 = new StringConcatenation(); + _builder_2.append("/"); + String _plus_1 = (_plus + _builder_2); + final FileSystemWorkspace workspace = new FileSystemWorkspace(_plus_1, ""); + workspace.initAndClear(); + InputOutput.println("Input and output workspaces are created"); + final EcoreMetamodelDescriptor metamodel = GeneratePledgeModels.loadMetamodel(TaxationPackage.eINSTANCE); + final EList partialModel = GeneratePledgeModels.loadPartialModel(inputs, "Household.xmi"); + final ViatraQuerySetDescriptor queries = GeneratePledgeModels.loadQueries(metamodel, Case_study_A.instance()); + InputOutput.println("DSL loaded"); + final int SIZE = 10; + int REPS = 1; + final int RUNTIME = 600; + Ecore2LogicConfiguration _ecore2LogicConfiguration = new Ecore2LogicConfiguration(); + final TracedOutput modelGenerationProblem = ecore2Logic.transformMetamodel(metamodel, _ecore2LogicConfiguration); + LogicProblem problem = modelGenerationProblem.getOutput(); + Viatra2LogicConfiguration _viatra2LogicConfiguration = new Viatra2LogicConfiguration(); + final TracedOutput validModelExtensionProblem = viatra2Logic.transformQueries(queries, modelGenerationProblem, _viatra2LogicConfiguration); + problem = validModelExtensionProblem.getOutput(); + workspace.writeModel(problem, "problem.logicproblem"); + InputOutput.println("Problem created"); + for (int i = 0; (i < REPS); i++) { + { + InputOutput.println((("Run #" + Integer.valueOf(i)) + ":")); + ViatraReasoner reasoner = new ViatraReasoner(); + final TreeSet knownIntegers = new TreeSet(); + CollectionExtensions.addAll(knownIntegers, Integer.valueOf(0)); + final TreeSet knownReals = new TreeSet(); + BigDecimal _bigDecimal = new BigDecimal("0.0"); + CollectionExtensions.addAll(knownReals, _bigDecimal); + final TreeSet knownStrings = new TreeSet(); + CollectionExtensions.addAll(knownStrings, "r0", "r1", "r2"); + ViatraReasonerConfiguration _viatraReasonerConfiguration = new ViatraReasonerConfiguration(); + final Procedure1 _function = (ViatraReasonerConfiguration it) -> { + it.runtimeLimit = RUNTIME; + it.typeScopes.maxNewElements = SIZE; + boolean _isEmpty = knownIntegers.isEmpty(); + boolean _not = (!_isEmpty); + if (_not) { + it.typeScopes.knownIntegers = knownIntegers; + } + boolean _isEmpty_1 = knownReals.isEmpty(); + boolean _not_1 = (!_isEmpty_1); + if (_not_1) { + it.typeScopes.knownReals = knownReals; + } + }; + final ViatraReasonerConfiguration solverConfig = ObjectExtensions.operator_doubleArrow(_viatraReasonerConfiguration, _function); + final long startTime = System.currentTimeMillis(); + LogicResult solution = reasoner.solve(problem, solverConfig, workspace); + long _currentTimeMillis_1 = System.currentTimeMillis(); + final long totalTime = (_currentTimeMillis_1 - startTime); + InputOutput.println(" Problem Solved"); + GeneratePledgeModels.writeStats(solution, totalTime); + if ((solution instanceof ModelResult)) { + GeneratePledgeModels.writeRepresentation(solution, workspace, i); + InputOutput.println(" Solution saved and visualised"); + } else { + String _string = solution.getClass().getSimpleName().toString(); + String _plus_2 = (" Returned: " + _string); + InputOutput.println(_plus_2); + } + final Runtime r = Runtime.getRuntime(); + r.gc(); + r.gc(); + r.gc(); + Thread.sleep(3000); + } + } + InputOutput.println("---End---"); + } 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; + } + + public static void writeInterpretation(final LogicResult solution, final Logic2Ecore logic2Ecore, final ReasonerWorkspace workspace, final int i, final ViatraReasoner reasoner, final TracedOutput mgProb) { + final List interpretations = reasoner.getInterpretations(((ModelResult) solution)); + int _size = interpretations.size(); + ExclusiveRange _doubleDotLessThan = new ExclusiveRange(0, _size, true); + for (final Integer interpIndex : _doubleDotLessThan) { + { + final LogicModelInterpretation interpretation = interpretations.get((interpIndex).intValue()); + final EObject model = logic2Ecore.transformInterpretation(interpretation, mgProb.getTrace()); + StringConcatenation _builder = new StringConcatenation(); + _builder.append("solution"); + _builder.append(i); + _builder.append("_"); + _builder.append(interpIndex); + _builder.append(".xmi"); + workspace.writeModel(model, _builder.toString()); + } + } + } + + public static void writeRepresentation(final LogicResult solution, final ReasonerWorkspace workspace, final int i) { + final EList representations = solution.getRepresentation(); + int _size = representations.size(); + ExclusiveRange _doubleDotLessThan = new ExclusiveRange(0, _size, true); + for (final Integer representationIndex : _doubleDotLessThan) { + { + final Object representation = representations.get((representationIndex).intValue()); + if ((representation instanceof PartialInterpretation)) { + final String gml = new PartialInterpretation2Gml().transform(((PartialInterpretation)representation)); + StringConcatenation _builder = new StringConcatenation(); + _builder.append("solution"); + _builder.append(i); + _builder.append("_"); + _builder.append(representationIndex); + _builder.append(".gml"); + workspace.writeText(_builder.toString(), gml); + final PartialInterpretationVisualisation png = new GraphvizVisualiser().visualiseConcretization(((PartialInterpretation)representation)); + StringConcatenation _builder_1 = new StringConcatenation(); + _builder_1.append("solution"); + _builder_1.append(i); + _builder_1.append("_"); + _builder_1.append(representationIndex); + _builder_1.append(".png"); + png.writeToFile(workspace, _builder_1.toString()); + } else { + StringConcatenation _builder_2 = new StringConcatenation(); + _builder_2.append("solution"); + _builder_2.append(representationIndex); + _builder_2.append(".txt"); + workspace.writeText(_builder_2.toString(), representation.toString()); + } + } + } + } + + public static String writeStats(final LogicResult solution, final long time) { + String _xblockexpression = null; + { + final Statistics stats = solution.getStatistics(); + InputOutput.println(" Statistics:"); + _xblockexpression = InputOutput.println(((" \"solve\" time: " + Double.valueOf((((double) time) / 1000))) + " s")); + } + return _xblockexpression; + } +} -- cgit v1.2.3-54-g00ecf