100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps
Java asset-managementbuildingdashboarddataplatformdevice-managementedge-computingenergyenergy-managementenergy-monitorfleet-managementfleet-telematicsiotiot-applicationiot-platformmodbusmqttmqtt-brokerota-updaterules-enginesmartcity
Energy optimisation
Rich Turnerc79fb4f69476
diff --git a/manager/src/main/java/org/openremote/manager/energy/EnergyOptimisationService.java b/manager/src/main/java/org/openremote/manager/energy/EnergyOptimisationService.javaindex 2c240cf88..fef789a95 100644--- a/manager/src/main/java/org/openremote/manager/energy/EnergyOptimisationService.java+++ b/manager/src/main/java/org/openremote/manager/energy/EnergyOptimisationService.java@@ -42,10 +42,7 @@ import org.openremote.model.util.AssetModelUtil;import org.openremote.model.util.Pair;import org.openremote.model.value.MetaItemType;-import java.time.Duration;-import java.time.Instant;-import java.time.ZoneId;-import java.time.ZoneOffset;+import java.time.*;import java.time.format.DateTimeFormatter;import java.time.temporal.ChronoUnit;import java.util.*;@@ -215,7 +212,7 @@ public class EnergyOptimisationService extends RouteBuilder implements Container}/**- * Gets the start time of the current interval+ * Gets the start time of the interval that the currentMillis value is within*/protected static Instant getOptimisationStartTime(long currentMillis, long periodSeconds) {Instant now = Instant.ofEpochMilli(currentMillis);@@ -284,11 +281,10 @@ public class EnergyOptimisationService extends RouteBuilder implements ContainerchildElectricityAssets.stream().filter(asset ->- // Filter consumers and producers or group asset of consumers and producers that have a power attribute- asset instanceof ElectricityConsumerAsset- || asset instanceof ElectricityProducerAsset- || isProducerOrConsumerGroupAsset(asset))- .filter(asset -> asset.hasAttribute(ElectricityAsset.POWER))+ // Filter electricity asset or group asset of consumers and producers that have a power attribute+ asset instanceof ElectricityAsset+ || isElectricityGroupAsset(asset))+ .filter(asset -> asset.hasAttribute(ElectricityAsset.POWER) && !asset.hasAttribute(ElectricityAsset.POWER_SETPOINT)).forEach(asset -> {@SuppressWarnings("OptionalGetWithoutIsPresent")Attribute<Double> powerAttribute = asset.getAttribute(ElectricityAsset.POWER).get();@@ -328,7 +324,7 @@ public class EnergyOptimisationService extends RouteBuilder implements Containerdouble[] exportPowerMaxes = new double[intervalCount];Arrays.fill(importPowerMaxes, importPowerMax);Arrays.fill(exportPowerMaxes, exportPowerMax);- long periodSeconds = (long)optimiser.getIntervalSize()*60*60;+ long periodSeconds = (long)(optimiser.getIntervalSize()*60*60);optimisableStorageAssets.forEach(storageAsset -> {LOG.finest("Optimising storage asset setpoints: " + storageAsset);@@ -344,14 +340,14 @@ public class EnergyOptimisationService extends RouteBuilder implements ContainerassetPredictedDatapointService.updateValue(new AttributeRef(storageAsset.getId(), ElectricityAsset.POWER_SETPOINT.getName()),setpoints[i],- optimisationTime.plus(periodSeconds*i, ChronoUnit.SECONDS).toEpochMilli());+ LocalDateTime.ofInstant(optimisationTime.plus(periodSeconds*i, ChronoUnit.SECONDS), ZoneId.systemDefault()));}assetProcessingService.sendAttributeEvent(new AttributeEvent(storageAsset.getId(), ElectricityAsset.POWER_SETPOINT, setpoints[0]));});}- protected boolean isProducerOrConsumerGroupAsset(Asset<?> asset) {+ protected boolean isElectricityGroupAsset(Asset<?> asset) {if (!(asset instanceof GroupAsset)) {return false;}@@ -362,8 +358,7 @@ public class EnergyOptimisationService extends RouteBuilder implements Container.orElse(null);return assetClass != null &&- (ElectricityConsumerAsset.class.isAssignableFrom(assetClass)- || ElectricityProducerAsset.class.isAssignableFrom(assetClass));+ ElectricityAsset.class.isAssignableFrom(assetClass);}protected double[] get24HAttributeValues(String assetId, Attribute<Double> attribute, double intervalSize, int intervalCount, Instant optimisationTime) {@@ -377,20 +372,22 @@ public class EnergyOptimisationService extends RouteBuilder implements ContainerAttributeRef ref = new AttributeRef(assetId, attribute.getName());if (attribute.hasMeta(MetaItemType.HAS_PREDICTED_DATA_POINTS)) {+ LocalDateTime timestamp = LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault());ValueDatapoint<?>[] predictedData = assetPredictedDatapointService.getValueDatapoints(ref,"minute",- ((long) intervalSize * 60) + " minute",- optimisationTime.toEpochMilli(), optimisationTime.plus(24, HOURS).toEpochMilli()+ (long)(intervalSize * 60) + " minute",+ timestamp,+ timestamp.plus(24, HOURS).minus((long)(intervalSize * 60), ChronoUnit.MINUTES));if (predictedData.length != values.length) {LOG.warning("Returned predicted data point count does not match interval count: Ref=" + ref + ", expected=" + values.length + ", actual=" + predictedData.length);} else {IntStream.range(0, predictedData.length).forEach(i ->- values[i] = (double)(Object)predictedData[i].getValue());+ values[i] = predictedData[i].getValue() != null ? (double)(Object)predictedData[i].getValue() : 0d);}} else {- LOG.fine("Electricity asset doesn't have any predicted data for attribute: Ref=" + ref);+ LOG.finer("Electricity asset doesn't have any predicted data for attribute: Ref=" + ref);}values[0] = attribute.getValue().orElse(0d);@@ -436,11 +433,11 @@ public class EnergyOptimisationService extends RouteBuilder implements Container// Does the storage support import and have an energy level scheduleOptional<Integer[][]> energyLevelScheduleOptional = storageAsset.getEnergyLevelSchedule();boolean hasEnergyMinRequirement = energyLevelMin > 0 || energyLevelScheduleOptional.isPresent();- double powerExportMax = storageAsset.getPowerExportMax().orElse(Double.MIN_VALUE);+ double powerExportMax = storageAsset.getPowerExportMax().map(power -> -1*power).orElse(Double.MIN_VALUE);double powerImportMax = storageAsset.getPowerImportMax().orElse(Double.MAX_VALUE);int[][] energySchedule = energyLevelScheduleOptional.map(dayArr -> Arrays.stream(dayArr).map(hourArr -> Arrays.stream(hourArr).mapToInt(Integer::intValue).toArray()).toArray(int[][]::new)).orElse(null);- optimiser.applyEnergySchedule(energyLevelMins, energyCapacity, energyLevelMin, energyLevelMax, energySchedule, timerService.getCurrentTimeMillis());+ optimiser.applyEnergySchedule(energyLevelMins, energyCapacity, energyLevelMin, energyLevelMax, energySchedule, LocalDateTime.ofInstant(Instant.ofEpochMilli(timerService.getCurrentTimeMillis()), ZoneId.systemDefault()));// TODO: Make these a function of energy levelFunction<Integer, Double> powerImportMaxCalculator = interval -> powerImportMax;diff --git a/manager/src/main/java/org/openremote/manager/energy/EnergyOptimiser.java b/manager/src/main/java/org/openremote/manager/energy/EnergyOptimiser.javaindex feb372711..569232251 100644--- a/manager/src/main/java/org/openremote/manager/energy/EnergyOptimiser.java+++ b/manager/src/main/java/org/openremote/manager/energy/EnergyOptimiser.java@@ -19,14 +19,17 @@*/package org.openremote.manager.energy;-import org.openremote.model.asset.impl.ElectricityStorageAsset;import org.openremote.model.util.Pair;-import java.time.Instant;import java.time.LocalDateTime;-import java.time.ZoneId;+import java.time.OffsetDateTime;+import java.time.ZoneOffset;import java.time.temporal.ChronoField;-import java.util.*;+import java.time.temporal.ChronoUnit;+import java.util.ArrayList;+import java.util.Arrays;+import java.util.Comparator;+import java.util.List;import java.util.concurrent.atomic.AtomicInteger;import java.util.function.BiFunction;import java.util.function.Function;@@ -180,9 +183,10 @@ public class EnergyOptimiser {/*** Will take the supplied 24x7 energy schedule percentages and energy level min/max values and apply them to the- * supplied energyLevelMins also adjusting for any intervalSize difference.+ * supplied energyLevelMins also adjusting for any intervalSize difference. The energy schedule should be in UTC+ * time.*/- public void applyEnergySchedule(double[] energyLevelMins, double energyCapacity, double energyLevelMin, double energyLevelMax, int[][] energyLevelSchedule, long currentTime) {+ public void applyEnergySchedule(double[] energyLevelMins, double energyCapacity, double energyLevelMin, double energyLevelMax, int[][] energyLevelSchedule, LocalDateTime currentTime) {energyLevelMin = Math.min(energyLevelMax, Math.max(0d, energyLevelMin));Arrays.fill(energyLevelMins, energyLevelMin);@@ -191,7 +195,7 @@ public class EnergyOptimiser {}// Extract the schedule for the next 24 hour period starting at current hour plus 1 (need to attain energy level by the time the hour starts)- LocalDateTime date = Instant.ofEpochMilli(currentTime + 3600000).atZone(ZoneId.systemDefault()).toLocalDateTime();+ OffsetDateTime date = currentTime.plus(1, ChronoUnit.HOURS).atOffset(ZoneOffset.UTC);int dayIndex = date.getDayOfWeek().getValue();int hourIndex = date.get(ChronoField.HOUR_OF_DAY);int i = 0;@@ -216,7 +220,7 @@ public class EnergyOptimiser {// Put energy level schedule value into first interval for the hourenergyLevelMins[(hourIntervals * i)] = Math.min(energyLevelMax, Math.max(energyLevelMins[(hourIntervals * i)], schedule[i]));}- } else if (intervalSize > 1d) {+ } else {int takeSize = (int) intervalSize;int hourIntervals = (int) (24d / intervalSize);@@ -354,8 +358,9 @@ public class EnergyOptimiser {}/**- * Will find the best earning opportunity for each interval (import or export) and will then try to apply each in- * order of earning potential. The powerSetpoints will be updated as a result.+ * Will find the best earning opportunity for each interval (import or export) and will then try to apply them in+ * chronological order (reallocating earlier import/exports if it cost beneficial). The powerSetpoints will be+ * updated as a result.*/public void applyEarningOpportunities(double[][] importCostAndPower, double[][] exportCostAndPower, double[] energyLevelMins, double[] powerSetpoints, Function<Integer, Double> energyLevelCalculator, Function<Integer, Double> powerImportMaxCalculator, Function<Integer, Double> powerExportMaxCalculator, double energyLevelMax) {@@ -377,22 +382,19 @@ public class EnergyOptimiser {.sorted(Comparator.comparingDouble(optimisedInterval -> optimisedInterval.value[0])).collect(Collectors.toList());- // Go through each earning opportunity (highest earning first) and determine if it can be utilised without- // breaching the energy min levels+ // Go through each earning opportunity and determine if it can be utilised without breaching the energy min+ // levelsfor (Pair<Integer, double[]> earningOpportunity : earningOpportunities) {int interval = earningOpportunity.key;double[] costAndPower = earningOpportunity.value;- boolean isImportOpportunity = costAndPower[2] > 0;- double impPowerMax = isImportOpportunity ? Math.min(powerImportMaxCalculator.apply(interval), costAndPower[2]) : 0d;- double expPowerMax = !isImportOpportunity ? Math.max(powerExportMaxCalculator.apply(interval), costAndPower[1]) : 0d;- if (isImportOpportunity && powerSetpoints[interval] >= 0 && powerSetpoints[interval] < impPowerMax) {+ if (isImportOpportunity(costAndPower, powerSetpoints[interval], interval, powerImportMaxCalculator)) {// import opportunity and interval still available to import power//noinspection ConstantConditionsapplyImportOpportunity(importCostAndPower, exportCostAndPower, energyLevelMins, powerSetpoints, energyLevelCalculator, powerImportMaxCalculator, powerExportMaxCalculator, interval, energyLevelMax);- } else if (!isImportOpportunity && powerSetpoints[interval] <= 0 && powerSetpoints[interval] > expPowerMax) {+ } else if (isExportOpportunity(costAndPower, powerSetpoints[interval], interval, powerExportMaxCalculator)) {// export opportunity and interval still available to export power//noinspection ConstantConditions@@ -401,6 +403,14 @@ public class EnergyOptimiser {}}+ protected boolean isImportOpportunity(double[] costAndPower, double powerSetpoint, int interval, Function<Integer, Double> powerImportMaxCalculator) {+ return costAndPower[2] > 0 && powerSetpoint >= 0 && powerSetpoint < Math.min(powerImportMaxCalculator.apply(interval), costAndPower[2]);+ }++ protected boolean isExportOpportunity(double[] costAndPower, double powerSetpoint, int interval, Function<Integer, Double> powerExportMaxCalculator) {+ return costAndPower[1] < 0 && powerSetpoint <= 0 && powerSetpoint > Math.max(powerExportMaxCalculator.apply(interval), costAndPower[1]);+ }+/*** Tries to apply the maximum import power as defined in the importCostAndPower at the specified interval taking* into consideration the maximum power and energy levels; if there is insufficient power or energy capacity at the@@ -409,69 +419,98 @@ public class EnergyOptimiser {*/public void applyImportOpportunity(double[][] importCostAndPower, double[][] exportCostAndPower, double[] energyLevelMins, double[] powerSetpoints, Function<Integer, Double> energyLevelCalculator, Function<Integer, Double> powerImportMaxCalculator, Function<Integer, Double> powerExportMaxCalculator, int interval, double energyLevelMax) {double[] costAndPower = importCostAndPower[interval];- double intervalEnergyLevel = energyLevelCalculator.apply(interval);+ double impPowerMin = costAndPower[1];double impPowerMax = Math.min(powerImportMaxCalculator.apply(interval), costAndPower[2]);double powerCapacity = impPowerMax - powerSetpoints[interval];- double energySpace = energyLevelMax - intervalEnergyLevel;- double energyChangeMax = powerCapacity * intervalSize;- if (energySpace < energyChangeMax && exportCostAndPower != null) {- // Can't maximise on opportunity without exporting earlier on so can this be done in a cost- // effective way+ if (impPowerMin > powerCapacity) {+ // Can't attain min power level to make use of this opportunity+ return;+ }++ double energySpace = energyLevelMax - energyLevelCalculator.apply(interval);+ double energySpaceMax = powerCapacity * intervalSize;+ double energySpaceMin = impPowerMin * intervalSize;+ List<Pair<Integer, Double>> pastIntervalPowerDeltas = new ArrayList<>();++ int k = interval;+ while (k < powerSetpoints.length && energySpace < 0 && energySpace <= energySpaceMin) {++ double futureEnergySpace = energyLevelCalculator.apply(k) - energyLevelMins[k];+ energySpace = Math.max(energySpace, -futureEnergySpace);+ k++;++ }++ if (energySpace > 0 && energySpace < energySpaceMax && exportCostAndPower != null) {+ // Can't maximise on opportunity without exporting earlier on so can this be done+ // in a cost effective wayint i = interval - 1;- List<Pair<Integer, double[]>> exportOpportunities = new ArrayList<>();+ List<Pair<Integer, Double>> pastOpportunities = new ArrayList<>();while (i >= 0) {- if (powerSetpoints[i] > 0) {- // Already importing so cannot use this interval- i--;- continue;- }- if (costAndPower[0] + exportCostAndPower[i][0] < 0) {- // We can afford to export and still earn using original import- exportOpportunities.add(new Pair<>(i, exportCostAndPower[i]));+ if (costAndPower[0] + exportCostAndPower[i][0] < 0 && powerSetpoints[i] <= 0) {+ // We can afford to export earlier and still earn from this import+ pastOpportunities.add(new Pair<>(i, exportCostAndPower[i][0]));}i--;}- exportOpportunities.sort(Comparator.comparingDouble(op -> op.value[0]));+ pastOpportunities.sort(Comparator.comparingDouble(op -> op.value));int j = 0;- while (energySpace < energyChangeMax && j < exportOpportunities.size()) {+ while (energySpace < energySpaceMax && j < pastOpportunities.size()) {// Energy level at this interval must be above energy min to consider exporting- Pair<Integer, double[]> exportOpportunity = exportOpportunities.get(j);- int exportInterval = exportOpportunity.key;- double[] exportPowerCost = exportOpportunity.value;- double expPowerMax = Math.max(powerExportMaxCalculator.apply(exportInterval), exportPowerCost[1]);- powerCapacity = expPowerMax - powerSetpoints[exportInterval];+ Pair<Integer, Double> opportunity = pastOpportunities.get(j);+ int pastInterval = opportunity.key;++ // Power capacity must be within the optimum power band+ double[] pastCostAndPower = exportCostAndPower[pastInterval];+ double expPowerMax = Math.max(powerExportMaxCalculator.apply(pastInterval), pastCostAndPower[1]);+ double expPowerCapacity = expPowerMax - powerSetpoints[pastInterval];- if (powerCapacity >= 0 || powerCapacity > exportPowerCost[2]) {+ if (expPowerCapacity >= 0 || expPowerCapacity > pastCostAndPower[2]) {// Power capacity is outside optimum power band so cannot use this opportunityj++;continue;}- double energySurplus = energyLevelMins[exportInterval] - energyLevelCalculator.apply(exportInterval);+ double energySurplusMin = pastCostAndPower[2] * intervalSize;+ double energySurplus = energyLevelMins[pastInterval] - energyLevelCalculator.apply(pastInterval);+ energySurplus = Math.max(energySurplus, energySpace - energySpaceMax);++ // We have spare energy capacity and power check if we don't violate energy min for any future exports+ k = pastInterval;+ while (k < powerSetpoints.length && energySurplus < 0 && energySurplus <= energySurplusMin) {++ double futureEnergySurplus = energyLevelCalculator.apply(k) - energyLevelMins[k];+ energySurplus = Math.max(energySurplus, -futureEnergySurplus);+ k++;++ }++ expPowerCapacity = Math.max(expPowerCapacity, energySurplus / intervalSize);- if (energySurplus < 0 && powerCapacity < 0) {- // We have spare energy capacity and power- double energyPotential = Math.max(energySurplus, energySpace - energyChangeMax);- double powerPotential = energyPotential / intervalSize;- powerPotential = Math.max(powerPotential, powerCapacity);- energySpace += -1d * powerPotential * intervalSize;- powerSetpoints[exportInterval] = powerSetpoints[exportInterval] + powerPotential;+ if (expPowerCapacity < 0 && expPowerCapacity < pastCostAndPower[2]) {+ // We can export in the optimum range+ energySpace += -1d * energySurplus;+ pastIntervalPowerDeltas.add(new Pair<>(pastInterval, expPowerCapacity));}j++;}}- // Do original import if there is any energy space- if (energySpace > 0) {- energyChangeMax = Math.min(energyChangeMax, energySpace);- powerCapacity = Math.min(impPowerMax - powerSetpoints[interval], (energyChangeMax / intervalSize));+ // Do original import if there is enough energy space+ if (energySpace > 0 && energySpace >= energySpaceMin) {++ // Adjust past interval set points as required+ pastIntervalPowerDeltas.forEach(intervalAndDelta -> powerSetpoints[intervalAndDelta.key] += intervalAndDelta.value);++ energySpaceMax = Math.min(energySpaceMax, energySpace);+ powerCapacity = Math.min(impPowerMax - powerSetpoints[interval], (energySpaceMax / intervalSize));powerSetpoints[interval] = powerSetpoints[interval] + powerCapacity;}}@@ -484,59 +523,109 @@ public class EnergyOptimiser {*/public void applyExportOpportunity(double[][] importCostAndPower, double[][] exportCostAndPower, double[] energyLevelMins, double[] powerSetpoints, Function<Integer, Double> energyLevelCalculator, Function<Integer, Double> powerImportMaxCalculator, Function<Integer, Double> powerExportMaxCalculator, int interval, double energyLevelMax) {double[] costAndPower = exportCostAndPower[interval];- double intervalEnergyLevel = energyLevelCalculator.apply(interval);+ double expPowerMin = costAndPower[2];double expPowerMax = Math.max(powerExportMaxCalculator.apply(interval), costAndPower[1]);double powerCapacity = expPowerMax - powerSetpoints[interval];- double energySurplus = intervalEnergyLevel - energyLevelMins[interval];- double energyChangeMax = -1d * powerCapacity * intervalSize;- if (energySurplus < energyChangeMax && importCostAndPower != null) {- // Can't maximise on opportunity without importing earlier on so can this be done in a cost- // effective way+ if (expPowerMin < powerCapacity) {+ // Can't attain min power level to make use of this opportunity+ return;+ }++ double energySurplus = energyLevelCalculator.apply(interval) - energyLevelMins[interval];+ double energySurplusMin = -1d * expPowerMin * intervalSize;+ double energySurplusMax = -1d * powerCapacity * intervalSize;+ List<Pair<Integer, Double>> pastAndFutureIntervalPowerDeltas = new ArrayList<>();++ int k = interval;+ while (k < powerSetpoints.length && energySurplus > 0 && energySurplus >= energySurplusMin) {++ double futureEnergySurplus = energyLevelCalculator.apply(k) - energyLevelMins[k];++ // The following is an attempt to make use of an earning opportunity that would violate future energy limits+ // by allocating extra imports between 'now' and 'then' - this needs more work+// if (futureEnergySurplus < energySurplusMin || futureEnergySurplus <= 0) {+// // Try and allocate an import between this future point and the earning opportunity to prevent this deficit+// int l = k - 1;+// while (futureEnergySurplus < energySurplusMax && l > interval) {+// int finalL = l;+// if (powerSetpoints[l] >= 0 && pastAndFutureIntervalPowerDeltas.stream().noneMatch(delta -> delta.key.equals(finalL))) {+//+// double surplusDeficit = energySurplusMax - futureEnergySurplus;+// double intermediateEnergyCapacity = energyLevelMax - energyLevelCalculator.apply(l);+// double intermediatePowerCapacity = powerImportMaxCalculator.apply(l) - powerSetpoints[l];+// intermediatePowerCapacity = Math.min(intermediatePowerCapacity, surplusDeficit / intervalSize);+// intermediatePowerCapacity = Math.min(intermediatePowerCapacity, intermediateEnergyCapacity / intervalSize);+//+// if (intermediatePowerCapacity > 0 && powerSetpoints[l] + intermediatePowerCapacity > importCostAndPower[l][1] && costAndPower[0] + importCostAndPower[l][0] < 0) {+// // There is capacity and it is cost effective to use it+// futureEnergySurplus = intermediatePowerCapacity * intervalSize;+// pastAndFutureIntervalPowerDeltas.add(new Pair<>(l, intermediatePowerCapacity));+// }+// }+// l--;+// }+// }++ energySurplus = Math.min(energySurplus, futureEnergySurplus);+ k++;++ }++ if (energySurplus > 0 && energySurplus < energySurplusMax && importCostAndPower != null) {+ // Can't maximise on opportunity without importing earlier on so can this be done+ // in a cost effective wayint i = interval - 1;- List<Pair<Integer, double[]>> importOpportunities = new ArrayList<>();+ List<Pair<Integer, Double>> pastOpportunities = new ArrayList<>();while (i >= 0) {- if (powerSetpoints[i] < 0) {- // Already exporting so cannot use this interval- i--;- continue;- }- if (costAndPower[0] + importCostAndPower[i][0] < 0) {+ if (costAndPower[0] + importCostAndPower[i][0] < 0 && powerSetpoints[i] >= 0) {// We can afford to import and still earn using original export- importOpportunities.add(new Pair<>(i, importCostAndPower[i]));+ pastOpportunities.add(new Pair<>(i, importCostAndPower[i][0]));}i--;}- importOpportunities.sort(Comparator.comparingDouble(op -> op.value[0]));+ pastOpportunities.sort(Comparator.comparingDouble(op -> op.value));int j = 0;- while (energySurplus < energyChangeMax && j < importOpportunities.size()) {- // Energy level at this interval must be below energy max to consider importing- Pair<Integer, double[]> importOpportunity = importOpportunities.get(j);- int importInterval = importOpportunity.key;- double[] importPowerCost = importOpportunity.value;- double impPowerMax = Math.min(powerImportMaxCalculator.apply(interval), importPowerCost[2]);- powerCapacity = impPowerMax - powerSetpoints[importInterval];+ while (energySurplus < energySurplusMax && j < pastOpportunities.size()) {+ Pair<Integer, Double> opportunity = pastOpportunities.get(j);+ int pastInterval = opportunity.key;++ // Power capacity must be within the optimum power band+ double[] pastCostAndPower = importCostAndPower[pastInterval];+ double impPowerMax = Math.min(powerImportMaxCalculator.apply(interval), pastCostAndPower[2]);+ double impPowerCapacity = impPowerMax - powerSetpoints[pastInterval];- if (powerCapacity <= 0 || powerCapacity < importPowerCost[1]) {+ if (impPowerCapacity <= 0 || impPowerCapacity < pastCostAndPower[1]) {// Power capacity is outside optimum power band so cannot use this opportunityj++;continue;}- double energySpace = energyLevelMax - energyLevelCalculator.apply(importInterval);+ double energySpaceMin = pastCostAndPower[1] * intervalSize;+ double energySpace = energyLevelMax - energyLevelCalculator.apply(pastInterval);+ energySpace = Math.max(energySpace, energySpace - energySurplusMax);++ // We have spare energy capacity and power check if we don't violate energy max for any future imports+ k = pastInterval;+ while (k < powerSetpoints.length && energySurplus > 0 && energySpace >= energySpaceMin) {++ double futureEnergySpace = energyLevelMax - energyLevelCalculator.apply(k);+ energySpace = Math.min(energySpace, futureEnergySpace);+ k++;++ }++ impPowerCapacity = Math.min(impPowerCapacity, energySpace / intervalSize);- if (energySpace > 0 && powerCapacity > 0) {- // We have spare energy capacity and power- double energyPotential = Math.min(energySpace, energyChangeMax - energySurplus);- double powerPotential = energyPotential / intervalSize;- powerPotential = Math.min(powerPotential, powerCapacity);- energySurplus += powerPotential * intervalSize;- powerSetpoints[importInterval] = powerSetpoints[importInterval] + powerPotential;+ if (impPowerCapacity > 0 && impPowerCapacity > pastCostAndPower[1]) {+ // We can import in the optimum range+ energySurplus += energySurplus;+ pastAndFutureIntervalPowerDeltas.add(new Pair<>(pastInterval, impPowerCapacity));}j++;@@ -544,9 +633,13 @@ public class EnergyOptimiser {}// Do original export if there is any energy surplus- if (energySurplus > 0) {- energyChangeMax = Math.min(energyChangeMax, energySurplus);- powerCapacity = Math.max(expPowerMax - powerSetpoints[interval], -1d * (energyChangeMax / intervalSize));+ if (energySurplus > 0 && energySurplus >= energySurplusMin) {++ // Adjust past interval set points as required+ pastAndFutureIntervalPowerDeltas.forEach(intervalAndDelta -> powerSetpoints[intervalAndDelta.key] += intervalAndDelta.value);++ energySurplusMax = Math.min(energySurplusMax, energySurplus);+ powerCapacity = Math.max(expPowerMax - powerSetpoints[interval], -1d * (energySurplusMax / intervalSize));powerSetpoints[interval] = powerSetpoints[interval] + powerCapacity;}}diff --git a/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationAssetTest.groovy b/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationAssetTest.groovyindex 583009698..ccf27a38b 100644--- a/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationAssetTest.groovy+++ b/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationAssetTest.groovy@@ -19,6 +19,8 @@ import spock.lang.Specificationimport spock.util.concurrent.PollingConditionsimport java.time.Instant+import java.time.LocalDateTime+import java.time.ZoneIdimport java.time.temporal.ChronoUnitimport java.util.concurrent.Executors@@ -44,7 +46,6 @@ import static spock.util.matcher.HamcrestMatchers.closeTo* You should have received a copy of the GNU Affero General Public License* along with this program. If not, see <http://www.gnu.org/licenses/>.*/-@Ignoreclass EnergyOptimisationAssetTest extends Specification implements ManagerContainerTrait {def "Test storage asset with consumer and producer"() {@@ -84,49 +85,48 @@ class EnergyOptimisationAssetTest extends Specification implements ManagerContaiwhen: "supplier tariff values are set for the next 24hrs"def tariffExports = [-5, -2, -8, 2, 2, 5, -2, -2]def tariffImports = [3, -5, 10, 1, 3, -5, 7, 8]- now = Instant.ofEpochMilli(timerService.getCurrentTimeMillis()).truncatedTo(ChronoUnit.HOURS)+ def optimisationDateTime = LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault())assetProcessingService.sendAttributeEvent(new AttributeEvent(managerTestSetup.electricitySupplierAssetId, ElectricityAsset.TARIFF_IMPORT.name, tariffImports.get(0)))assetProcessingService.sendAttributeEvent(new AttributeEvent(managerTestSetup.electricitySupplierAssetId, ElectricityAsset.TARIFF_EXPORT.name, tariffExports.get(0)))for (int i = 1; i < tariffExports.size(); i++) {- assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySupplierAssetId, ElectricityAsset.TARIFF_IMPORT.name), tariffImports.get(i), now.plus((long)(optimiser.intervalSize * 60)*(i-1), ChronoUnit.MINUTES).toEpochMilli())- assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySupplierAssetId, ElectricityAsset.TARIFF_EXPORT.name), tariffExports.get(i), now.plus((long)(optimiser.intervalSize * 60)*(i-1), ChronoUnit.MINUTES).toEpochMilli())+ assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySupplierAssetId, ElectricityAsset.TARIFF_IMPORT.name), tariffImports.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES))+ assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySupplierAssetId, ElectricityAsset.TARIFF_EXPORT.name), tariffExports.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES))}and: "consumer and producer prediction values are set for the next 24hrs"- [-5, -25, 15, 0, 0, -5, -5, -2]- def consumerPower = [0, 5, 10, 0, 0, 10, 5, 0]+ def consumerPower = [0, 5, 20, 0, 0, 10, 5, 0]def producerPower = [-5, -30, -5, 0, 0, -15, -10, -2]assetProcessingService.sendAttributeEvent(new AttributeEvent(managerTestSetup.electricityConsumerAssetId, ElectricityAsset.POWER.name, consumerPower.get(0)))assetProcessingService.sendAttributeEvent(new AttributeEvent(managerTestSetup.electricitySolarAssetId, ElectricityAsset.POWER.name, producerPower.get(0)))for (int i = 1; i < consumerPower.size(); i++) {- assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricityConsumerAssetId, ElectricityAsset.POWER.name), tariffImports.get(i), now.plus((long)(optimiser.intervalSize * 60)*(i-1), ChronoUnit.MINUTES).toEpochMilli())- assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySolarAssetId, ElectricityAsset.POWER.name), tariffExports.get(i), now.plus((long)(optimiser.intervalSize * 60)*(i-1), ChronoUnit.MINUTES).toEpochMilli())+ assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricityConsumerAssetId, ElectricityAsset.POWER.name), consumerPower.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES))+ assetPredictedDatapointService.updateValue(new AttributeRef(managerTestSetup.electricitySolarAssetId, ElectricityAsset.POWER.name), producerPower.get(i), optimisationDateTime.plus((long)(optimiser.intervalSize * 60)*i, ChronoUnit.MINUTES))}and: "the optimisation runs"optimisationService.runOptimisation(managerTestSetup.electricityOptimisationAssetId, optimisationTime)- then: "the setpoints of the storage asset for the next 24hrs should be correctly optimised"+ then: "the setpoints of the storage asset for the next 24hrs should be correctly optimised [-20.0, 7.0, -20.0, 7.0, 0.0, 7.0, -14.0, 0.0]"conditions.eventually {- assert ((ElectricityStorageAsset)assetStorageService.find(managerTestSetup.electricityBatteryAssetId)).getPowerSetpoint().orElse(0d) == 7d+ assert ((ElectricityStorageAsset)assetStorageService.find(managerTestSetup.electricityBatteryAssetId)).getPowerSetpoint().orElse(0d) == 0ddef setpoints = assetPredictedDatapointService.getValueDatapoints(new AttributeRef(managerTestSetup.electricityBatteryAssetId, ElectricityAsset.POWER_SETPOINT.name),"minute",- ((long)optimiser.intervalSize * 60) + " minute",- timerService.currentTimeMillis,- Instant.ofEpochMilli(timerService.currentTimeMillis).plus(1, ChronoUnit.DAYS).toEpochMilli()+ (long)(optimiser.intervalSize * 60) + " minute",+ LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault()).plus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES),+ LocalDateTime.ofInstant(optimisationTime, ZoneId.systemDefault()).plus(1, ChronoUnit.DAYS).minus((long)(optimiser.intervalSize * 60), ChronoUnit.MINUTES))assert setpoints.size() == 7- assert setpoints[0].value == 7d- assert setpoints[1].value == 7d- assert that(setpoints[2].value, closeTo(2.33333, 0.0001))- assert that(setpoints[3].value, closeTo(-4.66666, 0.0001))+ assert setpoints[0].value == 0d+ assert setpoints[1].value == -20d+ assert setpoints[2].value == 7d //that(setpoints[2].value, closeTo(2.33333, 0.0001))+ assert setpoints[3].value == 0dassert setpoints[4].value == 7d- assert setpoints[5].value == -20d- assert that(setpoints[6].value, closeTo(-5.66666, 0.0001))+ assert setpoints[5].value == -14d+ assert setpoints[6].value == 0d}}}diff --git a/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationTest.groovy b/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationTest.groovyindex 267e2466b..28c95f796 100644--- a/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationTest.groovy+++ b/test/src/test/groovy/org/openremote/test/energy/EnergyOptimisationTest.groovy@@ -8,8 +8,10 @@ import org.openremote.model.util.Pairimport spock.lang.Specificationimport java.time.Instant+import java.time.LocalDateTimeimport java.time.ZoneIdimport java.time.ZoneOffset+import java.time.temporal.ChronoUnitimport java.util.function.Functionimport java.util.stream.IntStream@@ -188,7 +190,8 @@ class EnergyOptimisationTest extends Specification {given: "an energy optimisation instance"currentInterval = 0- def currentTime = Instant.ofEpochMilli(System.currentTimeMillis()).atZone(ZoneId.systemDefault()).toLocalDate().atTime(23, 00).toEpochSecond(ZoneOffset.UTC) * 1000+ def startOfDay = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS)+ def currentTime = startOfDay.plus(23, ChronoUnit.HOURS)def optimisation = new EnergyOptimiser(intervalSize, 1d)and: "some input parameters"@@ -233,7 +236,7 @@ class EnergyOptimisationTest extends Specification {energyMinLevels == [40d, 40d, 160d, 40d, 40d, 40d, 40d, 40d] as double[]when: "the energy min levels are regenerated for a different time"- currentTime = Instant.ofEpochMilli(System.currentTimeMillis()).atZone(ZoneId.systemDefault()).toLocalDate().atTime(06, 00).toEpochSecond(ZoneOffset.UTC) * 1000+ currentTime = currentTime.plus(7, ChronoUnit.HOURS)optimisation.applyEnergySchedule(energyMinLevels, energyCapacity, energyLevelMin, energyLevelMax, energyScheduleWeek, currentTime)then: "the energy min levels should be correct"@@ -253,7 +256,8 @@ class EnergyOptimisationTest extends Specification {given: "an energy optimisation instance"currentInterval = 0- def currentTime = Instant.ofEpochMilli(System.currentTimeMillis()).atZone(ZoneId.systemDefault()).toLocalDate().atTime(23, 00).toEpochSecond(ZoneOffset.UTC) * 1000+ def startOfDay = LocalDateTime.now().truncatedTo(ChronoUnit.DAYS)+ def currentTime = startOfDay.plus(23, ChronoUnit.HOURS)def optimisation = new EnergyOptimiser(intervalSize, 1d)and: "some input parameters"@@ -354,10 +358,10 @@ class EnergyOptimisationTest extends Specification {powerSetpoints[0] == 7dpowerSetpoints[1] == 7dpowerSetpoints[2] == 7d- powerSetpoints[3] closeTo(2.33333, 0.0001)+ powerSetpoints[3] == 0dpowerSetpoints[4] closeTo(-4.66666, 0.0001)powerSetpoints[5] == 7dpowerSetpoints[6] == -20d- powerSetpoints[7] closeTo(-5.66666, 0.0001)+ powerSetpoints[7] closeTo(-3.33333, 0.0001)}}