From 3f5aaab5025b8eb243f414b1c789085327df04f4 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Wed, 20 Mar 2019 16:09:09 +0100 Subject: Fault tree transformation for partial models WIP --- .../ui/handler/ReliabilityAnalysisHandler.xtend | 128 +++++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.ui/src/hu/bme/mit/inf/dslreasoner/faulttree/ui/handler/ReliabilityAnalysisHandler.xtend (limited to 'Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.ui/src/hu/bme/mit/inf/dslreasoner/faulttree/ui/handler/ReliabilityAnalysisHandler.xtend') diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.ui/src/hu/bme/mit/inf/dslreasoner/faulttree/ui/handler/ReliabilityAnalysisHandler.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.ui/src/hu/bme/mit/inf/dslreasoner/faulttree/ui/handler/ReliabilityAnalysisHandler.xtend new file mode 100644 index 00000000..5fa89148 --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.ui/src/hu/bme/mit/inf/dslreasoner/faulttree/ui/handler/ReliabilityAnalysisHandler.xtend @@ -0,0 +1,128 @@ +package hu.bme.mit.inf.dslreasoner.faulttree.ui.handler + +import hu.bme.mit.inf.dslreasoner.application.execution.EclipseBasedProgressMonitor +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.CftModel +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.TransformationDefinition +import hu.bme.mit.inf.dslreasoner.faulttree.transformation.cft2ft.Cft2FtTransformation +import hu.bme.mit.inf.dslreasoner.faulttree.transformation.ecore2cft.Ecore2CftTransformation +import hu.bme.mit.inf.dslreasoner.faulttree.transformation.solver.FtAnalysisObjective +import hu.bme.mit.inf.dslreasoner.faulttree.transformation.solver.ReliabilityResult +import hu.bme.mit.inf.dslreasoner.faulttree.transformation.solver.StormDftConfiguration +import hu.bme.mit.inf.dslreasoner.faulttree.transformation.solver.StormDftSolver +import hu.bme.mit.inf.dslreasoner.logic.model.builder.DocumentationLevel +import hu.bme.mit.inf.dslreasoner.workspace.ProjectWorkspace +import org.eclipse.core.commands.AbstractHandler +import org.eclipse.core.commands.ExecutionEvent +import org.eclipse.core.commands.ExecutionException +import org.eclipse.core.resources.IFile +import org.eclipse.core.resources.IProject +import org.eclipse.core.resources.IResource +import org.eclipse.core.runtime.IProgressMonitor +import org.eclipse.core.runtime.NullProgressMonitor +import org.eclipse.emf.common.util.URI +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.resource.ResourceSet +import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl +import org.eclipse.swt.widgets.MessageBox +import org.eclipse.ui.PlatformUI +import org.eclipse.ui.handlers.HandlerUtil +import org.eclipse.viatra.query.runtime.api.AdvancedViatraQueryEngine +import org.eclipse.viatra.query.runtime.emf.EMFScope + +class ReliabilityAnalysisHandler extends AbstractHandler { + + override execute(ExecutionEvent event) throws ExecutionException { + val selection = HandlerUtil.getCurrentStructuredSelection(event) + val resourceSet = new ResourceSetImpl + val iterator = selection.iterator + var IProject targetProject = null + var Resource targetResource = null + var TransformationDefinition transformationDefinition = null + while (iterator.hasNext) { + val selectedElement = iterator.next + if (selectedElement instanceof IFile) { + val resource = tryLoadResource(resourceSet, selectedElement) + if (resource !== null && !resource.contents.empty) { + val rootElement = resource.contents.head + if (rootElement instanceof CftModel) { + if (rootElement.transformationDefinitions.empty) { + throw new IllegalArgumentException("Selected cft file is not a transformation definition.") + } + if (transformationDefinition !== null) { + throw new IllegalArgumentException( + "Only a single transformation definition may be selected.") + } + transformationDefinition = rootElement.transformationDefinitions.head + } else { + if (targetResource !== null) { + throw new IllegalArgumentException("Only a single architecture model may be selected.") + } + targetResource = resource + targetProject = selectedElement.project + } + } + } + } + if (targetResource === null || targetResource === null) { + throw new IllegalArgumentException( + "A transformation definition and an architecture model must be selected.") + } + runAnalysis(transformationDefinition, targetResource, targetProject, new NullProgressMonitor) + null + } + + private static def tryLoadResource(ResourceSet resourceSet, IFile file) { + val fullPath = file.fullPath.toString + val uri = URI.createPlatformResourceURI(fullPath, true) + try { + resourceSet.getResource(uri, true) + } catch (RuntimeException e) { + null + } + } + + private def runAnalysis(TransformationDefinition transformationDefinition, Resource resource, IProject project, + IProgressMonitor monitor) { + val workspace = createWorkspace(project, monitor) + val cft = createComponentFaultTree(transformationDefinition, resource) + workspace.writeModel(cft, "cft.xmi") + val cft2ft = new Cft2FtTransformation + val ft = cft2ft.createFaultTree(cft) + workspace.writeModel(ft, "ft.xmi") + val solver = new StormDftSolver + val config = new StormDftConfiguration + config.progressMonitor = new EclipseBasedProgressMonitor(monitor) + config.documentationLevel = DocumentationLevel.NORMAL + config.objective = FtAnalysisObjective.MTTF + val result = solver.solve(ft, config, workspace) + displayResult(result) + } + + private def createWorkspace(IProject project, IProgressMonitor monitor) { + val folder = project.getFolder("debug") + if (!folder.exists) { + folder.create(IResource.NONE, true, monitor) + } + val path = folder.fullPath.toString + val uri = URI.createPlatformResourceURI(path, true) + val workspace = new ProjectWorkspace(uri.toString, "") + workspace.initAndClear + workspace + } + + private def createComponentFaultTree(TransformationDefinition transformationDefinition, Resource resource) { + val queryEngine = AdvancedViatraQueryEngine.createUnmanagedEngine(new EMFScope(resource)) + try { + val ecore2cft = new Ecore2CftTransformation(transformationDefinition, queryEngine) + ecore2cft.createComponentFaultTree + } finally { + queryEngine.dispose + } + } + + private def displayResult(ReliabilityResult result) { + val messageBox = new MessageBox(PlatformUI.workbench.activeWorkbenchWindow.shell) + messageBox.message = result.toString + messageBox.open + } +} -- cgit v1.2.3-70-g09d2