From d90bedacaafe87e06fddaa05a6ff9b7b796e97e7 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Sat, 16 Feb 2019 00:43:11 +0100 Subject: Two-valued fault tree analyzer WIP --- .../cft2ft/.Cft2FtTransformation.xtendbin | Bin 2298 -> 2825 bytes .../cft2ft/.EventCollection.xtendbin | Bin 0 -> 7022 bytes .../cft2ft/.EventMaterializer.xtendbin | Bin 0 -> 11749 bytes .../cft2ft/.FaultTreeBuilder.xtendbin | Bin 0 -> 4029 bytes .../faulttree/transformation/cft2ft/.gitignore | 7 + .../cft2ft/Cft2FtTransformation.java | 43 +- .../transformation/cft2ft/EventCollection.java | 188 +++++++++ .../transformation/cft2ft/EventMaterializer.java | 456 +++++++++++++++++++++ .../transformation/cft2ft/FaultTreeBuilder.java | 57 +++ 9 files changed, 749 insertions(+), 2 deletions(-) create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.EventCollection.xtendbin create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.EventMaterializer.xtendbin create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.FaultTreeBuilder.xtendbin create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventCollection.java create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventMaterializer.java create mode 100644 Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/FaultTreeBuilder.java (limited to 'Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft') diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.Cft2FtTransformation.xtendbin b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.Cft2FtTransformation.xtendbin index 3e751774..20f1f4a7 100644 Binary files a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.Cft2FtTransformation.xtendbin and b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.Cft2FtTransformation.xtendbin differ diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.EventCollection.xtendbin b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.EventCollection.xtendbin new file mode 100644 index 00000000..54ba3d09 Binary files /dev/null and b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.EventCollection.xtendbin differ diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.EventMaterializer.xtendbin b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.EventMaterializer.xtendbin new file mode 100644 index 00000000..271c9cc0 Binary files /dev/null and b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.EventMaterializer.xtendbin differ diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.FaultTreeBuilder.xtendbin b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.FaultTreeBuilder.xtendbin new file mode 100644 index 00000000..db3a7e73 Binary files /dev/null and b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.FaultTreeBuilder.xtendbin differ diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.gitignore b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.gitignore index 70156b02..75154a4c 100644 --- a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.gitignore +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/.gitignore @@ -1 +1,8 @@ /.Cft2FtTransformation.java._trace +/.EventMaterializer.java._trace +/.MaterializedEvent.java._trace +/.CollectedInputs.java._trace +/.MaterializedEventCollection.java._trace +/.FaultTreeBuilder.java._trace +/.FaultModelBuilder.java._trace +/.EventCollection.java._trace diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/Cft2FtTransformation.java b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/Cft2FtTransformation.java index ae750806..e87b8865 100644 --- a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/Cft2FtTransformation.java +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/Cft2FtTransformation.java @@ -1,10 +1,49 @@ 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.ConstantModel; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.Event; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.FaultTree; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.FtFactory; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.RandomEvent; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.ReliabilityModel; +import hu.bme.mit.inf.dslreasoner.faulttree.transformation.cft2ft.EventMaterializer; +import hu.bme.mit.inf.dslreasoner.faulttree.transformation.cft2ft.FaultTreeBuilder; +import org.eclipse.xtext.xbase.lib.ObjectExtensions; +import org.eclipse.xtext.xbase.lib.Procedures.Procedure1; @SuppressWarnings("all") public class Cft2FtTransformation { - public void createFaultTree(final ComponentFaultTree componentFaultTree) { - throw new UnsupportedOperationException(); + public ReliabilityModel createFaultTree(final ComponentFaultTree componentFaultTree) { + ReliabilityModel _xblockexpression = null; + { + final EventMaterializer materializer = new EventMaterializer(); + final Event topEvent = materializer.getOrMaterialize(componentFaultTree.getTopEvent()); + ReliabilityModel _switchResult = null; + boolean _matched = false; + if (topEvent instanceof ConstantEvent) { + _matched=true; + ConstantModel _createConstantModel = FtFactory.eINSTANCE.createConstantModel(); + final Procedure1 _function = (ConstantModel it) -> { + it.setFailed(((ConstantEvent)topEvent).isFailed()); + }; + _switchResult = ObjectExtensions.operator_doubleArrow(_createConstantModel, _function); + } + if (!_matched) { + if (topEvent instanceof RandomEvent) { + _matched=true; + FaultTree _xblockexpression_1 = null; + { + final FaultTreeBuilder builder = new FaultTreeBuilder(); + builder.addTopLevel(((RandomEvent)topEvent)); + _xblockexpression_1 = builder.getFaultTree(); + } + _switchResult = _xblockexpression_1; + } + } + _xblockexpression = _switchResult; + } + return _xblockexpression; } } diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventCollection.java b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventCollection.java new file mode 100644 index 00000000..dceef9f8 --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventCollection.java @@ -0,0 +1,188 @@ +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; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.eclipse.xtext.xbase.lib.Pure; +import org.eclipse.xtext.xbase.lib.util.ToStringBuilder; + +@Data +@SuppressWarnings("all") +public class EventCollection { + public static class Builder { + private int falseEventCount = 0; + + private int trueEventCount = 0; + + private final ImmutableSet.Builder randomEventsBuilder = ImmutableSet.builder(); + + private Builder() { + } + + public EventCollection.Builder add(final Event event) { + EventCollection.Builder _xblockexpression = null; + { + boolean _matched = false; + if (event instanceof ConstantEvent) { + _matched=true; + boolean _isFailed = ((ConstantEvent)event).isFailed(); + if (_isFailed) { + this.trueEventCount++; + } else { + this.falseEventCount++; + } + } + if (!_matched) { + if (event instanceof RandomEvent) { + _matched=true; + this.randomEventsBuilder.add(((RandomEvent)event)); + } + } + if (!_matched) { + throw new IllegalArgumentException(("Unknown event: " + event)); + } + _xblockexpression = this; + } + return _xblockexpression; + } + + public EventCollection.Builder addAll(final EventCollection materializedEvens) { + EventCollection.Builder _xblockexpression = null; + { + int _falseEventCount = this.falseEventCount; + this.falseEventCount = (_falseEventCount + materializedEvens.falseEventCount); + int _trueEventCount = this.trueEventCount; + this.trueEventCount = (_trueEventCount + materializedEvens.trueEventCount); + this.randomEventsBuilder.addAll(materializedEvens.randomEvents); + _xblockexpression = this; + } + return _xblockexpression; + } + + public EventCollection build() { + ImmutableSet _build = this.randomEventsBuilder.build(); + return new EventCollection(this.falseEventCount, this.trueEventCount, _build); + } + } + + private final int falseEventCount; + + private final int trueEventCount; + + private final Set randomEvents; + + public boolean containsFalseEvent() { + return (this.falseEventCount >= 1); + } + + public boolean containsTrueEvent() { + return (this.trueEventCount >= 1); + } + + public int getVariableEventCount() { + return this.randomEvents.size(); + } + + public boolean containsRandomEvent() { + int _variableEventCount = this.getVariableEventCount(); + return (_variableEventCount >= 1); + } + + public int getCount() { + int _variableEventCount = this.getVariableEventCount(); + return ((this.falseEventCount + this.trueEventCount) + _variableEventCount); + } + + public boolean isEmpty() { + return (((!this.containsFalseEvent()) && (!this.containsTrueEvent())) && (!this.containsRandomEvent())); + } + + public boolean containsExactlyOneRandomEvent() { + return (((!this.containsFalseEvent()) && (!this.containsTrueEvent())) && (this.getVariableEventCount() == 1)); + } + + public RandomEvent toSingleRandomEvent() { + RandomEvent _xblockexpression = null; + { + boolean _containsExactlyOneRandomEvent = this.containsExactlyOneRandomEvent(); + boolean _not = (!_containsExactlyOneRandomEvent); + if (_not) { + throw new IllegalStateException("Input collection is not a single random event"); + } + _xblockexpression = IterableExtensions.head(this.randomEvents); + } + return _xblockexpression; + } + + public static EventCollection.Builder builder() { + return new EventCollection.Builder(); + } + + public EventCollection(final int falseEventCount, final int trueEventCount, final Set randomEvents) { + super(); + this.falseEventCount = falseEventCount; + this.trueEventCount = trueEventCount; + this.randomEvents = randomEvents; + } + + @Override + @Pure + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + this.falseEventCount; + result = prime * result + this.trueEventCount; + return prime * result + ((this.randomEvents== null) ? 0 : this.randomEvents.hashCode()); + } + + @Override + @Pure + public boolean equals(final Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + EventCollection other = (EventCollection) obj; + if (other.falseEventCount != this.falseEventCount) + return false; + if (other.trueEventCount != this.trueEventCount) + return false; + if (this.randomEvents == null) { + if (other.randomEvents != null) + return false; + } else if (!this.randomEvents.equals(other.randomEvents)) + return false; + return true; + } + + @Override + @Pure + public String toString() { + ToStringBuilder b = new ToStringBuilder(this); + b.add("falseEventCount", this.falseEventCount); + b.add("trueEventCount", this.trueEventCount); + b.add("randomEvents", this.randomEvents); + return b.toString(); + } + + @Pure + public int getFalseEventCount() { + return this.falseEventCount; + } + + @Pure + public int getTrueEventCount() { + return this.trueEventCount; + } + + @Pure + public Set getRandomEvents() { + return this.randomEvents; + } +} diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventMaterializer.java b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventMaterializer.java new file mode 100644 index 00000000..70481341 --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/EventMaterializer.java @@ -0,0 +1,456 @@ +package hu.bme.mit.inf.dslreasoner.faulttree.transformation.cft2ft; + +import com.google.common.base.Objects; +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.Connection; +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.Input; +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.AndGate; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.BasicEvent; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.ConstantEvent; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.Distribution; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.Event; +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.KOfMGate; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.OrGate; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.RandomEvent; +import hu.bme.mit.inf.dslreasoner.faulttree.transformation.cft2ft.EventCollection; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.function.Function; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.xtend.lib.annotations.Data; +import org.eclipse.xtend2.lib.StringConcatenation; +import org.eclipse.xtext.xbase.lib.CollectionLiterals; +import org.eclipse.xtext.xbase.lib.Extension; +import org.eclipse.xtext.xbase.lib.Functions.Function1; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.eclipse.xtext.xbase.lib.ObjectExtensions; +import org.eclipse.xtext.xbase.lib.Procedures.Procedure1; +import org.eclipse.xtext.xbase.lib.Pure; + +@SuppressWarnings("all") +public class EventMaterializer { + @Data + protected static class EventKey { + private final Component component; + + private final T event; + + @Override + public String toString() { + StringConcatenation _builder = new StringConcatenation(); + String _name = this.component.getName(); + _builder.append(_name); + _builder.append("_"); + String _name_1 = this.event.getName(); + _builder.append(_name_1); + return _builder.toString(); + } + + public EventKey(final Component component, final T event) { + super(); + this.component = component; + this.event = event; + } + + @Override + @Pure + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((this.component== null) ? 0 : this.component.hashCode()); + return prime * result + ((this.event== null) ? 0 : this.event.hashCode()); + } + + @Override + @Pure + public boolean equals(final Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + EventMaterializer.EventKey other = (EventMaterializer.EventKey) obj; + if (this.component == null) { + if (other.component != null) + return false; + } else if (!this.component.equals(other.component)) + return false; + if (this.event == null) { + if (other.event != null) + return false; + } else if (!this.event.equals(other.event)) + return false; + return true; + } + + @Pure + public Component getComponent() { + return this.component; + } + + @Pure + public T getEvent() { + return this.event; + } + } + + @Extension + private final FtFactory _ftFactory = FtFactory.eINSTANCE; + + private final Map, Event> materializationCache = CollectionLiterals., Event>newHashMap(); + + private final Map, EventCollection> multipleInputCache = CollectionLiterals., EventCollection>newHashMap(); + + private final ConstantEvent falseEvent; + + private final ConstantEvent trueEvent; + + private final LinkedHashSet> path = new LinkedHashSet>(); + + public EventMaterializer() { + ConstantEvent _createConstantEvent = this._ftFactory.createConstantEvent(); + final Procedure1 _function = (ConstantEvent it) -> { + it.setFailed(false); + }; + ConstantEvent _doubleArrow = ObjectExtensions.operator_doubleArrow(_createConstantEvent, _function); + this.falseEvent = _doubleArrow; + ConstantEvent _createConstantEvent_1 = this._ftFactory.createConstantEvent(); + final Procedure1 _function_1 = (ConstantEvent it) -> { + it.setFailed(true); + }; + ConstantEvent _doubleArrow_1 = ObjectExtensions.operator_doubleArrow(_createConstantEvent_1, _function_1); + this.trueEvent = _doubleArrow_1; + } + + public Event getOrMaterialize(final Output output) { + return this.getOrMaterialize(output.getComponent(), output.getEventDeclaration()); + } + + public Event getOrMaterialize(final Component component, final EventDeclaration eventDeclaration) { + Event _xblockexpression = null; + { + final EventMaterializer.EventKey eventKey = new EventMaterializer.EventKey(component, eventDeclaration); + this.pushEventKey(eventKey); + Event _xtrycatchfinallyexpression = null; + try { + final Function, Event> _function = (EventMaterializer.EventKey it) -> { + return this.materialize(it.component, it.event); + }; + _xtrycatchfinallyexpression = this.materializationCache.computeIfAbsent(eventKey, _function); + } finally { + this.popEventKey(eventKey); + } + _xblockexpression = _xtrycatchfinallyexpression; + } + return _xblockexpression; + } + + protected Event materialize(final Component component, final EventDeclaration eventDeclaration) { + RandomEvent _xblockexpression = null; + { + String _name = component.getName(); + String _plus = (_name + "_"); + String _name_1 = eventDeclaration.getName(); + final String eventName = (_plus + _name_1); + RandomEvent _switchResult = null; + boolean _matched = false; + if (eventDeclaration instanceof InputEvent) { + _matched=true; + return this.materializeConnectedEvent(component, ((InputEvent)eventDeclaration)); + } + if (!_matched) { + if (eventDeclaration instanceof BasicEventDefinition) { + _matched=true; + BasicEvent _xblockexpression_1 = null; + { + final BasicEvent basicEvent = this._ftFactory.createBasicEvent(); + basicEvent.setDistribution(EcoreUtil.copy(((BasicEventDefinition)eventDeclaration).getDistribution())); + _xblockexpression_1 = basicEvent; + } + _switchResult = _xblockexpression_1; + } + } + if (!_matched) { + if (eventDeclaration instanceof GateDefinition) { + _matched=true; + Gate _xblockexpression_1 = null; + { + final EventCollection inputs = this.collectInputs(component, ((GateDefinition)eventDeclaration)); + Gate _switchResult_1 = null; + boolean _matched_1 = false; + if (eventDeclaration instanceof AndGateDefinition) { + _matched_1=true; + AndGate _xifexpression = null; + boolean _containsFalseEvent = inputs.containsFalseEvent(); + if (_containsFalseEvent) { + return this.falseEvent; + } else { + AndGate _xifexpression_1 = null; + boolean _isEmpty = inputs.isEmpty(); + if (_isEmpty) { + return this.trueEvent; + } else { + AndGate _xifexpression_2 = null; + boolean _containsExactlyOneRandomEvent = inputs.containsExactlyOneRandomEvent(); + if (_containsExactlyOneRandomEvent) { + return inputs.toSingleRandomEvent(); + } else { + _xifexpression_2 = this._ftFactory.createAndGate(); + } + _xifexpression_1 = _xifexpression_2; + } + _xifexpression = _xifexpression_1; + } + _switchResult_1 = _xifexpression; + } + if (!_matched_1) { + if (eventDeclaration instanceof OrGateDefinition) { + _matched_1=true; + OrGate _xifexpression = null; + boolean _containsTrueEvent = inputs.containsTrueEvent(); + if (_containsTrueEvent) { + return this.trueEvent; + } else { + OrGate _xifexpression_1 = null; + boolean _isEmpty = inputs.isEmpty(); + if (_isEmpty) { + return this.falseEvent; + } else { + OrGate _xifexpression_2 = null; + boolean _containsExactlyOneRandomEvent = inputs.containsExactlyOneRandomEvent(); + if (_containsExactlyOneRandomEvent) { + return inputs.toSingleRandomEvent(); + } else { + _xifexpression_2 = this._ftFactory.createOrGate(); + } + _xifexpression_1 = _xifexpression_2; + } + _xifexpression = _xifexpression_1; + } + _switchResult_1 = _xifexpression; + } + } + if (!_matched_1) { + if (eventDeclaration instanceof KOfMGateDefinition) { + _matched_1=true; + Gate _xblockexpression_2 = null; + { + int _count = inputs.getCount(); + int _k = ((KOfMGateDefinition)eventDeclaration).getK(); + int _multiply = (_count * _k); + int _m = ((KOfMGateDefinition)eventDeclaration).getM(); + final int requiredTrueInputs = (_multiply / _m); + int _trueEventCount = inputs.getTrueEventCount(); + final int k = (requiredTrueInputs - _trueEventCount); + final int m = inputs.getVariableEventCount(); + Gate _xifexpression = null; + if ((k == 0)) { + return this.trueEvent; + } else { + Gate _xifexpression_1 = null; + if ((k > m)) { + return this.falseEvent; + } else { + Gate _xifexpression_2 = null; + boolean _containsExactlyOneRandomEvent = inputs.containsExactlyOneRandomEvent(); + if (_containsExactlyOneRandomEvent) { + return inputs.toSingleRandomEvent(); + } else { + Gate _xifexpression_3 = null; + if ((k == 1)) { + _xifexpression_3 = this._ftFactory.createOrGate(); + } else { + Gate _xifexpression_4 = null; + if ((k == m)) { + _xifexpression_4 = this._ftFactory.createAndGate(); + } else { + KOfMGate _xblockexpression_3 = null; + { + final KOfMGate kOfMGate = this._ftFactory.createKOfMGate(); + kOfMGate.setK(k); + _xblockexpression_3 = kOfMGate; + } + _xifexpression_4 = _xblockexpression_3; + } + _xifexpression_3 = _xifexpression_4; + } + _xifexpression_2 = _xifexpression_3; + } + _xifexpression_1 = _xifexpression_2; + } + _xifexpression = _xifexpression_1; + } + _xblockexpression_2 = _xifexpression; + } + _switchResult_1 = _xblockexpression_2; + } + } + if (!_matched_1) { + throw new IllegalArgumentException(("Unknown gate definition: " + eventDeclaration)); + } + final Gate gate = _switchResult_1; + gate.getInputEvents().addAll(inputs.getRandomEvents()); + _xblockexpression_1 = gate; + } + _switchResult = _xblockexpression_1; + } + } + if (!_matched) { + throw new IllegalArgumentException(("Unknown event declaration: " + eventDeclaration)); + } + final RandomEvent event = _switchResult; + event.setName(eventName); + _xblockexpression = event; + } + return _xblockexpression; + } + + protected Event materializeConnectedEvent(final Component component, final InputEvent inputEvent) { + Event _xblockexpression = null; + { + boolean _isMultiple = inputEvent.isMultiple(); + if (_isMultiple) { + StringConcatenation _builder = new StringConcatenation(); + _builder.append("Cannot materialize multiple nput "); + String _name = component.getName(); + _builder.append(_name); + _builder.append("_"); + String _name_1 = inputEvent.getName(); + _builder.append(_name_1); + throw new IllegalArgumentException(_builder.toString()); + } + final Input input = this.findInput(component, inputEvent); + final EList incomingConnections = input.getIncomingConnections(); + int _size = incomingConnections.size(); + boolean _notEquals = (_size != 1); + if (_notEquals) { + StringConcatenation _builder_1 = new StringConcatenation(); + _builder_1.append("Input "); + String _name_2 = component.getName(); + _builder_1.append(_name_2); + _builder_1.append("_"); + String _name_3 = inputEvent.getName(); + _builder_1.append(_name_3); + _builder_1.append(" has "); + int _size_1 = incomingConnections.size(); + _builder_1.append(_size_1); + _builder_1.append(" connections instead of 1"); + throw new IllegalArgumentException(_builder_1.toString()); + } + final Output output = IterableExtensions.head(incomingConnections).getOutput(); + _xblockexpression = this.getOrMaterialize(output.getComponent(), output.getEventDeclaration()); + } + return _xblockexpression; + } + + protected EventCollection collectInputs(final Component component, final GateDefinition gateDefinition) { + EventCollection _xblockexpression = null; + { + final EventCollection.Builder builder = EventCollection.builder(); + EList _inputEvents = gateDefinition.getInputEvents(); + for (final EventDeclaration inputEventDeclaration : _inputEvents) { + boolean _matched = false; + if (inputEventDeclaration instanceof InputEvent) { + boolean _isMultiple = ((InputEvent)inputEventDeclaration).isMultiple(); + if (_isMultiple) { + _matched=true; + final EventCollection materializedEvents = this.getOrMaterializeConnectedEvents(component, ((InputEvent)inputEventDeclaration)); + builder.addAll(materializedEvents); + } + } + if (!_matched) { + builder.add(this.getOrMaterialize(component, inputEventDeclaration)); + } + } + _xblockexpression = builder.build(); + } + return _xblockexpression; + } + + protected EventCollection getOrMaterializeConnectedEvents(final Component component, final InputEvent inputEvent) { + EventCollection _xblockexpression = null; + { + final EventMaterializer.EventKey inputKey = new EventMaterializer.EventKey(component, inputEvent); + this.pushEventKey(inputKey); + EventCollection _xtrycatchfinallyexpression = null; + try { + final Function, EventCollection> _function = (EventMaterializer.EventKey it) -> { + return this.materializeConnectedEvents(it.component, it.event); + }; + _xtrycatchfinallyexpression = this.multipleInputCache.computeIfAbsent(inputKey, _function); + } finally { + this.popEventKey(inputKey); + } + _xblockexpression = _xtrycatchfinallyexpression; + } + return _xblockexpression; + } + + protected EventCollection materializeConnectedEvents(final Component component, final InputEvent inputEvent) { + EventCollection _xblockexpression = null; + { + final Input input = this.findInput(component, inputEvent); + final EventCollection.Builder builder = EventCollection.builder(); + EList _incomingConnections = input.getIncomingConnections(); + for (final Connection connection : _incomingConnections) { + { + final Event materializedEvent = this.getOrMaterialize(connection.getOutput()); + builder.add(materializedEvent); + } + } + _xblockexpression = builder.build(); + } + return _xblockexpression; + } + + protected Input findInput(final Component component, final InputEvent inputEvent) { + final Function1 _function = (Input it) -> { + InputEvent _inputEvent = it.getInputEvent(); + return Boolean.valueOf(Objects.equal(_inputEvent, inputEvent)); + }; + final Input input = IterableExtensions.findFirst(component.getInputs(), _function); + if ((input == null)) { + StringConcatenation _builder = new StringConcatenation(); + _builder.append("No input "); + _builder.append(inputEvent); + _builder.append(" in component "); + _builder.append(component); + throw new IllegalArgumentException(_builder.toString()); + } + return input; + } + + private void pushEventKey(final EventMaterializer.EventKey eventKey) { + boolean _add = this.path.add(eventKey); + boolean _not = (!_add); + if (_not) { + StringConcatenation _builder = new StringConcatenation(); + _builder.append("Circular dependency ["); + { + for(final EventMaterializer.EventKey ancestor : this.path) { + _builder.append(ancestor); + _builder.append(", "); + } + } + _builder.append(eventKey); + _builder.append("] detected"); + throw new IllegalStateException(_builder.toString()); + } + } + + private boolean popEventKey(final EventMaterializer.EventKey eventKey) { + return this.path.remove(eventKey); + } +} diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/FaultTreeBuilder.java b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/FaultTreeBuilder.java new file mode 100644 index 00000000..9b2dfd76 --- /dev/null +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.transformation/xtend-gen/hu/bme/mit/inf/dslreasoner/faulttree/transformation/cft2ft/FaultTreeBuilder.java @@ -0,0 +1,57 @@ +package hu.bme.mit.inf.dslreasoner.faulttree.transformation.cft2ft; + +import com.google.common.base.Objects; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.FaultTree; +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.emf.common.util.EList; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtend.lib.annotations.Accessors; +import org.eclipse.xtext.xbase.lib.Pure; + +@SuppressWarnings("all") +public class FaultTreeBuilder { + @Accessors + private final FaultTree faultTree = FtFactory.eINSTANCE.createFaultTree(); + + public void addTopLevel(final RandomEvent event) { + RandomEvent _topEvent = this.faultTree.getTopEvent(); + boolean _tripleNotEquals = (_topEvent != null); + if (_tripleNotEquals) { + throw new IllegalStateException("Top event was already set"); + } + this.add(event); + this.faultTree.setTopEvent(event); + } + + protected void add(final RandomEvent event) { + EObject _eContainer = this.faultTree.eContainer(); + boolean _equals = Objects.equal(_eContainer, this.faultTree); + if (_equals) { + return; + } + EObject _eContainer_1 = this.faultTree.eContainer(); + boolean _tripleNotEquals = (_eContainer_1 != null); + if (_tripleNotEquals) { + throw new IllegalStateException("Event is already in a different fault tree"); + } + EList _events = this.faultTree.getEvents(); + _events.add(event); + if ((event instanceof Gate)) { + this.addAll(((Gate)event).getInputEvents()); + } + } + + protected void addAll(final Collection events) { + for (final RandomEvent event : events) { + this.add(event); + } + } + + @Pure + public FaultTree getFaultTree() { + return this.faultTree; + } +} -- cgit v1.2.3-54-g00ecf