Skip to content

armgit / core

Public Imported from GitHub
0

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

EnergyOptimisationService.java updates and AssetPredictedDatapointService.java now allows batch update

Rich Turner7cbc6148f703
diff --git a/container/src/main/java/org/openremote/container/timer/TimerService.java b/container/src/main/java/org/openremote/container/timer/TimerService.java
index 2d2c7b07c..5ffe53902 100644
--- a/container/src/main/java/org/openremote/container/timer/TimerService.java
+++ b/container/src/main/java/org/openremote/container/timer/TimerService.java
@@ -69,6 +69,11 @@ public class TimerService implements ContainerService {
public void start() {
// NOOP
}
+
+ @Override
+ public void reset() {
+ // NOOP
+ }
},
PSEUDO {
protected AtomicLong offset = new AtomicLong();
@@ -104,12 +109,18 @@ public class TimerService implements ContainerService {
stopTime = null;
}
}
+
+ @Override
+ public void reset() {
+ offset.set(0L);
+ }
};
public abstract void init();
public abstract long getCurrentTimeMillis();
public abstract void stop();
public abstract void start();
+ public abstract void reset();
public abstract long advanceTime(long amount, TimeUnit unit);
}
diff --git a/manager/src/main/java/org/openremote/manager/agent/AgentService.java b/manager/src/main/java/org/openremote/manager/agent/AgentService.java
index cd59a87fa..75fda8df6 100644
--- a/manager/src/main/java/org/openremote/manager/agent/AgentService.java
+++ b/manager/src/main/java/org/openremote/manager/agent/AgentService.java
@@ -156,7 +156,8 @@ public class AgentService extends RouteBuilder implements ContainerService, Asse
@Override
public void stop(Container container) throws Exception {
- agentMap.values().stream().map(Agent::getId).forEach(this::stopAgent);
+ List<Agent<?,?,?>> agents = new ArrayList<>(agentMap.values());
+ agents.forEach(agent -> this.stopAgent(agent.getId()));
agentMap.clear();
protocolInstanceMap.clear();
}
@@ -637,6 +638,11 @@ public class AgentService extends RouteBuilder implements ContainerService, Asse
}
protected Map<String, Agent<?, ?, ?>> getAgents() {
+
+ if (agentMap != null) {
+ return agentMap;
+ }
+
return withLockReturning(getClass().getSimpleName() + "::getAgents", () -> {
if (agentMap == null) {
agentMap = assetStorageService.findAll(
diff --git a/manager/src/main/java/org/openremote/manager/datapoint/AssetPredictedDatapointService.java b/manager/src/main/java/org/openremote/manager/datapoint/AssetPredictedDatapointService.java
index e84a848b9..24520475b 100644
--- a/manager/src/main/java/org/openremote/manager/datapoint/AssetPredictedDatapointService.java
+++ b/manager/src/main/java/org/openremote/manager/datapoint/AssetPredictedDatapointService.java
@@ -34,6 +34,7 @@ import org.openremote.model.attribute.Attribute;
import org.openremote.model.attribute.AttributeRef;
import org.openremote.model.datapoint.DatapointInterval;
import org.openremote.model.datapoint.ValueDatapoint;
+import org.openremote.model.util.Pair;
import org.openremote.model.value.Values;
import org.postgresql.util.PGInterval;
import org.postgresql.util.PGobject;
@@ -46,6 +47,7 @@ import java.time.Instant;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
@@ -277,29 +279,40 @@ public class AssetPredictedDatapointService implements ContainerService, Protoco
}
public void updateValue(String assetId, String attributeName, Object value, LocalDateTime timestamp) {
- persistenceService.doTransaction(em -> upsertValue(em, assetId, attributeName, value, timestamp));
+ updateValues(assetId, attributeName, Collections.singletonList(new Pair<>(value, timestamp)));
}
- protected void upsertValue(EntityManager em, String assetId, String attributeName, Object value, LocalDateTime timestamp) {
- PGobject pgJsonValue = new PGobject();
- pgJsonValue.setType("jsonb");
- try {
- pgJsonValue.setValue(Values.asJSON(value).orElse("null"));
- } catch (SQLException e) {
- LOG.log(Level.WARNING, "Failed to store predicted data point: " + new AttributeRef(assetId, attributeName), e);
- }
+ public void updateValues(String assetId, String attributeName, List<Pair<?, LocalDateTime>> valuesAndTimestamps) {
+ persistenceService.doTransaction(em -> upsertValue(em, assetId, attributeName, valuesAndTimestamps));
+ }
+ protected void upsertValue(EntityManager em, String assetId, String attributeName, List<Pair<?, LocalDateTime>> valuesAndTimestamps) {
em.unwrap(Session.class).doWork(connection -> {
PreparedStatement st = connection.prepareStatement("INSERT INTO asset_predicted_datapoint (entity_id, attribute_name, value, timestamp) \n" +
"VALUES (?, ?, ?, ?)\n" +
"ON CONFLICT (entity_id, attribute_name, timestamp) DO UPDATE \n" +
" SET value = excluded.value");
- st.setString(1, assetId);
- st.setString(2, attributeName);
- st.setObject(3, pgJsonValue);
- st.setObject(4, timestamp);
- st.executeUpdate();
+ valuesAndTimestamps.forEach(valueAndTimestamp -> {
+
+ PGobject pgJsonValue = new PGobject();
+ pgJsonValue.setType("jsonb");
+ try {
+ pgJsonValue.setValue(Values.asJSON(valueAndTimestamp.key).orElse("null"));
+ st.setString(1, assetId);
+ st.setString(2, attributeName);
+ st.setObject(3, pgJsonValue);
+ st.setObject(4, valueAndTimestamp.value);
+ st.addBatch();
+
+ } catch (Exception e) {
+ String msg = "Failed to store predicted data point: " + new AttributeRef(assetId, attributeName);
+ LOG.log(Level.WARNING, msg, e);
+ throw new IllegalStateException(msg, e);
+ }
+ });
+
+ st.executeBatch();
});
}
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 c475fa49f..3eb446f3e 100644
--- a/manager/src/main/java/org/openremote/manager/energy/EnergyOptimisationService.java
+++ b/manager/src/main/java/org/openremote/manager/energy/EnergyOptimisationService.java
@@ -38,6 +38,10 @@ import org.openremote.model.attribute.AttributeEvent;
import org.openremote.model.attribute.AttributeRef;
import org.openremote.model.datapoint.ValueDatapoint;
import org.openremote.model.query.AssetQuery;
+import org.openremote.model.query.LogicGroup;
+import org.openremote.model.query.filter.AttributePredicate;
+import org.openremote.model.query.filter.BooleanPredicate;
+import org.openremote.model.query.filter.StringPredicate;
import org.openremote.model.util.AssetModelUtil;
import org.openremote.model.util.Pair;
import org.openremote.model.value.MetaItemType;
@@ -49,6 +53,7 @@ import java.util.*;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.logging.Level;
@@ -248,18 +253,16 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
EnergyOptimiser optimiser = optimiserAndScheduler.key;
int intervalCount = optimiser.get24HourIntervalCount();
- // Get all child assets
- List<Asset<?>> childElectricityAssets = assetStorageService.findAll(
+ LOG.finest(getLogPrefix(optimisationAssetId) + "Fetching child assets of type '" + ElectricitySupplierAsset.class.getSimpleName() + "'");
+
+ List<ElectricitySupplierAsset> supplierAssets = assetStorageService.findAll(
new AssetQuery()
.select(new AssetQuery.Select().excludePath(true))
+ .types(ElectricitySupplierAsset.class)
.recursive(true)
.parents(optimisationAssetId)
- );
-
- LOG.finest(getLogPrefix(optimisationAssetId) + "Child asset count = " + childElectricityAssets.size());
-
- List<ElectricitySupplierAsset> supplierAssets = childElectricityAssets.stream()
- .filter(asset -> (asset instanceof ElectricitySupplierAsset) && asset.hasAttribute(ElectricitySupplierAsset.TARIFF_IMPORT))
+ ).stream()
+ .filter(asset -> asset.hasAttribute(ElectricitySupplierAsset.TARIFF_IMPORT))
.map(asset -> (ElectricitySupplierAsset)asset)
.collect(Collectors.toList());
@@ -268,34 +271,70 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
return;
}
- List<ElectricityStorageAsset> optimisableStorageAssets = childElectricityAssets.stream()
- .filter(asset -> (asset instanceof ElectricityStorageAsset)
- && asset.hasAttribute(ElectricityAsset.POWER_SETPOINT))
+ if (LOG.isLoggable(Level.FINEST)) {
+ LOG.finest(getLogPrefix(optimisationAssetId) + "Found child asset of type '" + ElectricitySupplierAsset.class.getSimpleName() + "': " + supplierAssets.get(0));
+ }
+
+ LOG.finest(getLogPrefix(optimisationAssetId) + "Fetching optimisable child assets of type '" + ElectricityStorageAsset.class.getSimpleName() + "'");
+
+ AssetQuery query = new AssetQuery()
+ .select(new AssetQuery.Select().excludePath(true))
+ .recursive(true)
+ .parents(optimisationAssetId)
+ .types(ElectricityStorageAsset.class)
+ .attributes(new AttributePredicate().name(new StringPredicate(ElectricityAsset.POWER_SETPOINT.getName())));
+ query.attributes.groups = new ArrayList<>();
+ query.attributes.groups.add(
+ new LogicGroup<>(
+ LogicGroup.Operator.OR,
+ new AttributePredicate(ElectricityStorageAsset.SUPPORTS_IMPORT.getName(), new BooleanPredicate(true)),
+ new AttributePredicate(ElectricityStorageAsset.SUPPORTS_EXPORT.getName(), new BooleanPredicate(true)))
+ );
+
+ List<ElectricityStorageAsset> optimisableStorageAssets = assetStorageService.findAll(query).stream()
.map(asset -> (ElectricityStorageAsset)asset)
.sorted(Comparator.comparingInt(asset -> asset.getEnergyLevelSchedule().map(schedule -> 0).orElse(1)))
.collect(Collectors.toList());
if (optimisableStorageAssets.isEmpty()) {
- LOG.warning(getLogPrefix(optimisationAssetId) + "Expected at least one " + ElectricityStorageAsset.class.getSimpleName() + " asset with a '" + ElectricityAsset.POWER_SETPOINT.getName() + "' attribute but found none");
+ LOG.warning(getLogPrefix(optimisationAssetId) + "Expected at least one optimisable '" + ElectricityStorageAsset.class.getSimpleName() + " asset with a '" + ElectricityAsset.POWER_SETPOINT.getName() + "' attribute but found none");
return;
}
+ if (LOG.isLoggable(Level.FINEST)) {
+ LOG.finest(getLogPrefix(optimisationAssetId) + "Found optimisable child assets of type '" + ElectricityStorageAsset.class.getSimpleName() + "': " + optimisableStorageAssets.stream().map(Asset::getId).collect(Collectors.joining(", ")));
+ }
+
// Get consumers and producers and sum power demand for the next 24hrs
double[] powerNets = new double[intervalCount];
- childElectricityAssets.stream()
- .filter(asset ->
- // 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))
+ LOG.finest(getLogPrefix(optimisationAssetId) + "Fetching child assets of type '" + ElectricityProducerAsset.class.getSimpleName() + "', '" + ElectricityConsumerAsset.class.getSimpleName() + "', '" + GroupAsset.class.getSimpleName() + "' (with child type of consumer or producer)");
+
+ AtomicInteger count = new AtomicInteger(0);
+ assetStorageService.findAll(
+ new AssetQuery()
+ .select(new AssetQuery.Select().excludePath(true))
+ .recursive(true)
+ .parents(optimisationAssetId)
+ .types(ElectricityConsumerAsset.class, ElectricityProducerAsset.class, GroupAsset.class)
+ .attributes(new AttributePredicate().name(new StringPredicate(ElectricityAsset.POWER.getName())))
+ )
+ .stream()
+ .filter(asset -> !(asset instanceof GroupAsset) || isElectricityGroupAsset(asset))
.forEach(asset -> {
@SuppressWarnings("OptionalGetWithoutIsPresent")
Attribute<Double> powerAttribute = asset.getAttribute(ElectricityAsset.POWER).get();
double[] powerLevels = get24HAttributeValues(asset.getId(), powerAttribute, optimiser.getIntervalSize(), intervalCount, optimisationTime);
IntStream.range(0, intervalCount).forEach(i -> powerNets[i] += powerLevels[i]);
+ count.incrementAndGet();
});
+ if (LOG.isLoggable(Level.FINEST)) {
+ LOG.finest(getLogPrefix(optimisationAssetId) + "Found child assets of type '" + ElectricityProducerAsset.class.getSimpleName() + "', '" + ElectricityConsumerAsset.class.getSimpleName() + "', '" + GroupAsset.class.getSimpleName() + "' (with child type of consumer or producer): count=" + count.get());
+ LOG.finest("Calculated net power of consumers and producers: " + Arrays.toString(powerNets));
+ LOG.finest("Getting supply costs for each interval");
+ }
+
// Get supplier costs for each interval
ElectricitySupplierAsset supplierAsset = supplierAssets.get(0);
double financialWeightingImport = optimiser.getFinancialWeighting();
@@ -338,25 +377,49 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
Arrays.fill(exportPowerMaxes, exportPowerMax);
long periodSeconds = (long)(optimiser.getIntervalSize()*60*60);
- optimisableStorageAssets.forEach(storageAsset -> {
+ LOG.finer(getLogPrefix(optimisationAssetId) + "Optimising each storage asset");
- double[] setpoints = getStoragePowerSetpoints(optimiser, optimisationAssetId, storageAsset, powerNets, importPowerMaxes, exportPowerMaxes, costsImport, costsExport);
+ for (ElectricityStorageAsset storageAsset : optimisableStorageAssets) {
+ boolean hasSetpoint = storageAsset.hasAttribute(ElectricityStorageAsset.POWER_SETPOINT);
+ boolean supportsExport = storageAsset.isSupportsExport().orElse(false);
+ boolean supportsImport = storageAsset.isSupportsImport().orElse(false);
+
+ if (LOG.isLoggable(Level.FINEST)) {
+ LOG.finest("Optimising power set points for storage asset: " + storageAsset);
+ }
- // Assume these setpoints will be applied so update the power net values with these
- for (int i = 0; i < powerNets.length; i++) {
- powerNets[i] += setpoints[i];
+ if (!supportsExport && !supportsImport) {
+ LOG.finest(getLogPrefix(optimisationAssetId) + "Storage asset doesn't support import or export: " + storageAsset.getId());
+ continue;
}
- // Push the setpoints into the prediction service for the storage asset's setpoint attribute and set current setpoint
- for (int i = 1; i < setpoints.length; i++) {
- assetPredictedDatapointService.updateValue(
- new AttributeRef(storageAsset.getId(), ElectricityAsset.POWER_SETPOINT.getName()),
- setpoints[i],
- LocalDateTime.ofInstant(optimisationTime.plus(periodSeconds*i, ChronoUnit.SECONDS), ZoneId.systemDefault()));
+ if (!hasSetpoint) {
+ LOG.info(getLogPrefix(optimisationAssetId) + "Storage asset has no '" + ElectricityStorageAsset.POWER_SETPOINT.getName() + "' attribute so cannot be controlled: " + storageAsset.getId());
+ continue;
}
- assetProcessingService.sendAttributeEvent(new AttributeEvent(storageAsset.getId(), ElectricityAsset.POWER_SETPOINT, setpoints[0]));
- });
+ double[] setpoints = getStoragePowerSetpoints(optimiser, optimisationAssetId, storageAsset, powerNets, importPowerMaxes, exportPowerMaxes, costsImport, costsExport);
+
+ if (setpoints != null) {
+
+ // Assume these setpoints will be applied so update the power net values with these
+ for (int i = 0; i < powerNets.length; i++) {
+ powerNets[i] += setpoints[i];
+ }
+
+ // Push the setpoints into the prediction service for the storage asset's setpoint attribute and set current setpoint
+ List<Pair<?, LocalDateTime>> valuesAndTimestamps = IntStream.range(1, setpoints.length).mapToObj(i ->
+ new Pair<>(setpoints[i],
+ LocalDateTime.ofInstant(optimisationTime.plus(periodSeconds * i, ChronoUnit.SECONDS), ZoneId.systemDefault()))
+ ).collect(Collectors.toList());
+
+ assetPredictedDatapointService.updateValues(storageAsset.getId(), ElectricityAsset.POWER_SETPOINT.getName(), valuesAndTimestamps);
+ }else {
+ LOG.finest("Cannot optimise power set points for storage asset: " + storageAsset.getId());
+ }
+
+ assetProcessingService.sendAttributeEvent(new AttributeEvent(storageAsset.getId(), ElectricityAsset.POWER_SETPOINT, setpoints != null ? setpoints[0] : null));
+ }
}
protected boolean isElectricityGroupAsset(Asset<?> asset) {
@@ -416,33 +479,25 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
protected double[] getStoragePowerSetpoints(EnergyOptimiser optimiser, String optimisationAssetId, ElectricityStorageAsset storageAsset, double[] powerNets, double[] importPowerLimits, double[] exportPowerLimits, double[] costImports, double[] costExports) {
int intervalCount = powerNets.length;
- boolean hasSetpoint = storageAsset.hasAttribute(ElectricityStorageAsset.POWER_SETPOINT);
boolean supportsExport = storageAsset.isSupportsExport().orElse(false);
boolean supportsImport = storageAsset.isSupportsImport().orElse(false);
- if (!supportsExport && !supportsImport) {
- LOG.finest(getLogPrefix(optimisationAssetId) + "Storage asset doesn't support import or export: " + storageAsset.getId());
- return new double[intervalCount];
- }
-
LOG.finer(getLogPrefix(optimisationAssetId) + "Optimising storage asset: " + storageAsset);
- if (!hasSetpoint) {
- LOG.info(getLogPrefix(optimisationAssetId) + "Storage asset has no '" + ElectricityStorageAsset.POWER_SETPOINT.getName() + "' attribute so cannot be controlled: " + storageAsset.getId());
- return new double[intervalCount];
- }
-
double energyCapacity = storageAsset.getEnergyCapacity().orElse(0d);
double energyLevel = Math.min(energyCapacity, storageAsset.getEnergyLevel().orElse(-1d));
if (energyCapacity <= 0d || energyLevel < 0) {
LOG.info(getLogPrefix(optimisationAssetId) + "Storage asset has no capacity or energy level so cannot import or export energy: " + storageAsset.getId());
- return new double[intervalCount];
+ return null;
}
double energyLevelMax = Math.min(energyCapacity, ((double) storageAsset.getEnergyLevelPercentageMax().orElse(100) / 100) * energyCapacity);
double energyLevelMin = Math.min(energyCapacity, ((double) storageAsset.getEnergyLevelPercentageMin().orElse(0) / 100) * energyCapacity);
double[] energyLevelMins = new double[intervalCount];
+ double[] energyLevelMaxs = new double[intervalCount];
+ Arrays.fill(energyLevelMins, energyLevelMin);
+ Arrays.fill(energyLevelMaxs, energyLevelMax);
// Does the storage support import and have an energy level schedule
Optional<Integer[][]> energyLevelScheduleOptional = storageAsset.getEnergyLevelSchedule();
@@ -453,7 +508,7 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
if (energySchedule != null) {
LOG.finer(getLogPrefix(optimisationAssetId) + "Applying energy schedule for storage asset: " + storageAsset.getId());
- optimiser.applyEnergySchedule(energyLevelMins, energyCapacity, energyLevelMin, energyLevelMax, energySchedule, LocalDateTime.ofInstant(Instant.ofEpochMilli(timerService.getCurrentTimeMillis()), ZoneId.systemDefault()));
+ optimiser.applyEnergySchedule(energyLevelMins, energyLevelMaxs, energyCapacity, energySchedule, LocalDateTime.ofInstant(Instant.ofEpochMilli(timerService.getCurrentTimeMillis()), ZoneId.systemDefault()));
}
// TODO: Make these a function of energy level
@@ -470,10 +525,7 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
double[] powerSetpoints = new double[intervalCount];
Function<Integer, Double> energyLevelCalculator = interval ->
- Math.min(
- energyLevelMax,
- energyLevel + IntStream.range(0, interval).mapToDouble(j -> powerSetpoints[j] * optimiser.getIntervalSize()).sum()
- );
+ energyLevel + IntStream.range(0, interval).mapToDouble(j -> powerSetpoints[j] * optimiser.getIntervalSize()).sum();
// If asset supports exporting energy (V2G, battery storage, etc.) then need to determine if there are
// opportunities to export energy to save/earn, taking into consideration the cost of exporting from this asset
@@ -501,7 +553,7 @@ public class EnergyOptimisationService extends RouteBuilder implements Container
}
LOG.finer(getLogPrefix(optimisationAssetId) + "Applying earning opportunities for storage asset: " + storageAsset.getId());
- optimiser.applyEarningOpportunities(importCostAndPower, exportCostAndPower, energyLevelMins, powerSetpoints, energyLevelCalculator, powerImportMaxCalculator, powerExportMaxCalculator, energyLevelMax);
+ optimiser.applyEarningOpportunities(importCostAndPower, exportCostAndPower, energyLevelMins, energyLevelMaxs, powerSetpoints, energyLevelCalculator, powerImportMaxCalculator, powerExportMaxCalculator);
if (LOG.isLoggable(Level.FINER)) {
LOG.finer(getLogPrefix(optimisationAssetId) + "Calculated earning opportunity power set points = " + Arrays.toString(powerSetpoints));
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 1ddc89bf4..d5d2e0f99 100644
--- a/manager/src/main/java/org/openremote/manager/energy/EnergyOptimiser.java
+++ b/manager/src/main/java/org/openremote/manager/energy/EnergyOptimiser.java
@@ -186,15 +186,12 @@ public class EnergyOptimiser {
* 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, LocalDateTime currentTime) {
+ public void applyEnergySchedule(double[] energyLevelMins, double[] energyLevelMaxs, double energyCapacity, int[][] energyLevelSchedule, LocalDateTime currentTime) {
if (energyLevelSchedule == null) {
return;
}
- energyLevelMin = Math.min(energyLevelMax, Math.max(0d, energyLevelMin));
- Arrays.fill(energyLevelMins, energyLevelMin);
-
// 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)
OffsetDateTime date = currentTime.plus(1, ChronoUnit.HOURS).atOffset(ZoneOffset.UTC);
int dayIndex = date.getDayOfWeek().getValue();
@@ -219,7 +216,7 @@ public class EnergyOptimiser {
for (i = 0; i < schedule.length; i++) {
// Put energy level schedule value into first interval for the hour
- energyLevelMins[(hourIntervals * i)] = Math.min(energyLevelMax, Math.max(energyLevelMins[(hourIntervals * i)], schedule[i]));
+ energyLevelMins[(hourIntervals * i)] = Math.min(energyLevelMaxs[hourIntervals * i], Math.max(energyLevelMins[hourIntervals * i], schedule[i]));
}
} else {
int takeSize = (int) intervalSize;
@@ -227,7 +224,7 @@ public class EnergyOptimiser {
for (i = 0; i < hourIntervals; i++) {
// Take largest energy level for the intervals
- energyLevelMins[i] = Math.min(energyLevelMax, Math.max(energyLevelMins[i], java.util.Arrays.stream(schedule, (i * takeSize), (i * takeSize) + takeSize).max().orElse(0)));
+ energyLevelMins[i] = Math.min(energyLevelMaxs[i], Math.max(energyLevelMins[i], java.util.Arrays.stream(schedule, (i * takeSize), (i * takeSize) + takeSize).max().orElse(0)));
}
}
}
@@ -363,7 +360,7 @@ public class EnergyOptimiser {
* 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) {
+ public void applyEarningOpportunities(double[][] importCostAndPower, double[][] exportCostAndPower, double[] energyLevelMins, double[] energyLevelMaxs, double[] powerSetpoints, Function<Integer, Double> energyLevelCalculator, Function<Integer, Double> powerImportMaxCalculator, Function<Integer, Double> powerExportMaxCalculator) {
// Look for import and export earning opportunities
double[][] primary = importCostAndPower != null ? importCostAndPower : exportCostAndPower; // Never null
@@ -393,14 +390,14 @@ public class EnergyOptimiser {
// import opportunity and interval still available to import power
//noinspection ConstantConditions
- applyImportOpportunity(importCostAndPower, exportCostAndPower, energyLevelMins, powerSetpoints, energyLevelCalculator, powerImportMaxCalculator, powerExportMaxCalculator, interval, energyLevelMax);
+ applyImportOpportunity(importCostAndPower, exportCostAndPower, energyLevelMins, energyLevelMaxs, powerSetpoints, energyLevelCalculator, powerImportMaxCalculator, powerExportMaxCalculator, interval);
LOG.finest("Applied import earning opportunity: interval=" + interval + ", set point=" + powerSetpoints[interval]);
} else if (isExportOpportunity(costAndPower, powerSetpoints[interval], interval, powerExportMaxCalculator)) {
// export opportunity and interval still available to export power
//noinspection ConstantConditions
- applyExportOpportunity(importCostAndPower, exportCostAndPower, energyLevelMins, powerSetpoints, energyLevelCalculator, powerImportMaxCalculator, powerExportMaxCalculator, interval, energyLevelMax);
+ applyExportOpportunity(importCostAndPower, exportCostAndPower, energyLevelMins, energyLevelMaxs, powerSetpoints, energyLevelCalculator, powerImportMaxCalculator, powerExportMaxCalculator, interval);
LOG.finest("Applied export earning opportunity: interval=" + interval + ", set point=" + powerSetpoints[interval]);
}
}
@@ -420,7 +417,7 @@ public class EnergyOptimiser {
* interval then an earlier cost effective export opportunity will be attempted to offset the requirement. The
* powerSetpoints will be updated as a result.
*/
- 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) {
+ public void applyImportOpportunity(double[][] importCostAndPower, double[][] exportCostAndPower, double[] energyLevelMins, double[] energyLevelMaxs, double[] powerSetpoints, Function<Integer, Double> energyLevelCalculator, Function<Integer, Double> powerImportMaxCalculator, Function<Integer, Double> powerExportMaxCalculator, int interval) {
double[] costAndPower = importCostAndPower[interval];
double impPowerMin = costAndPower[1];
double impPowerMax = Math.min(powerImportMaxCalculator.apply(interval), costAndPower[2]);
@@ -431,7 +428,7 @@ public class EnergyOptimiser {
return;
}
- double energySpace = energyLevelMax - energyLevelCalculator.apply(interval);
+ double energySpace = energyLevelMaxs[interval] - energyLevelCalculator.apply(interval);
double energySpaceMax = powerCapacity * intervalSize;
double energySpaceMin = impPowerMin * intervalSize;
List<Pair<Integer, Double>> pastIntervalPowerDeltas = new ArrayList<>();
@@ -524,7 +521,7 @@ public class EnergyOptimiser {
* interval then an earlier cost effective import opportunity will be attempted to offset the requirement. The
* powerSetpoints will be updated as a result.
*/
- 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) {
+ public void applyExportOpportunity(double[][] importCostAndPower, double[][] exportCostAndPower, double[] energyLevelMins, double[] energyLevelMaxs, double[] powerSetpoints, Function<Integer, Double> energyLevelCalculator, Function<Integer, Double> powerImportMaxCalculator, Function<Integer, Double> powerExportMaxCalculator, int interval) {
double[] costAndPower = exportCostAndPower[interval];
double expPowerMin = costAndPower[2];
double expPowerMax = Math.max(powerExportMaxCalculator.apply(interval), costAndPower[1]);
@@ -610,14 +607,14 @@ public class EnergyOptimiser {
}
double energySpaceMin = pastCostAndPower[1] * intervalSize;
- double energySpace = energyLevelMax - energyLevelCalculator.apply(pastInterval);
+ double energySpace = energyLevelMaxs[interval] - 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);
+ double futureEnergySpace = energyLevelMaxs[k] - energyLevelCalculator.apply(k);
energySpace = Math.min(energySpace, futureEnergySpace);
k++;
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesBuilder.java b/manager/src/main/java/org/openremote/manager/rules/RulesBuilder.java
index 4505fb84f..054416d0d 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesBuilder.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesBuilder.java
@@ -114,7 +114,6 @@ public class RulesBuilder {
}
})
.then(facts -> {
- RULES_FIRED_LOG.info("Rule fired '" + builder.name + "'");
builder.action.execute((RulesFacts) facts);
}).build();
rules.add(rule);
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java b/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
index f37b29060..27c709149 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
@@ -502,7 +502,7 @@ public class RulesEngine<T extends Ruleset> {
long startTimestamp = System.currentTimeMillis();
lastFireTimestamp = startTimestamp;
engine.fire(deployment.getRules(), facts);
- RULES_LOG.fine("Rules executed in: " + (System.currentTimeMillis() - startTimestamp) + "ms");
+ RULES_FIRED_LOG.fine("Rules deployment '" + deployment.getName() + "' executed in: " + (System.currentTimeMillis() - startTimestamp) + "ms");
}
} catch (Exception ex) {
diff --git a/model/src/main/java/org/openremote/model/query/AssetQuery.java b/model/src/main/java/org/openremote/model/query/AssetQuery.java
index 5de4ec254..a7948a155 100644
--- a/model/src/main/java/org/openremote/model/query/AssetQuery.java
+++ b/model/src/main/java/org/openremote/model/query/AssetQuery.java
@@ -345,8 +345,14 @@ public class AssetQuery {
return this;
}
+ @SuppressWarnings("unchecked")
+ public final <T extends Asset<?>> AssetQuery types(Class<T> type) {
+ this.types = new Class[] {type};
+ return this;
+ }
+
@SafeVarargs
- public final <T extends Asset<?>> AssetQuery types(Class<T>... types) {
+ public final AssetQuery types(Class<? extends Asset<?>>... types) {
if (types == null || types.length == 0) {
this.types = null;
return this;