4 files changed, 338 insertions, 3 deletions

diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/Cft2FtTransformation.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/Cft2FtTransformation.xtend
index caaffc3c..a522654c 100644
--- a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/Cft2FtTransformation.xtend
+++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/Cft2FtTransformation.xtend
@@ -1,10 +1,24 @@
 package hu.bme.mit.inf.dslreasoner.faulttree.transformation.cft2ft
 
 import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.ComponentFaultTree
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.ConstantEvent
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.FtFactory
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.RandomEvent
 
 class Cft2FtTransformation {
         def createFaultTree(ComponentFaultTree componentFaultTree) {
-                // TODO
-                throw new UnsupportedOperationException()
+                val materializer = new EventMaterializer
+                val topEvent = materializer.getOrMaterialize(componentFaultTree.topEvent)
+                switch (topEvent) {
+                        ConstantEvent:
+                                FtFactory.eINSTANCE.createConstantModel => [
+                                        failed = topEvent.failed
+                                ]
+                        RandomEvent: {
+                                val builder = new FaultTreeBuilder
+                                builder.addTopLevel(topEvent)
+                                builder.faultTree
+                        }
+                }
         }
-}
\ No newline at end of file
+}
diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventCollection.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventCollection.xtend
new file mode 100644
index 00000000..102dc57e
--- /dev/null
+++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventCollection.xtend
@@ -0,0 +1,90 @@
+package hu.bme.mit.inf.dslreasoner.faulttree.transformation.cft2ft
+
+import com.google.common.collect.ImmutableSet
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.ConstantEvent
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.Event
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.RandomEvent
+import java.util.Set
+import org.eclipse.xtend.lib.annotations.Data
+
+@Data
+class EventCollection {
+        val int falseEventCount
+        val int trueEventCount
+        val Set<RandomEvent> randomEvents
+
+        def containsFalseEvent() {
+                falseEventCount >= 1
+        }
+
+        def containsTrueEvent() {
+                trueEventCount >= 1
+        }
+
+        def getVariableEventCount() {
+                randomEvents.size
+        }
+
+        def containsRandomEvent() {
+                variableEventCount >= 1
+        }
+
+        def getCount() {
+                falseEventCount + trueEventCount + variableEventCount
+        }
+
+        def isEmpty() {
+                !containsFalseEvent && !containsTrueEvent && !containsRandomEvent
+        }
+
+        def containsExactlyOneRandomEvent() {
+                !containsFalseEvent && !containsTrueEvent && variableEventCount == 1
+        }
+
+        def toSingleRandomEvent() {
+                if (!containsExactlyOneRandomEvent) {
+                        throw new IllegalStateException("Input collection is not a single random event")
+                }
+                randomEvents.head
+        }
+
+        static def builder() {
+                new Builder()
+        }
+
+        static class Builder {
+                var falseEventCount = 0
+                var trueEventCount = 0
+                val randomEventsBuilder = ImmutableSet.<RandomEvent>builder
+
+                private new() {
+                }
+
+                def add(Event event) {
+                        switch (event) {
+                                ConstantEvent:
+                                        if (event.failed) {
+                                                trueEventCount++
+                                        } else {
+                                                falseEventCount++
+                                        }
+                                RandomEvent:
+                                        randomEventsBuilder.add(event)
+                                default:
+                                        throw new IllegalArgumentException("Unknown event: " + event)
+                        }
+                        this
+                }
+
+                def addAll(EventCollection materializedEvens) {
+                        falseEventCount += materializedEvens.falseEventCount
+                        trueEventCount += materializedEvens.trueEventCount
+                        randomEventsBuilder.addAll(materializedEvens.randomEvents)
+                        this
+                }
+
+                def build() {
+                        new EventCollection(falseEventCount, trueEventCount, randomEventsBuilder.build)
+                }
+        }
+}
diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventMaterializer.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventMaterializer.xtend
new file mode 100644
index 00000000..85396e4d
--- /dev/null
+++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventMaterializer.xtend
@@ -0,0 +1,192 @@
+package hu.bme.mit.inf.dslreasoner.faulttree.transformation.cft2ft
+
+import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.AndGateDefinition
+import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.BasicEventDefinition
+import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.Component
+import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.EventDeclaration
+import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.GateDefinition
+import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.InputEvent
+import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.KOfMGateDefinition
+import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.OrGateDefinition
+import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.Output
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.ConstantEvent
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.Event
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.FtFactory
+import java.util.LinkedHashSet
+import java.util.Map
+import org.eclipse.emf.ecore.util.EcoreUtil
+import org.eclipse.xtend.lib.annotations.Data
+
+class EventMaterializer {
+        extension val FtFactory = FtFactory.eINSTANCE
+
+        val Map<EventKey<EventDeclaration>, Event> materializationCache = newHashMap
+        val Map<EventKey<InputEvent>, EventCollection> multipleInputCache = newHashMap
+        val ConstantEvent falseEvent
+        val ConstantEvent trueEvent
+        val path = new LinkedHashSet<EventKey<? extends EventDeclaration>>
+
+        new() {
+                falseEvent = createConstantEvent => [
+                        failed = false
+                ]
+                trueEvent = createConstantEvent => [
+                        failed = true
+                ]
+        }
+
+        def getOrMaterialize(Output output) {
+                getOrMaterialize(output.component, output.eventDeclaration)
+        }
+
+        def Event getOrMaterialize(Component component, EventDeclaration eventDeclaration) {
+                val eventKey = new EventKey(component, eventDeclaration)
+                pushEventKey(eventKey)
+                try {
+                        materializationCache.computeIfAbsent(eventKey)[materialize(it.component, it.event)]
+                } finally {
+                        popEventKey(eventKey)
+                }
+        }
+
+        protected def materialize(Component component, EventDeclaration eventDeclaration) {
+                val eventName = component.name + "_" + eventDeclaration.name
+                val event = switch (eventDeclaration) {
+                        InputEvent:
+                                return materializeConnectedEvent(component, eventDeclaration)
+                        BasicEventDefinition: {
+                                val basicEvent = createBasicEvent
+                                basicEvent.distribution = EcoreUtil.copy(eventDeclaration.distribution)
+                                basicEvent
+                        }
+                        GateDefinition: {
+                                val inputs = collectInputs(component, eventDeclaration)
+                                val gate = switch (eventDeclaration) {
+                                        AndGateDefinition:
+                                                if (inputs.containsFalseEvent) {
+                                                        return falseEvent
+                                                } else if (inputs.empty) {
+                                                        return trueEvent
+                                                } else if (inputs.containsExactlyOneRandomEvent) {
+                                                        return inputs.toSingleRandomEvent
+                                                } else {
+                                                        createAndGate
+                                                }
+                                        OrGateDefinition:
+                                                if (inputs.containsTrueEvent) {
+                                                        return trueEvent
+                                                } else if (inputs.empty) {
+                                                        return falseEvent
+                                                } else if (inputs.containsExactlyOneRandomEvent) {
+                                                        return inputs.toSingleRandomEvent
+                                                } else {
+                                                        createOrGate
+                                                }
+                                        KOfMGateDefinition: {
+                                                val requiredTrueInputs = inputs.count * eventDeclaration.k / eventDeclaration.m
+                                                val k = requiredTrueInputs - inputs.getTrueEventCount
+                                                val m = inputs.variableEventCount
+                                                if (k == 0) {
+                                                        return trueEvent
+                                                } else if (k > m) {
+                                                        return falseEvent
+                                                } else if (inputs.containsExactlyOneRandomEvent) {
+                                                        return inputs.toSingleRandomEvent
+                                                } else if (k == 1) {
+                                                        createOrGate
+                                                } else if (k == m) {
+                                                        createAndGate
+                                                } else {
+                                                        val kOfMGate = createKOfMGate
+                                                        kOfMGate.k = k
+                                                        kOfMGate
+                                                }
+                                        }
+                                        default:
+                                                throw new IllegalArgumentException("Unknown gate definition: " + eventDeclaration)
+                                }
+                                gate.inputEvents.addAll(inputs.getRandomEvents)
+                                gate
+                        }
+                        default:
+                                throw new IllegalArgumentException("Unknown event declaration: " + eventDeclaration)
+                }
+                event.name = eventName
+                event
+        }
+
+        protected def materializeConnectedEvent(Component component, InputEvent inputEvent) {
+                if (inputEvent.multiple) {
+                        throw new IllegalArgumentException('''Cannot materialize multiple nput «component.name»_«inputEvent.name»''')
+                }
+                val input = findInput(component, inputEvent)
+                val incomingConnections = input.incomingConnections
+                if (incomingConnections.size != 1) {
+                        throw new IllegalArgumentException('''Input «component.name»_«inputEvent.name» has «incomingConnections.size» connections instead of 1''')
+                }
+                val output = incomingConnections.head.output
+                getOrMaterialize(output.component, output.eventDeclaration)
+        }
+
+        protected def collectInputs(Component component, GateDefinition gateDefinition) {
+                val builder = EventCollection.builder
+                for (inputEventDeclaration : gateDefinition.inputEvents) {
+                        switch (inputEventDeclaration) {
+                                InputEvent case inputEventDeclaration.multiple: {
+                                        val materializedEvents = getOrMaterializeConnectedEvents(component, inputEventDeclaration)
+                                        builder.addAll(materializedEvents)
+                                }
+                                default:
+                                        builder.add(getOrMaterialize(component, inputEventDeclaration))
+                        }
+                }
+                builder.build
+        }
+
+        protected def getOrMaterializeConnectedEvents(Component component, InputEvent inputEvent) {
+                val inputKey = new EventKey(component, inputEvent)
+                pushEventKey(inputKey)
+                try {
+                         multipleInputCache.computeIfAbsent(inputKey)[materializeConnectedEvents(it.component, it.event)]
+                } finally {
+                        popEventKey(inputKey)
+                }
+        }
+
+        protected def materializeConnectedEvents(Component component, InputEvent inputEvent) {
+                val input = findInput(component, inputEvent)
+                val builder = EventCollection.builder
+                for (connection : input.incomingConnections) {
+                        val materializedEvent = getOrMaterialize(connection.output)
+                        builder.add(materializedEvent)
+                }
+                builder.build
+        }
+
+        protected def findInput(Component component, InputEvent inputEvent) {
+                val input = component.inputs.findFirst[it.inputEvent == inputEvent]
+                if (input === null) {
+                        throw new IllegalArgumentException('''No input «inputEvent» in component «component»''')
+                }
+                return input
+        }
+
+        private def pushEventKey(EventKey<? extends EventDeclaration> eventKey) {
+                if (!path.add(eventKey)) {
+                        throw new IllegalStateException(
+                        '''Circular dependency [«FOR ancestor : path»«ancestor», «ENDFOR»«eventKey»] detected''')
+                }
+        }
+
+        private def popEventKey(EventKey<? extends EventDeclaration> eventKey) {
+                path.remove(eventKey)
+        }
+
+        @Data
+        protected static class EventKey<T extends EventDeclaration> {
+                val Component component
+                val T event
+
+                override toString() '''«component.name»_«event.name»'''
+        }
+}
diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/FaultTreeBuilder.xtend b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/FaultTreeBuilder.xtend
new file mode 100644
index 00000000..0b0afea6
--- /dev/null
+++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/src/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/FaultTreeBuilder.xtend
@@ -0,0 +1,39 @@
+package hu.bme.mit.inf.dslreasoner.faulttree.transformation.cft2ft
+
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.FtFactory
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.Gate
+import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.RandomEvent
+import java.util.Collection
+import org.eclipse.xtend.lib.annotations.Accessors
+
+class FaultTreeBuilder {
+        @Accessors
+        val faultTree = FtFactory.eINSTANCE.createFaultTree
+
+        def addTopLevel(RandomEvent event) {
+                if (faultTree.topEvent !== null) {
+                        throw new IllegalStateException("Top event was already set")
+                }
+                add(event)
+                faultTree.topEvent = event
+        }
+
+        protected def void add(RandomEvent event) {
+                if (faultTree.eContainer == faultTree) {
+                        return
+                }
+                if (faultTree.eContainer !== null) {
+                        throw new IllegalStateException("Event is already in a different fault tree")
+                }
+                faultTree.events += event
+                if (event instanceof Gate) {
+                        addAll(event.inputEvents)
+                }
+        }
+
+        protected def addAll(Collection<RandomEvent> events) {
+                for (event : events) {
+                        add(event)
+                }
+        }
+}