1 files changed, 130 insertions, 122 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 33f59413..9ffd33c5 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
@@ -20,6 +20,8 @@ import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualisatio
 import hu.bme.mit.inf.dslreasoner.workspace.ProjectWorkspace
 import java.util.Optional
 import org.eclipse.emf.common.util.URI
+import org.eclipse.core.runtime.IProgressMonitor
+import hu.bme.mit.inf.dslreasoner.logic.model.builder.SolverProgressMonitor
 class GenerationTaskExecutor {
        val metamodelLoader = new MetamodelLoader
@@ -33,10 +35,11 @@ class GenerationTaskExecutor {
        
        def executeGenerationTask(
                GenerationTask task,
-                ScriptExecutor scriptExecutor)
+                ScriptExecutor scriptExecutor,
+                IProgressMonitor monitor)
        {
+                monitor.subTask('''Collecting all resources''')
                // 1. Load all resources
-                
                val metamodelSpecification = scriptExecutor.getMetamodelSpecification(task.metamodel)
                val patternSpecification = scriptExecutor.getPatternSpecification(task.patterns)
                val partialmodelSpecification = scriptExecutor.getPartialModelSpecification(task.partialModel)
@@ -52,153 +55,158 @@ class GenerationTaskExecutor {
                val documentationLevel = scriptExecutor.getDocumentation(configSpecification)
                val runtieLimit = scriptExecutor.getRuntimeLimit(configSpecification)
                val memoryLimit = scriptExecutor.getMemoryLimit(configSpecification)
-                // 2. create console
-                
-                val reasonerWorkspace = if(debugFolder!== null) {
-                        new ProjectWorkspace(debugFolder.path,"")
-                } else {
-                        new NullWorkspace
-                }
-                reasonerWorkspace.initAndClear
-                val outputWorkspace = if(outputFolder !== null) {
-                        new ProjectWorkspace(outputFolder.path,"")
-                } else {
-                        new NullWorkspace
-                }
-                outputWorkspace.initAndClear
                
+                // 2. create console
                val console = new ScriptConsole(true,true,
                        if(messageFile!==null) URI.createURI(messageFile.path) else null,
                        if(debugFolder!==null) URI.createURI('''«debugFolder.path»/errors.txt''') else null,
                        if(statisticsFile!==null) URI.createURI(statisticsFile.path) else null
                )
                
-                // 3. interpret all specification to a description
+                try {
-                val metamodelDescriptor = if(metamodelSpecification !== null) {
+                        val reasonerWorkspace = if(debugFolder!== null) {
-                        metamodelLoader.loadMetamodel(metamodelSpecification)
+                                new ProjectWorkspace(debugFolder.path,"")
-                } else {
-                        console.writeError('''Error during the loading of the metamodel: No metamodel specified!''')
-                        throw new IllegalArgumentException('''No metamodel is specified!''')
-                }
-                val queryDescriptor = if(patternSpecification !== null) {
-                         this.queryLoader.loadQueries(patternSpecification)
-                } else {
-                        null
-                }
-                val partialModelDescriptor = if(partialmodelSpecification !== null) {
-                        this.modelLoader.loadModel(partialmodelSpecification,scriptExecutor)
-                } else {
-                        null
-                }
-                
-                // 4. translate all description to a logic problem
-                val Ecore2Logic ecore2Logic = new Ecore2Logic
-                val Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic)
-                val Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic)
-                val InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic
-                
-                var modelGeneration = ecore2Logic.transformMetamodel(metamodelDescriptor,new Ecore2LogicConfiguration())
-                var problem = modelGeneration.output
-                if(partialModelDescriptor !== null) {
-                        problem = instanceModel2Logic.transform(
-                                modelGeneration,
-                                partialModelDescriptor
-                        ).output
-                }
-                if(queryDescriptor !== null){
-                        problem = viatra2Logic.transformQueries(
-                                queryDescriptor.key,
-                                modelGeneration,
-                                new Viatra2LogicConfiguration
-                        ).output
-                }
-                if(documentationLevel.atLeastNormal) {
-                        reasonerWorkspace.writeModel(problem,"generation.logicproblem")
-                }
-                
-                // 5. create a solver and a configuration
-                // 5.1 initialize
-                val solver = solverLoader.loadSolver(task.solver,configurationMap)
-                val solverConfig = solverLoader.loadSolverConfig(task.solver,configurationMap,console)
-                
-                
-                // 5.2 set values that defined directly 
-                solverConfig.solutionScope = new SolutionScope => [
-                        it.numberOfRequiredSolution = if(task.numberSpecified) {
-                                task.number
                        } else {
-                                1
+                                new NullWorkspace
                        }
-                ]
+                        reasonerWorkspace.init
-                solverConfig.typeScopes = scopeLoader.loadScope(
+                        val outputWorkspace = if(outputFolder !== null) {
-                        scopeSpecification,
+                                new ProjectWorkspace(outputFolder.path,"")
-                        problem,
+                        } else {
-                        ecore2Logic,
+                                new NullWorkspace
-                        modelGeneration.trace
+                        }
-                )
+                        outputWorkspace.init
-                
-                // 5.3 set resource limits
-                documentationLevel.ifPresent[solverConfig.documentationLevel = it]
-                runtieLimit.ifPresent[solverConfig.runtimeLimit = it]
-                memoryLimit.ifPresent[solverConfig.memoryLimit = 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 }
-                console.writeMessage("Model generation started")
-                
-                for(run : 1..runs) {
                        
-                        // 6.2 For each run, the configuration and the workspace is adjusted
+                        // 3. interpret all specification to a description
-                        solverLoader.setRunIndex(solverConfig,configurationMap,run,console)
+                        val metamodelDescriptor = if(metamodelSpecification !== null) {
-                        val reasonerWorkspaceForRun = if(runs > 1) {
+                                metamodelLoader.loadMetamodel(metamodelSpecification)
-                                reasonerWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]
+                        } else {
+                                console.writeError('''Error during the loading of the metamodel: No metamodel specified!''')
+                                throw new IllegalArgumentException('''No metamodel is specified!''')
+                        }
+                        val queryDescriptor = if(patternSpecification !== null) {
+                                 this.queryLoader.loadQueries(patternSpecification)
                        } else {
-                                reasonerWorkspace
+                                null
                        }
+                        val partialModelDescriptor = if(partialmodelSpecification !== null) {
+                                this.modelLoader.loadModel(partialmodelSpecification,scriptExecutor)
+                        } else {
+                                null
+                        }
+                        monitor.worked(50)
                        
+                        // 4. translate all description to a logic problem
+                        monitor.subTask('''Translating all resources to logic''')
+                        val Ecore2Logic ecore2Logic = new Ecore2Logic
+                        val Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic)
+                        val Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic)
+                        val InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic
                        
-                        // 7. Solver call
+                        var modelGeneration = ecore2Logic.transformMetamodel(metamodelDescriptor,new Ecore2LogicConfiguration())
+                        var problem = modelGeneration.output
+                        if(partialModelDescriptor !== null) {
+                                problem = instanceModel2Logic.transform(
+                                        modelGeneration,
+                                        partialModelDescriptor
+                                ).output
+                        }
+                        if(queryDescriptor !== null){
+                                problem = viatra2Logic.transformQueries(
+                                        queryDescriptor.key,
+                                        modelGeneration,
+                                        new Viatra2LogicConfiguration
+                                ).output
+                        }
+                        if(documentationLevel.atLeastNormal) {
+                                reasonerWorkspace.writeModel(problem,"generation.logicproblem")
+                        }
                        
-                        val solution = solver.solve(problem,solverConfig,reasonerWorkspaceForRun)
+                        // 5. create a solver and a configuration
+                        // 5.1 initialize
+                        val solver = solverLoader.loadSolver(task.solver,configurationMap)
+                        val solverConfig = solverLoader.loadSolverConfig(task.solver,configurationMap,console)
                        
-                        console.writeMessage(solution.soutionDescription.toString)
                        
-                        //  8. Solution processing
+                        // 5.2 set values that defined directly 
-                        if(solution instanceof ModelResult) {
+                        solverConfig.solutionScope = new SolutionScope => [
-                                // 
+                                it.numberOfRequiredSolution = if(task.numberSpecified) {
-                                val interpretations = solver.getInterpretations(solution)
+                                        task.number
-                                val outputWorkspaceForRun = if(runs > 1) {
-                                        outputWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]
                                } else {
-                                        outputWorkspace
+                                        1
                                }
+                        ]
+                        solverConfig.typeScopes = scopeLoader.loadScope(
+                                scopeSpecification,
+                                problem,
+                                ecore2Logic,
+                                modelGeneration.trace
+                        )
+                        
+                        // 5.3 set resource limits
+                        documentationLevel.ifPresent[solverConfig.documentationLevel = it]
+                        runtieLimit.ifPresent[solverConfig.runtimeLimit = it]
+                        memoryLimit.ifPresent[solverConfig.memoryLimit = 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
+                                solverLoader.setRunIndex(solverConfig,configurationMap,run,console)
+                                solverConfig.progressMonitor = new EclipseProgressMonitor(monitor)
+                                val reasonerWorkspaceForRun = if(runs > 1) {
+                                        reasonerWorkspace.subWorkspace('''run«run»''',"") => [init]
+                                } else {
+                                        reasonerWorkspace
+                                }
+                                
+                                // 7. Solver call
+                                val solution = solver.solve(problem,solverConfig,reasonerWorkspaceForRun)
+                                console.writeMessage(solution.soutionDescription.toString)
                                
-                                for(interpretationIndex : 0..<interpretations.size) {
+                                //  8. Solution processing
-                                        val interpretation = interpretations.get(interpretationIndex)
+                                if(solution instanceof ModelResult) {
-                                        val model = logic2Ecore.transformInterpretation(interpretation,modelGeneration.trace)
+                                        val interpretations = solver.getInterpretations(solution)
-                                        outputWorkspaceForRun.writeModel(model,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex».xmi''')
+                                        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»/«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».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 GraphvizVisualisation
+                                                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»''')
+                                                        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 GraphvizVisualisation
+                                                                val dot = vis2.visualiseConcretization(representation)
+                                                                dot.writeToFile(outputWorkspaceForRun,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1»''')
+                                                        }
                                                }
+                                                monitor.worked(100)
                                        }
+                                } else {
+                                        monitor.worked(solverConfig.solutionScope.numberOfRequiredSolution*100)
                                }
                                
-                                for(representation : solution.representation) {
-                                        
-                                }
                        }
-                        
+                        console.writeMessage("Model generation finished")
+                } catch(Exception e) {
+                        console.writeError('''Error occured: «e.message»''')
                }
-                console.writeMessage("Model generation finished")
        }
        
        private def dispatch soutionDescription(InconsistencyResult s) {

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 33f59413..9ffd33c5 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
@@ -20,6 +20,8 @@ import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualisatio
20	import hu.bme.mit.inf.dslreasoner.workspace.ProjectWorkspace	20	import hu.bme.mit.inf.dslreasoner.workspace.ProjectWorkspace
21	import java.util.Optional	21	import java.util.Optional
22	import org.eclipse.emf.common.util.URI	22	import org.eclipse.emf.common.util.URI
		23	import org.eclipse.core.runtime.IProgressMonitor
		24	import hu.bme.mit.inf.dslreasoner.logic.model.builder.SolverProgressMonitor
23		25
24	class GenerationTaskExecutor {	26	class GenerationTaskExecutor {
25	val metamodelLoader = new MetamodelLoader	27	val metamodelLoader = new MetamodelLoader
@@ -33,10 +35,11 @@ class GenerationTaskExecutor {
33		35
34	def executeGenerationTask(	36	def executeGenerationTask(
35	GenerationTask task,	37	GenerationTask task,
36	ScriptExecutor scriptExecutor)	38	ScriptExecutor scriptExecutor,
		39	IProgressMonitor monitor)
37	{	40	{
		41	monitor.subTask('''Collecting all resources''')
38	// 1. Load all resources	42	// 1. Load all resources
39
40	val metamodelSpecification = scriptExecutor.getMetamodelSpecification(task.metamodel)	43	val metamodelSpecification = scriptExecutor.getMetamodelSpecification(task.metamodel)
41	val patternSpecification = scriptExecutor.getPatternSpecification(task.patterns)	44	val patternSpecification = scriptExecutor.getPatternSpecification(task.patterns)
42	val partialmodelSpecification = scriptExecutor.getPartialModelSpecification(task.partialModel)	45	val partialmodelSpecification = scriptExecutor.getPartialModelSpecification(task.partialModel)
@@ -52,153 +55,158 @@ class GenerationTaskExecutor {
52	val documentationLevel = scriptExecutor.getDocumentation(configSpecification)	55	val documentationLevel = scriptExecutor.getDocumentation(configSpecification)
53	val runtieLimit = scriptExecutor.getRuntimeLimit(configSpecification)	56	val runtieLimit = scriptExecutor.getRuntimeLimit(configSpecification)
54	val memoryLimit = scriptExecutor.getMemoryLimit(configSpecification)	57	val memoryLimit = scriptExecutor.getMemoryLimit(configSpecification)
55	// 2. create console
56
57	val reasonerWorkspace = if(debugFolder!== null) {
58	new ProjectWorkspace(debugFolder.path,"")
59	} else {
60	new NullWorkspace
61	}
62	reasonerWorkspace.initAndClear
63	val outputWorkspace = if(outputFolder !== null) {
64	new ProjectWorkspace(outputFolder.path,"")
65	} else {
66	new NullWorkspace
67	}
68	outputWorkspace.initAndClear
69		58
		59	// 2. create console
70	val console = new ScriptConsole(true,true,	60	val console = new ScriptConsole(true,true,
71	if(messageFile!==null) URI.createURI(messageFile.path) else null,	61	if(messageFile!==null) URI.createURI(messageFile.path) else null,
72	if(debugFolder!==null) URI.createURI('''«debugFolder.path»/errors.txt''') else null,	62	if(debugFolder!==null) URI.createURI('''«debugFolder.path»/errors.txt''') else null,
73	if(statisticsFile!==null) URI.createURI(statisticsFile.path) else null	63	if(statisticsFile!==null) URI.createURI(statisticsFile.path) else null
74	)	64	)
75		65
76	// 3. interpret all specification to a description	66	try {
77	val metamodelDescriptor = if(metamodelSpecification !== null) {	67	val reasonerWorkspace = if(debugFolder!== null) {
78	metamodelLoader.loadMetamodel(metamodelSpecification)	68	new ProjectWorkspace(debugFolder.path,"")
79	} else {
80	console.writeError('''Error during the loading of the metamodel: No metamodel specified!''')
81	throw new IllegalArgumentException('''No metamodel is specified!''')
82	}
83	val queryDescriptor = if(patternSpecification !== null) {
84	this.queryLoader.loadQueries(patternSpecification)
85	} else {
86	null
87	}
88	val partialModelDescriptor = if(partialmodelSpecification !== null) {
89	this.modelLoader.loadModel(partialmodelSpecification,scriptExecutor)
90	} else {
91	null
92	}
93
94	// 4. translate all description to a logic problem
95	val Ecore2Logic ecore2Logic = new Ecore2Logic
96	val Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic)
97	val Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic)
98	val InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic
99
100	var modelGeneration = ecore2Logic.transformMetamodel(metamodelDescriptor,new Ecore2LogicConfiguration())
101	var problem = modelGeneration.output
102	if(partialModelDescriptor !== null) {
103	problem = instanceModel2Logic.transform(
104	modelGeneration,
105	partialModelDescriptor
106	).output
107	}
108	if(queryDescriptor !== null){
109	problem = viatra2Logic.transformQueries(
110	queryDescriptor.key,
111	modelGeneration,
112	new Viatra2LogicConfiguration
113	).output
114	}
115	if(documentationLevel.atLeastNormal) {
116	reasonerWorkspace.writeModel(problem,"generation.logicproblem")
117	}
118
119	// 5. create a solver and a configuration
120	// 5.1 initialize
121	val solver = solverLoader.loadSolver(task.solver,configurationMap)
122	val solverConfig = solverLoader.loadSolverConfig(task.solver,configurationMap,console)
123
124
125	// 5.2 set values that defined directly
126	solverConfig.solutionScope = new SolutionScope => [
127	it.numberOfRequiredSolution = if(task.numberSpecified) {
128	task.number
129	} else {	69	} else {
130	1	70	new NullWorkspace
131	}	71	}
132	]	72	reasonerWorkspace.init
133	solverConfig.typeScopes = scopeLoader.loadScope(	73	val outputWorkspace = if(outputFolder !== null) {
134	scopeSpecification,	74	new ProjectWorkspace(outputFolder.path,"")
135	problem,	75	} else {
136	ecore2Logic,	76	new NullWorkspace
137	modelGeneration.trace	77	}
138	)	78	outputWorkspace.init
139
140	// 5.3 set resource limits
141	documentationLevel.ifPresent[solverConfig.documentationLevel = it]
142	runtieLimit.ifPresent[solverConfig.runtimeLimit = it]
143	memoryLimit.ifPresent[solverConfig.memoryLimit = it]
144
145	// 6. execute the solver on the problem with the configuration
146	// 6.1 calculating the runs
147	val runs = if(task.runSpecified) { task.runs } else { 1 }
148	console.writeMessage("Model generation started")
149
150	for(run : 1..runs) {
151		79
152	// 6.2 For each run, the configuration and the workspace is adjusted	80	// 3. interpret all specification to a description
153	solverLoader.setRunIndex(solverConfig,configurationMap,run,console)	81	val metamodelDescriptor = if(metamodelSpecification !== null) {
154	val reasonerWorkspaceForRun = if(runs > 1) {	82	metamodelLoader.loadMetamodel(metamodelSpecification)
155	reasonerWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]	83	} else {
		84	console.writeError('''Error during the loading of the metamodel: No metamodel specified!''')
		85	throw new IllegalArgumentException('''No metamodel is specified!''')
		86	}
		87	val queryDescriptor = if(patternSpecification !== null) {
		88	this.queryLoader.loadQueries(patternSpecification)
156	} else {	89	} else {
157	reasonerWorkspace	90	null
158	}	91	}
		92	val partialModelDescriptor = if(partialmodelSpecification !== null) {
		93	this.modelLoader.loadModel(partialmodelSpecification,scriptExecutor)
		94	} else {
		95	null
		96	}
		97	monitor.worked(50)
159		98
		99	// 4. translate all description to a logic problem
		100	monitor.subTask('''Translating all resources to logic''')
		101	val Ecore2Logic ecore2Logic = new Ecore2Logic
		102	val Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic)
		103	val Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic)
		104	val InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic
160		105
161	// 7. Solver call	106	var modelGeneration = ecore2Logic.transformMetamodel(metamodelDescriptor,new Ecore2LogicConfiguration())
		107	var problem = modelGeneration.output
		108	if(partialModelDescriptor !== null) {
		109	problem = instanceModel2Logic.transform(
		110	modelGeneration,
		111	partialModelDescriptor
		112	).output
		113	}
		114	if(queryDescriptor !== null){
		115	problem = viatra2Logic.transformQueries(
		116	queryDescriptor.key,
		117	modelGeneration,
		118	new Viatra2LogicConfiguration
		119	).output
		120	}
		121	if(documentationLevel.atLeastNormal) {
		122	reasonerWorkspace.writeModel(problem,"generation.logicproblem")
		123	}
162		124
163	val solution = solver.solve(problem,solverConfig,reasonerWorkspaceForRun)	125	// 5. create a solver and a configuration
		126	// 5.1 initialize
		127	val solver = solverLoader.loadSolver(task.solver,configurationMap)
		128	val solverConfig = solverLoader.loadSolverConfig(task.solver,configurationMap,console)
164		129
165	console.writeMessage(solution.soutionDescription.toString)
166		130
167	// 8. Solution processing	131	// 5.2 set values that defined directly
168	if(solution instanceof ModelResult) {	132	solverConfig.solutionScope = new SolutionScope => [
169	//	133	it.numberOfRequiredSolution = if(task.numberSpecified) {
170	val interpretations = solver.getInterpretations(solution)	134	task.number
171	val outputWorkspaceForRun = if(runs > 1) {
172	outputWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]
173	} else {	135	} else {
174	outputWorkspace	136	1
175	}	137	}
		138	]
		139	solverConfig.typeScopes = scopeLoader.loadScope(
		140	scopeSpecification,
		141	problem,
		142	ecore2Logic,
		143	modelGeneration.trace
		144	)
		145
		146	// 5.3 set resource limits
		147	documentationLevel.ifPresent[solverConfig.documentationLevel = it]
		148	runtieLimit.ifPresent[solverConfig.runtimeLimit = it]
		149	memoryLimit.ifPresent[solverConfig.memoryLimit = it]
		150
		151	// 6. execute the solver on the problem with the configuration
		152	// 6.1 calculating the runs
		153	val runs = if(task.runSpecified) { task.runs } else { 1 }
		154	monitor.worked(50)
		155
		156	console.writeMessage("Model generation started")
		157	for(run : 1..runs) {
		158	monitor.subTask('''Solving problem«IF runs>0» «run»/«runs»«ENDIF»''')
		159
		160	// 6.2 For each run, the configuration and the workspace is adjusted
		161	solverLoader.setRunIndex(solverConfig,configurationMap,run,console)
		162	solverConfig.progressMonitor = new EclipseProgressMonitor(monitor)
		163	val reasonerWorkspaceForRun = if(runs > 1) {
		164	reasonerWorkspace.subWorkspace('''run«run»''',"") => [init]
		165	} else {
		166	reasonerWorkspace
		167	}
		168
		169	// 7. Solver call
		170	val solution = solver.solve(problem,solverConfig,reasonerWorkspaceForRun)
		171	console.writeMessage(solution.soutionDescription.toString)
176		172
177	for(interpretationIndex : 0..<interpretations.size) {	173	// 8. Solution processing
178	val interpretation = interpretations.get(interpretationIndex)	174	if(solution instanceof ModelResult) {
179	val model = logic2Ecore.transformInterpretation(interpretation,modelGeneration.trace)	175	val interpretations = solver.getInterpretations(solution)
180	outputWorkspaceForRun.writeModel(model,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex».xmi''')	176	val outputWorkspaceForRun = if(runs > 1) {
		177	outputWorkspace.subWorkspace('''run«run»''',"") => [initAndClear]
		178	} else {
		179	outputWorkspace
		180	}
181		181
182	val representation = solution.representation.get(interpretationIndex)	182	for(interpretationIndex : 0..<interpretations.size) {
183	if(representation instanceof PartialInterpretation) {	183	monitor.subTask('''Solving problem«IF runs>0» «run»/«runs»«ENDIF»: Visualising solution «interpretationIndex»/«interpretations.size»''')
184	val vis1 = new PartialInterpretation2Gml	184	val interpretation = interpretations.get(interpretationIndex)
185	val gml = vis1.transform(representation)	185	val model = logic2Ecore.transformInterpretation(interpretation,modelGeneration.trace)
186	outputWorkspaceForRun.writeText('''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex».gml''',gml)	186	outputWorkspaceForRun.writeModel(model,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».xmi''')
187	if(representation.newElements.size + representation.problem.elements.size < 150) {	187
188	val vis2 = new GraphvizVisualisation	188	val representation = solution.representation.get(interpretationIndex)
189	val dot = vis2.visualiseConcretization(representation)	189	if(representation instanceof PartialInterpretation) {
190	dot.writeToFile(outputWorkspaceForRun,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex»''')	190	val vis1 = new PartialInterpretation2Gml
		191	val gml = vis1.transform(representation)
		192	outputWorkspaceForRun.writeText('''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1».gml''',gml)
		193	if(representation.newElements.size + representation.problem.elements.size < 150) {
		194	val vis2 = new GraphvizVisualisation
		195	val dot = vis2.visualiseConcretization(representation)
		196	dot.writeToFile(outputWorkspaceForRun,'''model«IF runs>1»_«run»«ENDIF»_«interpretationIndex+1»''')
		197	}
191	}	198	}
		199	monitor.worked(100)
192	}	200	}
		201	} else {
		202	monitor.worked(solverConfig.solutionScope.numberOfRequiredSolution*100)
193	}	203	}
194		204
195	for(representation : solution.representation) {
196
197	}
198	}	205	}
199		206	console.writeMessage("Model generation finished")
		207	} catch(Exception e) {
		208	console.writeError('''Error occured: «e.message»''')
200	}	209	}
201	console.writeMessage("Model generation finished")
202	}	210	}
203		211
204	private def dispatch soutionDescription(InconsistencyResult s) {	212	private def dispatch soutionDescription(InconsistencyResult s) {