feat: add TotalSyntheticComponent

Author: metacosm

measure/src/main/java/net/laprun/sustainability/power/analysis/TotalSyntheticComponent.java

@@ -0,0 +1,82 @@
+package net.laprun.sustainability.power.analysis;
+
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import net.laprun.sustainability.power.Errors;
+import net.laprun.sustainability.power.SensorMetadata;
+import net.laprun.sustainability.power.SensorUnit;
+
+public class TotalSyntheticComponent implements SyntheticComponent {
+    private final Function<double[], Double> formula;
+    private final SensorUnit expectedResultUnit;
+    private final SensorMetadata.ComponentMetadata metadata;
+
+    public TotalSyntheticComponent(SensorMetadata metadata, SensorUnit expectedResultUnit, int... totalComponentIndices) {
+        Objects.requireNonNull(totalComponentIndices, "Must specify component indices that will aggregated in a total");
+        this.expectedResultUnit = Objects.requireNonNull(expectedResultUnit, "Must specify expected result unit");
+
+        final var errors = new Errors();
+        final var totalComponents = Arrays.stream(totalComponentIndices)
+                .mapToObj(i -> toTotalComponent(metadata, i, errors))
+                .toArray(TotalComponent[]::new);
+        final String description = Arrays.stream(totalComponents)
+                .map(TotalComponent::name)
+                .collect(Collectors.joining(" + ", "Aggregated total from (", ")"));
+        final String name = Arrays.stream(totalComponents)
+                .map(TotalComponent::name)
+                .collect(Collectors.joining("_", "total", ""));
+        final var isAttributed = metadata.components().values().stream()
+                .map(SensorMetadata.ComponentMetadata::isAttributed)
+                .reduce(Boolean::logicalAnd).orElse(false);
+        formula = components -> {
+            double result = 0;
+            for (var totalComponent : totalComponents) {
+                result += components[totalComponent.index] * totalComponent.factor;
+            }
+            return result;
+        };
+
+        if (metadata.exists(name)) {
+            errors.addError("Component " + name + " already exists");
+        }
+
+        if (errors.hasErrors()) {
+            throw new IllegalArgumentException(errors.formatErrors());
+        }
+
+        this.metadata = new SensorMetadata.ComponentMetadata(name, description, isAttributed, expectedResultUnit);
+    }
+
+    private double convertToExpectedUnit(double value) {
+        return value * expectedResultUnit.base().conversionFactorTo(expectedResultUnit);
+    }
+
+    private record TotalComponent(String name, int index, double factor) {
+    }
+
+    private TotalComponent toTotalComponent(SensorMetadata metadata, int index, Errors errors) {
+        final var cm = metadata.metadataFor(index);
+        final var name = cm.name();
+        final var unit = cm.unit();
+        if (!unit.isCommensurableWith(expectedResultUnit)) {
+            errors.addError("Component " + name
+                    + " is not commensurable with the expected base unit: " + expectedResultUnit);
+        }
+
+        final var factor = unit.factor();
+        return new TotalComponent(name, index, factor);
+    }
+
+    @Override
+    public SensorMetadata.ComponentMetadata metadata() {
+        return metadata;
+    }
+
+    @Override
+    public double synthesizeFrom(double[] components, long timestamp) {
+        return convertToExpectedUnit(formula.apply(components));
+    }
+}

measure/src/test/java/net/laprun/sustainability/power/analysis/TotalMeasureProcessorTest.java

@@ -20,10 +20,15 @@ void totalShouldFailIfAllComponentsAreNotCommensurable() {
                 .build();
 
         final var expectedResultUnit = SensorUnit.W;
-        final var e = assertThrows(IllegalArgumentException.class,
+        var e = assertThrows(IllegalArgumentException.class,
                 () -> new TotalMeasureProcessor(metadata, expectedResultUnit, 0, 1));
         assertTrue(e.getMessage().contains("Component " + inError
                 + " is not commensurable with the expected base unit: " + expectedResultUnit));
+
+        e = assertThrows(IllegalArgumentException.class,
+                () -> new TotalSyntheticComponent(metadata, expectedResultUnit, 0, 1));
+        assertTrue(e.getMessage().contains("Component " + inError
+                + " is not commensurable with the expected base unit: " + expectedResultUnit));
     }
 
     @Test
@@ -48,22 +53,28 @@ void testTotal() {
         final var m3total = m3c1 + m3c2 + m3c3;
 
         final var totalProc = new TotalMeasureProcessor(metadata, SensorUnit.of("mW"), 0, 1, 2);
+        final var totalSyncComp = new TotalSyntheticComponent(metadata, SensorUnit.W, 0, 1, 2);
 
         final var components = new double[metadata.componentCardinality()];
         components[0] = m1c1;
         components[1] = m1c2;
         components[2] = m1c3;
         totalProc.recordMeasure(components, System.currentTimeMillis());
+        // original components use mW as unit but we're asking for a synthetic total in W so the resulting total should be factored
+        final var mWtoWFactor = SensorUnit.mW.conversionFactorTo(SensorUnit.W);
+        assertEquals(m1total * mWtoWFactor, totalSyncComp.synthesizeFrom(components, 0));
 
         components[0] = m2c1;
         components[1] = m2c2;
         components[2] = m2c3;
         totalProc.recordMeasure(components, System.currentTimeMillis());
+        assertEquals(m2total * mWtoWFactor, totalSyncComp.synthesizeFrom(components, 0));
 
         components[0] = m3c1;
         components[1] = m3c2;
         components[2] = m3c3;
         totalProc.recordMeasure(components, System.currentTimeMillis());
+        assertEquals(m3total * mWtoWFactor, totalSyncComp.synthesizeFrom(components, 0));
 
         assertEquals(m1c1 + m1c2 + m1c3 + m2c1 + m2c2 + m2c3 + m3c1 + m3c2 + m3c3, totalProc.total());
         assertEquals(Stream.of(m1total, m2total, m3total).min(Double::compareTo).orElseThrow(), totalProc.minMeasuredTotal());