Skip to content

armgit / core

Public Imported from GitHub
0

100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps

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.java
index 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 Container
childElectricityAssets.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 Container
double[] 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 Container
assetPredictedDatapointService.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 Container
AttributeRef 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 schedule
Optional<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 level
Function<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.java
index 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 hour
energyLevelMins[(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
+ // levels
for (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 ConstantConditions
applyImportOpportunity(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 way
int 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 opportunity
j++;
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 way
int 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 opportunity
j++;
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.groovy
index 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.Specification
import spock.util.concurrent.PollingConditions
import java.time.Instant
+import java.time.LocalDateTime
+import java.time.ZoneId
import java.time.temporal.ChronoUnit
import 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/>.
*/
-@Ignore
class EnergyOptimisationAssetTest extends Specification implements ManagerContainerTrait {
def "Test storage asset with consumer and producer"() {
@@ -84,49 +85,48 @@ class EnergyOptimisationAssetTest extends Specification implements ManagerContai
when: "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) == 0d
def 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 == 0d
assert 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.groovy
index 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.Pair
import spock.lang.Specification
import java.time.Instant
+import java.time.LocalDateTime
import java.time.ZoneId
import java.time.ZoneOffset
+import java.time.temporal.ChronoUnit
import java.util.function.Function
import 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] == 7d
powerSetpoints[1] == 7d
powerSetpoints[2] == 7d
- powerSetpoints[3] closeTo(2.33333, 0.0001)
+ powerSetpoints[3] == 0d
powerSetpoints[4] closeTo(-4.66666, 0.0001)
powerSetpoints[5] == 7d
powerSetpoints[6] == -20d
- powerSetpoints[7] closeTo(-5.66666, 0.0001)
+ powerSetpoints[7] closeTo(-3.33333, 0.0001)
}
}