initial solution to integrate structure function

Author: michaelhglass

src/main/java/org/jreliability/bdd/BDDReliabilityFunction.java

@@ -15,7 +15,16 @@
 
 package org.jreliability.bdd;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
 import org.apache.commons.collections15.Transformer;
+import org.jreliability.booleanfunction.Term;
+import org.jreliability.booleanfunction.common.ANDTerm;
+import org.jreliability.booleanfunction.common.LiteralTerm;
+import org.jreliability.booleanfunction.common.NOTTerm;
+import org.jreliability.common.StructureFunction;
 import org.jreliability.function.ReliabilityFunction;
 import org.jreliability.function.SequentialFunction;
 import org.jreliability.function.UnreliabilityFunction;
@@ -26,19 +35,18 @@
  * 
  * @author glass
  * 
- * @param <T>
- *            the type of variable
+ * @param <T> the type of variable
  */
-public class BDDReliabilityFunction<T> extends SequentialFunction implements ReliabilityFunction {
+public class BDDReliabilityFunction<T> extends SequentialFunction implements ReliabilityFunction, StructureFunction<T> {
 
 	/**
 	 * The BDD representing the {@link UnreliabilityFunction}.
 	 */
 	protected final BDD<T> bdd;
 
 	/**
-	 * The used {@link Transformer} to get the {@link ReliabilityFunction} of
-	 * each element of the {@link BDD}.
+	 * The used {@link Transformer} to get the {@link ReliabilityFunction} of each
+	 * element of the {@link BDD}.
 	 */
 	protected final Transformer<T, ReliabilityFunction> functionTransformer;
 
@@ -51,12 +59,10 @@ public class BDDReliabilityFunction<T> extends SequentialFunction implements Rel
 	 * Constructs a {@link BDDReliabilityFunction} with a given {@link BDD} and
 	 * {@link Transformer}.
 	 * 
-	 * @param bdd
-	 *            the bdd representing the reliabilityFunction
+	 * @param bdd                 the bdd representing the reliabilityFunction
 	 * 
-	 * @param functionTransformer
-	 *            the functionTransformer to transform bdd elements to
-	 *            reliabilityFunction
+	 * @param functionTransformer the functionTransformer to transform bdd elements
+	 *                            to reliabilityFunction
 	 */
 	public BDDReliabilityFunction(BDD<T> bdd, Transformer<T, ReliabilityFunction> functionTransformer) {
 		super();
@@ -77,8 +83,7 @@ public double getY(final double x) {
 			/**
 			 * Default {@link Transformer}.
 			 * 
-			 * @param a
-			 *            parameter a
+			 * @param a parameter a
 			 * @return the double value of a
 			 */
 			@Override
@@ -108,4 +113,33 @@ public Transformer<T, ReliabilityFunction> getTransformer() {
 		return functionTransformer;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.jreliability.common.StructureFunction#isProvidingService(Map<T, Boolean>)
+	 */
+	@Override
+	public boolean isProvidingService(Map<T, Boolean> variables) {
+		// Convert variables and their phase to a term
+		List<Term> terms = new ArrayList<Term>();
+		for (Map.Entry<T, Boolean> entry : variables.entrySet()) {
+			LiteralTerm<T> literalTerm = new LiteralTerm<T>(entry.getKey());
+			if (entry.getValue()) {
+				terms.add(literalTerm);
+			} else {
+				terms.add(new NOTTerm(literalTerm));
+			}
+		}
+		ANDTerm variablesTerm = new ANDTerm(terms);
+		// Get BDD from term
+		BDDTTRF<T> bddTTRF = new BDDTTRF<T>(bdd.getProvider());
+		BDD<T> variablesBDD = bddTTRF.convertToBDD(variablesTerm);
+		
+		// Combine variablesBDD and bdd via AND: If result is zero, no service is provided anymore
+		BDD<T> tmpBDD = bdd.copy();
+		tmpBDD.andWith(variablesBDD);
+		boolean hasFailed = tmpBDD.isZero();
+		return !hasFailed;
+	}
+
 }

src/main/java/org/jreliability/common/StructureFunction.java

@@ -0,0 +1,31 @@
+/**
+ * 
+ */
+package org.jreliability.common;
+
+import java.util.Map;
+
+/**
+ * The {@link StructureFunction} {@code phi(T)} is a characteristic or indicater
+ * function that determines whether the system provides correct service
+ * ({@code phi(X) = true}) or has failed ({@code phi(X) = false}) given a set of
+ * properly working and/or failed variables of type T.
+ * 
+ * @author glass
+ * 
+ * @param <T> the type of the variables
+ * 
+ */
+public interface StructureFunction<T> {
+
+	/**
+	 * Corresponds to the structure function {@code phi} and returns whether the
+	 * system works given a map of either working or failed variables
+	 * 
+	 * @param variables the map of working or failed variables
+	 * @return true if the system still provides correct service and false in case
+	 *         it failed
+	 */
+	public boolean isProvidingService(Map<T, Boolean> variables);
+
+}

src/test/java/org/jreliability/bdd/BDDReliabilityFunctionTest.java

@@ -15,11 +15,15 @@
 
 package org.jreliability.bdd;
 
+import java.util.HashMap;
+import java.util.Map;
+
 import org.apache.commons.collections15.Transformer;
 import org.jreliability.bdd.javabdd.JBDDProviderFactory;
 import org.jreliability.booleanfunction.Term;
 import org.jreliability.booleanfunction.common.ANDTerm;
 import org.jreliability.booleanfunction.common.LiteralTerm;
+import org.jreliability.booleanfunction.common.ORTerm;
 import org.jreliability.function.ReliabilityFunction;
 import org.jreliability.function.common.ExponentialReliabilityFunction;
 import org.junit.jupiter.api.Assertions;
@@ -105,4 +109,42 @@ public void testGetTransformer() {
 		Assertions.assertEquals(transformer, function.getTransformer());
 	}
 
+	@Test
+	public void testIsProvidingService() {
+		// Sensor 1 & 2 in parallel, sensor 3 in series
+		String var1 = "sensor1";
+		String var2 = "sensor2";
+		String var3 = "sensor3";
+		Term s1 = new LiteralTerm<>(var1);
+		Term s2 = new LiteralTerm<>(var2);
+		Term s3 = new LiteralTerm<>(var3);
+		ORTerm or = new ORTerm();
+		or.add(s1, s2);
+		ANDTerm and = new ANDTerm();
+		and.add(or, s3);
+
+		BDDTTRF<String> ttrf = new BDDTTRF<String>(provider);
+		BDD<String> bdd = ttrf.convertToBDD(and);
+
+		BDDReliabilityFunction<String> function = new BDDReliabilityFunction<String>(bdd, new TestTransformer());
+
+		Map<String, Boolean> failedComponents = new HashMap<String, Boolean>();
+
+		// First sensor failure should return proper working system
+		failedComponents.put(var1, false);
+		Assertions.assertTrue(function.isProvidingService(failedComponents));
+
+		// Second sensor failure should return failed system
+		failedComponents.put(var2, false);
+		Assertions.assertFalse(function.isProvidingService(failedComponents));
+
+		// Second sensor back to life, system properly working
+		failedComponents.put(var2, true);
+		Assertions.assertTrue(function.isProvidingService(failedComponents));
+
+		// Sensor 3 failure cannot be mitigated, system fails
+		failedComponents.put(var3, false);
+		Assertions.assertFalse(function.isProvidingService(failedComponents));
+	}
+
 }