1 files changed, 89 insertions, 64 deletions
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend
index 40ffaf28..9a8ac8a3 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend
@@ -143,89 +143,114 @@ class GenerationTaskExecutor {
                                        1
                                }
                        ]
-                        solverConfig.typeScopes = scopeLoader.loadScope(
+                        
+                        val typeScopes = scopeLoader.loadScope(
                                scopeSpecification,
                                problem,
                                ecore2Logic,
                                modelGeneration.trace
                        )
-                        
+                        // If the type scope contains errors, then the problem is inconsistent
-                        // 5.3 set resource limits
+                        if(!typeScopes.value.empty) {
-                        documentationLevel.ifPresent[solverConfig.documentationLevel = it]
+                                monitor.worked(50)
-                        runtieLimit.ifPresent[solverConfig.runtimeLimit = it]
+                                console.writeMessage("Model generation started")
-                        memoryLimit.ifPresent[solverConfig.memoryLimit = it]
+                                typeScopes.value.forEach[console.writeMessage(it)]
-                        
-                        // 6. execute the solver on the problem with the configuration
-                        // 6.1 calculating the runs
-                        val runs = if(task.runSpecified) { task.runs } else { 1 }
-                        monitor.worked(50)
-                        
-                        console.writeMessage("Model generation started")
-                        for(run : 1..runs) {
-                                monitor.subTask('''Solving problem«IF runs>0» «run»/«runs»«ENDIF»''')
                                
-                                // 6.2 For each run, the configuration and the workspace is adjusted
+                                val runs = if(task.runSpecified) { task.runs } else { 1 }
-                                solverLoader.setRunIndex(solverConfig,configurationMap,run,console)
+                                for(run : 1..runs) {
-                                solverConfig.progressMonitor = new EclipseBasedProgressMonitor(monitor)
+                                        console.writeMessage('''Problem is inconsistent, no model is created!''')
-                                val reasonerWorkspaceForRun = if(runs > 1) {
+                                        val statistics = new LinkedHashMap
-                                        reasonerWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]
+                                        statistics.put("Task",(task.eContainer as ConfigurationScript).commands.indexOf(task)+1)
-                                } else {
+                                        statistics.put("Run",run)
-                                        reasonerWorkspace
+                                        statistics.put("Result","InconsistencyResult")
+                                        statistics.put("Domain to logic transformation time",domain2LogicTransformationTime/1000000)
+                                        statistics.put("Logic to solver transformation time",0)
+                                        statistics.put("Solver time",0)
+                                        statistics.put("Postprocessing time",0)
+                                        console.addStatistics(statistics)
                                }
                                
-                                // 7. Solver call
+                        } else {
-                                val solution = solver.solve(problem,solverConfig,reasonerWorkspaceForRun)
+                                solverConfig.typeScopes = typeScopes.key
-                                console.writeMessage(solution.soutionDescription.toString)
+                        
+                                // 5.3 set resource limits
+                                documentationLevel.ifPresent[solverConfig.documentationLevel = it]
+                                runtieLimit.ifPresent[solverConfig.runtimeLimit = it]
+                                memoryLimit.ifPresent[solverConfig.memoryLimit = it]
                                
-                                //  8. Solution processing
+                                // 6. execute the solver on the problem with the configuration
+                                // 6.1 calculating the runs
+                                val runs = if(task.runSpecified) { task.runs } else { 1 }
+                                monitor.worked(50)
                                
-                                // 8.1 Visualisation
+                                console.writeMessage("Model generation started")
-                                var solutionVisualisationTime = System.nanoTime
+                                for(run : 1..runs) {
-                                if(solution instanceof ModelResult) {
+                                        monitor.subTask('''Solving problem«IF runs>0» «run»/«runs»«ENDIF»''')
-                                        val interpretations = solver.getInterpretations(solution)
+                                        
-                                        val outputWorkspaceForRun = if(runs > 1) {
+                                        // 6.2 For each run, the configuration and the workspace is adjusted
-                                                outputWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]
+                                        solverLoader.setRunIndex(solverConfig,configurationMap,run,console)
+                                        solverConfig.progressMonitor = new EclipseBasedProgressMonitor(monitor)
+                                        val reasonerWorkspaceForRun = if(runs > 1) {
+                                                reasonerWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]
                                        } else {
-                                                outputWorkspace
+                                                reasonerWorkspace
                                        }
                                        
-                                        for(interpretationIndex : 0..<interpretations.size) {
+                                        // 7. Solver call
-                                                monitor.subTask('''Solving problem«IF runs>0» «run»/«runs»«ENDIF»: Visualising solution «interpretationIndex+1»/«interpretations.size»''')
+                                        val solution = solver.solve(problem,solverConfig,reasonerWorkspaceForRun)
-                                                val interpretation = interpretations.get(interpretationIndex)
+                                        console.writeMessage(solution.soutionDescription.toString)
-                                                val model = logic2Ecore.transformInterpretation(interpretation,modelGeneration.trace)
+                                        
-                                                outputWorkspaceForRun.writeModel(model,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».xmi''')
+                                        //  8. Solution processing
+                                        
+                                        // 8.1 Visualisation
+                                        var solutionVisualisationTime = System.nanoTime
+                                        if(solution instanceof ModelResult) {
+                                                val interpretations = solver.getInterpretations(solution)
+                                                val outputWorkspaceForRun = if(runs > 1) {
+                                                        outputWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]
+                                                } else {
+                                                        outputWorkspace
+                                                }
                                                
-                                                val representation = solution.representation.get(interpretationIndex)
+                                                for(interpretationIndex : 0..<interpretations.size) {
-                                                if(representation instanceof PartialInterpretation) {
+                                                        monitor.subTask('''Solving problem«IF runs>0» «run»/«runs»«ENDIF»: Visualising solution «interpretationIndex+1»/«interpretations.size»''')
-                                                        val vis1 = new PartialInterpretation2Gml
+                                                        val interpretation = interpretations.get(interpretationIndex)
-                                                        val gml = vis1.transform(representation)
+                                                        val model = logic2Ecore.transformInterpretation(interpretation,modelGeneration.trace)
-                                                        outputWorkspaceForRun.writeText('''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».gml''',gml)
+                                                        outputWorkspaceForRun.writeModel(model,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».xmi''')
-                                                        if(representation.newElements.size + representation.problem.elements.size < 150) {
+                                                        
-                                                                val vis2 = new GraphvizVisualiser
+                                                        val representation = solution.representation.get(interpretationIndex)
-                                                                val dot = vis2.visualiseConcretization(representation)
+                                                        if(representation instanceof PartialInterpretation) {
-                                                                dot.writeToFile(outputWorkspaceForRun,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».png''')
+                                                                val vis1 = new PartialInterpretation2Gml
+                                                                val gml = vis1.transform(representation)
+                                                                outputWorkspaceForRun.writeText('''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».gml''',gml)
+                                                                if(representation.newElements.size + representation.problem.elements.size < 150) {
+                                                                        val vis2 = new GraphvizVisualiser
+                                                                        val dot = vis2.visualiseConcretization(representation)
+                                                                        dot.writeToFile(outputWorkspaceForRun,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».png''')
+                                                                }
                                                        }
+                                                        monitor.worked(100)
                                                }
-                                                monitor.worked(100)
+                                        } else {
+                                                monitor.worked(solverConfig.solutionScope.numberOfRequiredSolution*100)
                                        }
-                                } else {
+                                        solutionVisualisationTime = System.nanoTime - solutionVisualisationTime
-                                        monitor.worked(solverConfig.solutionScope.numberOfRequiredSolution*100)
+                                        
+                                        // 8.2 Statistics
+                                        val statistics = new LinkedHashMap
+                                        statistics.put("Task",(task.eContainer as ConfigurationScript).commands.indexOf(task)+1)
+                                        statistics.put("Run",run)
+                                        statistics.put("Result",solution.class.simpleName)
+                                        statistics.put("Domain to logic transformation time",domain2LogicTransformationTime/1000000)
+                                        statistics.put("Logic to solver transformation time",solution.statistics.transformationTime)
+                                        statistics.put("Solver time",solution.statistics.solverTime)
+                                        statistics.put("Postprocessing time",solutionVisualisationTime)
+                                        for(entry: solution.statistics.entries) {
+                                                statistics.put(entry.name,statisticsUtil.readValue(entry))
+                                        }
+                                        console.addStatistics(statistics)
                                }
-                                solutionVisualisationTime = System.nanoTime - solutionVisualisationTime
                                
-                                // 8.2 Statistics
-                                val statistics = new LinkedHashMap
-                                statistics.put("Task",(task.eContainer as ConfigurationScript).commands.indexOf(task)+1)
-                                statistics.put("Run",run)
-                                statistics.put("Result",solution.class.simpleName)
-                                statistics.put("Domain to logic transformation time",domain2LogicTransformationTime/1000000)
-                                statistics.put("Logic to solver transformation time",solution.statistics.transformationTime)
-                                statistics.put("Solver time",solution.statistics.solverTime)
-                                statistics.put("Postprocessing time",solutionVisualisationTime)
-                                for(entry: solution.statistics.entries) {
-                                        statistics.put(entry.name,statisticsUtil.readValue(entry))
-                                }
-                                console.addStatistics(statistics)
                        }
                        console.flushStatistics
                        console.writeMessage("Model generation finished")

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend index 40ffaf28..9a8ac8a3 100644 --- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/GenerationTaskExecutor.xtend
@@ -143,89 +143,114 @@ class GenerationTaskExecutor {
143	1	143	1
144	}	144	}
145	]	145	]
146	solverConfig.typeScopes = scopeLoader.loadScope(	146
		147	val typeScopes = scopeLoader.loadScope(
147	scopeSpecification,	148	scopeSpecification,
148	problem,	149	problem,
149	ecore2Logic,	150	ecore2Logic,
150	modelGeneration.trace	151	modelGeneration.trace
151	)	152	)
152		153	// If the type scope contains errors, then the problem is inconsistent
153	// 5.3 set resource limits	154	if(!typeScopes.value.empty) {
154	documentationLevel.ifPresent[solverConfig.documentationLevel = it]	155	monitor.worked(50)
155	runtieLimit.ifPresent[solverConfig.runtimeLimit = it]	156	console.writeMessage("Model generation started")
156	memoryLimit.ifPresent[solverConfig.memoryLimit = it]	157	typeScopes.value.forEach[console.writeMessage(it)]
157
158	// 6. execute the solver on the problem with the configuration
159	// 6.1 calculating the runs
160	val runs = if(task.runSpecified) { task.runs } else { 1 }
161	monitor.worked(50)
162
163	console.writeMessage("Model generation started")
164	for(run : 1..runs) {
165	monitor.subTask('''Solving problem«IF runs>0» «run»/«runs»«ENDIF»''')
166		158
167	// 6.2 For each run, the configuration and the workspace is adjusted	159	val runs = if(task.runSpecified) { task.runs } else { 1 }
168	solverLoader.setRunIndex(solverConfig,configurationMap,run,console)	160	for(run : 1..runs) {
169	solverConfig.progressMonitor = new EclipseBasedProgressMonitor(monitor)	161	console.writeMessage('''Problem is inconsistent, no model is created!''')
170	val reasonerWorkspaceForRun = if(runs > 1) {	162	val statistics = new LinkedHashMap
171	reasonerWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]	163	statistics.put("Task",(task.eContainer as ConfigurationScript).commands.indexOf(task)+1)
172	} else {	164	statistics.put("Run",run)
173	reasonerWorkspace	165	statistics.put("Result","InconsistencyResult")
		166	statistics.put("Domain to logic transformation time",domain2LogicTransformationTime/1000000)
		167	statistics.put("Logic to solver transformation time",0)
		168	statistics.put("Solver time",0)
		169	statistics.put("Postprocessing time",0)
		170	console.addStatistics(statistics)
174	}	171	}
175		172
176	// 7. Solver call	173	} else {
177	val solution = solver.solve(problem,solverConfig,reasonerWorkspaceForRun)	174	solverConfig.typeScopes = typeScopes.key
178	console.writeMessage(solution.soutionDescription.toString)	175
		176	// 5.3 set resource limits
		177	documentationLevel.ifPresent[solverConfig.documentationLevel = it]
		178	runtieLimit.ifPresent[solverConfig.runtimeLimit = it]
		179	memoryLimit.ifPresent[solverConfig.memoryLimit = it]
179		180
180	// 8. Solution processing	181	// 6. execute the solver on the problem with the configuration
		182	// 6.1 calculating the runs
		183	val runs = if(task.runSpecified) { task.runs } else { 1 }
		184	monitor.worked(50)
181		185
182	// 8.1 Visualisation	186	console.writeMessage("Model generation started")
183	var solutionVisualisationTime = System.nanoTime	187	for(run : 1..runs) {
184	if(solution instanceof ModelResult) {	188	monitor.subTask('''Solving problem«IF runs>0» «run»/«runs»«ENDIF»''')
185	val interpretations = solver.getInterpretations(solution)	189
186	val outputWorkspaceForRun = if(runs > 1) {	190	// 6.2 For each run, the configuration and the workspace is adjusted
187	outputWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]	191	solverLoader.setRunIndex(solverConfig,configurationMap,run,console)
		192	solverConfig.progressMonitor = new EclipseBasedProgressMonitor(monitor)
		193	val reasonerWorkspaceForRun = if(runs > 1) {
		194	reasonerWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]
188	} else {	195	} else {
189	outputWorkspace	196	reasonerWorkspace
190	}	197	}
191		198
192	for(interpretationIndex : 0..<interpretations.size) {	199	// 7. Solver call
193	monitor.subTask('''Solving problem«IF runs>0» «run»/«runs»«ENDIF»: Visualising solution «interpretationIndex+1»/«interpretations.size»''')	200	val solution = solver.solve(problem,solverConfig,reasonerWorkspaceForRun)
194	val interpretation = interpretations.get(interpretationIndex)	201	console.writeMessage(solution.soutionDescription.toString)
195	val model = logic2Ecore.transformInterpretation(interpretation,modelGeneration.trace)	202
196	outputWorkspaceForRun.writeModel(model,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».xmi''')	203	// 8. Solution processing
		204
		205	// 8.1 Visualisation
		206	var solutionVisualisationTime = System.nanoTime
		207	if(solution instanceof ModelResult) {
		208	val interpretations = solver.getInterpretations(solution)
		209	val outputWorkspaceForRun = if(runs > 1) {
		210	outputWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]
		211	} else {
		212	outputWorkspace
		213	}
197		214
198	val representation = solution.representation.get(interpretationIndex)	215	for(interpretationIndex : 0..<interpretations.size) {
199	if(representation instanceof PartialInterpretation) {	216	monitor.subTask('''Solving problem«IF runs>0» «run»/«runs»«ENDIF»: Visualising solution «interpretationIndex+1»/«interpretations.size»''')
200	val vis1 = new PartialInterpretation2Gml	217	val interpretation = interpretations.get(interpretationIndex)
201	val gml = vis1.transform(representation)	218	val model = logic2Ecore.transformInterpretation(interpretation,modelGeneration.trace)
202	outputWorkspaceForRun.writeText('''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».gml''',gml)	219	outputWorkspaceForRun.writeModel(model,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».xmi''')
203	if(representation.newElements.size + representation.problem.elements.size < 150) {	220
204	val vis2 = new GraphvizVisualiser	221	val representation = solution.representation.get(interpretationIndex)
205	val dot = vis2.visualiseConcretization(representation)	222	if(representation instanceof PartialInterpretation) {
206	dot.writeToFile(outputWorkspaceForRun,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».png''')	223	val vis1 = new PartialInterpretation2Gml
		224	val gml = vis1.transform(representation)
		225	outputWorkspaceForRun.writeText('''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».gml''',gml)
		226	if(representation.newElements.size + representation.problem.elements.size < 150) {
		227	val vis2 = new GraphvizVisualiser
		228	val dot = vis2.visualiseConcretization(representation)
		229	dot.writeToFile(outputWorkspaceForRun,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».png''')
		230	}
207	}	231	}
		232	monitor.worked(100)
208	}	233	}
209	monitor.worked(100)	234	} else {
		235	monitor.worked(solverConfig.solutionScope.numberOfRequiredSolution*100)
210	}	236	}
211	} else {	237	solutionVisualisationTime = System.nanoTime - solutionVisualisationTime
212	monitor.worked(solverConfig.solutionScope.numberOfRequiredSolution*100)	238
		239	// 8.2 Statistics
		240	val statistics = new LinkedHashMap
		241	statistics.put("Task",(task.eContainer as ConfigurationScript).commands.indexOf(task)+1)
		242	statistics.put("Run",run)
		243	statistics.put("Result",solution.class.simpleName)
		244	statistics.put("Domain to logic transformation time",domain2LogicTransformationTime/1000000)
		245	statistics.put("Logic to solver transformation time",solution.statistics.transformationTime)
		246	statistics.put("Solver time",solution.statistics.solverTime)
		247	statistics.put("Postprocessing time",solutionVisualisationTime)
		248	for(entry: solution.statistics.entries) {
		249	statistics.put(entry.name,statisticsUtil.readValue(entry))
		250	}
		251	console.addStatistics(statistics)
213	}	252	}
214	solutionVisualisationTime = System.nanoTime - solutionVisualisationTime
215		253
216	// 8.2 Statistics
217	val statistics = new LinkedHashMap
218	statistics.put("Task",(task.eContainer as ConfigurationScript).commands.indexOf(task)+1)
219	statistics.put("Run",run)
220	statistics.put("Result",solution.class.simpleName)
221	statistics.put("Domain to logic transformation time",domain2LogicTransformationTime/1000000)
222	statistics.put("Logic to solver transformation time",solution.statistics.transformationTime)
223	statistics.put("Solver time",solution.statistics.solverTime)
224	statistics.put("Postprocessing time",solutionVisualisationTime)
225	for(entry: solution.statistics.entries) {
226	statistics.put(entry.name,statisticsUtil.readValue(entry))
227	}
228	console.addStatistics(statistics)
229	}	254	}
230	console.flushStatistics	255	console.flushStatistics
231	console.writeMessage("Model generation finished")	256	console.writeMessage("Model generation finished")