Examples with BooleanPredicate org.openremote.model.query.filter.BooleanPredicate used on opensource projects

Example 1 with BooleanPredicate

use of org.openremote.model.query.filter.BooleanPredicate in project openremote by openremote.

the class EnergyOptimisationService method runOptimisation.

/**
 * Runs the optimisation routine for the specified time; it is important that this method does not throw an
 * exception as it will cancel the scheduled task thus stopping future optimisations.
 */
protected void runOptimisation(String optimisationAssetId, Instant optimisationTime) {
    OptimisationInstance optimisationInstance = assetOptimisationInstanceMap.get(optimisationAssetId);
    if (optimisationInstance == null) {
        return;
    }
    LOG.finer(getLogPrefix(optimisationAssetId) + "Running for time '" + formatter.format(optimisationTime));
    EnergyOptimiser optimiser = optimisationInstance.energyOptimiser;
    int intervalCount = optimiser.get24HourIntervalCount();
    double intervalSize = optimiser.getIntervalSize();
    LOG.finest(getLogPrefix(optimisationAssetId) + "Fetching child assets of type '" + ElectricitySupplierAsset.class.getSimpleName() + "'");
    List<ElectricitySupplierAsset> supplierAssets = assetStorageService.findAll(new AssetQuery().types(ElectricitySupplierAsset.class).recursive(true).parents(optimisationAssetId)).stream().filter(asset -> asset.hasAttribute(ElectricitySupplierAsset.TARIFF_IMPORT)).map(asset -> (ElectricitySupplierAsset) asset).collect(Collectors.toList());
    if (supplierAssets.size() != 1) {
        LOG.warning(getLogPrefix(optimisationAssetId) + "Expected exactly one " + ElectricitySupplierAsset.class.getSimpleName() + " asset with a '" + ElectricitySupplierAsset.TARIFF_IMPORT.getName() + "' attribute but found: " + supplierAssets.size());
        return;
    }
    double[] powerNets = new double[intervalCount];
    ElectricitySupplierAsset supplierAsset = supplierAssets.get(0);
    if (LOG.isLoggable(Level.FINEST)) {
        LOG.finest(getLogPrefix(optimisationAssetId) + "Found child asset of type '" + ElectricitySupplierAsset.class.getSimpleName() + "': " + supplierAsset);
    }
    // Do some basic validation
    if (supplierAsset.getTariffImport().isPresent()) {
        LOG.warning(getLogPrefix(optimisationAssetId) + ElectricitySupplierAsset.class.getSimpleName() + " asset '" + ElectricitySupplierAsset.TARIFF_IMPORT.getName() + "' attribute has no value");
    }
    LOG.finest(getLogPrefix(optimisationAssetId) + "Fetching optimisable child assets of type '" + ElectricityStorageAsset.class.getSimpleName() + "'");
    List<ElectricityStorageAsset> optimisableStorageAssets = assetStorageService.findAll(new AssetQuery().recursive(true).parents(optimisationAssetId).types(ElectricityStorageAsset.class).attributes(new LogicGroup<>(LogicGroup.Operator.AND, Collections.singletonList(new LogicGroup<>(LogicGroup.Operator.OR, new AttributePredicate(ElectricityStorageAsset.SUPPORTS_IMPORT.getName(), new BooleanPredicate(true)), new AttributePredicate(ElectricityStorageAsset.SUPPORTS_EXPORT.getName(), new BooleanPredicate(true)))), new AttributePredicate().name(new StringPredicate(ElectricityAsset.POWER_SETPOINT.getName()))))).stream().map(asset -> (ElectricityStorageAsset) asset).collect(Collectors.toList());
    List<ElectricityStorageAsset> finalOptimisableStorageAssets = optimisableStorageAssets;
    optimisableStorageAssets = optimisableStorageAssets.stream().filter(asset -> {
        // Exclude force charged assets (so we don't mess with the setpoint)
        if (forceChargeAssetIds.contains(asset.getId())) {
            LOG.finest("Optimisable asset was requested to force charge so it won't be optimised: " + asset.getId());
            @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]);
            double currentEnergyLevel = asset.getEnergyLevel().orElse(0d);
            double maxEnergyLevel = getElectricityStorageAssetEnergyLevelMax(asset);
            if (currentEnergyLevel >= maxEnergyLevel) {
                LOG.info("Force charged asset has reached maxEnergyLevelPercentage so stopping charging: " + asset.getId());
                forceChargeAssetIds.remove(asset.getId());
                assetProcessingService.sendAttributeEvent(new AttributeEvent(asset.getId(), ElectricityStorageAsset.POWER_SETPOINT, 0d));
                assetProcessingService.sendAttributeEvent(new AttributeEvent(asset.getId(), ElectricityStorageAsset.FORCE_CHARGE, AttributeExecuteStatus.COMPLETED));
            }
            return false;
        }
        if (asset instanceof ElectricityChargerAsset) {
            // Check if it has a child vehicle asset
            return finalOptimisableStorageAssets.stream().noneMatch(a -> {
                if (a instanceof ElectricVehicleAsset && a.getParentId().equals(asset.getId())) {
                    // Take the lowest power max from vehicle or charger
                    double vehiclePowerImportMax = a.getPowerImportMax().orElse(Double.MAX_VALUE);
                    double vehiclePowerExportMax = a.getPowerExportMax().orElse(Double.MAX_VALUE);
                    double chargerPowerImportMax = asset.getPowerImportMax().orElse(Double.MAX_VALUE);
                    double chargerPowerExportMax = asset.getPowerExportMax().orElse(Double.MAX_VALUE);
                    double smallestPowerImportMax = Math.min(vehiclePowerImportMax, chargerPowerImportMax);
                    double smallestPowerExportMax = Math.min(vehiclePowerExportMax, chargerPowerExportMax);
                    if (smallestPowerImportMax < vehiclePowerImportMax) {
                        LOG.fine("Reducing vehicle power import max due to connected charger limit: vehicle=" + a.getId() + ", oldPowerImportMax=" + vehiclePowerImportMax + ", newPowerImportMax=" + smallestPowerImportMax);
                        a.setPowerImportMax(smallestPowerImportMax);
                    }
                    if (smallestPowerExportMax < vehiclePowerExportMax) {
                        LOG.fine("Reducing vehicle power Export max due to connected charger limit: vehicle=" + a.getId() + ", oldPowerExportMax=" + vehiclePowerExportMax + ", newPowerExportMax=" + smallestPowerExportMax);
                        a.setPowerExportMax(smallestPowerExportMax);
                    }
                    LOG.finest("Excluding charger from optimisable assets and child vehicle will be used instead: " + asset.getId());
                    return true;
                }
                return false;
            });
        }
        return true;
    }).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 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(", ")));
    }
    LOG.finest(getLogPrefix(optimisationAssetId) + "Fetching plain consumer and producer child assets of type '" + ElectricityProducerAsset.class.getSimpleName() + "', '" + ElectricityConsumerAsset.class.getSimpleName() + "', '" + ElectricityStorageAsset.class.getSimpleName() + "'");
    AtomicInteger count = new AtomicInteger(0);
    assetStorageService.findAll(new AssetQuery().recursive(true).parents(optimisationAssetId).types(ElectricityConsumerAsset.class, ElectricityProducerAsset.class).attributes(new AttributePredicate().name(new StringPredicate(ElectricityAsset.POWER.getName())))).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();
    });
    // Get power of storage assets that don't support neither import or export (treat them as plain consumers/producers)
    List<ElectricityStorageAsset> plainStorageAssets = assetStorageService.findAll(new AssetQuery().recursive(true).parents(optimisationAssetId).types(ElectricityStorageAsset.class).attributes(new AttributePredicate().name(new StringPredicate(ElectricityAsset.POWER.getName())), new AttributePredicate(ElectricityStorageAsset.SUPPORTS_IMPORT.getName(), new BooleanPredicate(true), true, null), new AttributePredicate(ElectricityStorageAsset.SUPPORTS_EXPORT.getName(), new BooleanPredicate(true), true, null))).stream().map(asset -> (ElectricityStorageAsset) asset).collect(Collectors.toList());
    // Exclude chargers with a power value != 0 and a child vehicle with a power value != 0 (avoid double counting - vehicle takes priority)
    plainStorageAssets.stream().filter(asset -> {
        if (asset instanceof ElectricityChargerAsset) {
            // Check if it has a child vehicle asset also check optimisable assets as child vehicle could be in there
            return plainStorageAssets.stream().noneMatch(a -> {
                if (a instanceof ElectricVehicleAsset && a.getParentId().equals(asset.getId())) {
                    LOG.finest("Excluding charger from plain consumer/producer calculations to avoid double counting power: " + asset.getId());
                    return true;
                }
                return false;
            }) && finalOptimisableStorageAssets.stream().noneMatch(a -> {
                if (a instanceof ElectricVehicleAsset && a.getParentId().equals(asset.getId())) {
                    LOG.finest("Excluding charger from plain consumer/producer calculations to avoid double counting power: " + asset.getId());
                    return true;
                }
                return false;
            });
        }
        return true;
    }).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.FINER)) {
        LOG.finer(getLogPrefix(optimisationAssetId) + "Found plain consumer and producer child assets count=" + count.get());
        LOG.finer("Calculated net power of consumers and producers: " + Arrays.toString(powerNets));
    }
    // Get supplier costs for each interval
    double financialWeightingImport = optimiser.getFinancialWeighting();
    double financialWeightingExport = optimiser.getFinancialWeighting();
    if (financialWeightingImport < 1d && !supplierAsset.getCarbonImport().isPresent()) {
        financialWeightingImport = 1d;
    }
    if (financialWeightingExport < 1d && !supplierAsset.getCarbonExport().isPresent()) {
        financialWeightingExport = 1d;
    }
    double[] costsImport = get24HAttributeValues(supplierAsset.getId(), supplierAsset.getAttribute(ElectricitySupplierAsset.TARIFF_IMPORT).orElse(null), optimiser.getIntervalSize(), intervalCount, optimisationTime);
    double[] costsExport = get24HAttributeValues(supplierAsset.getId(), supplierAsset.getAttribute(ElectricitySupplierAsset.TARIFF_EXPORT).orElse(null), optimiser.getIntervalSize(), intervalCount, optimisationTime);
    if (financialWeightingImport < 1d || financialWeightingExport < 1d) {
        double[] carbonImport = get24HAttributeValues(supplierAsset.getId(), supplierAsset.getAttribute(ElectricitySupplierAsset.CARBON_IMPORT).orElse(null), optimiser.getIntervalSize(), intervalCount, optimisationTime);
        double[] carbonExport = get24HAttributeValues(supplierAsset.getId(), supplierAsset.getAttribute(ElectricitySupplierAsset.CARBON_EXPORT).orElse(null), optimiser.getIntervalSize(), intervalCount, optimisationTime);
        LOG.finer(getLogPrefix(optimisationAssetId) + "Adjusting costs to include some carbon weighting, financialWeightingImport=" + financialWeightingImport + ", financialWeightingExport=" + financialWeightingExport);
        for (int i = 0; i < costsImport.length; i++) {
            costsImport[i] = (financialWeightingImport * costsImport[i]) + ((1 - financialWeightingImport) * carbonImport[i]);
            costsExport[i] = (financialWeightingExport * costsExport[i]) + ((1 - financialWeightingExport) * carbonExport[i]);
        }
    }
    if (LOG.isLoggable(Level.FINER)) {
        LOG.finer(getLogPrefix(optimisationAssetId) + "Import costs: " + Arrays.toString(costsImport));
        LOG.finer(getLogPrefix(optimisationAssetId) + "Export costs: " + Arrays.toString(costsExport));
    }
    // Savings variables
    List<String> obsoleteUnoptimisedAssetIds = new ArrayList<>(optimisationInstance.unoptimisedStorageAssetEnergyLevels.keySet());
    double unoptimisedPower = powerNets[0];
    double financialCost = 0d;
    double carbonCost = 0d;
    double unoptimisedFinancialCost = 0d;
    double unoptimisedCarbonCost = 0d;
    // Optimise storage assets with priority on storage assets with an energy schedule (already sorted above)
    double importPowerMax = supplierAsset.getPowerImportMax().orElse(Double.MAX_VALUE);
    double exportPowerMax = -1 * supplierAsset.getPowerExportMax().orElse(Double.MAX_VALUE);
    double[] importPowerMaxes = new double[intervalCount];
    double[] exportPowerMaxes = new double[intervalCount];
    Arrays.fill(importPowerMaxes, importPowerMax);
    Arrays.fill(exportPowerMaxes, exportPowerMax);
    long periodSeconds = (long) (optimiser.getIntervalSize() * 60 * 60);
    for (ElectricityStorageAsset storageAsset : optimisableStorageAssets) {
        boolean hasSetpoint = storageAsset.hasAttribute(ElectricityStorageAsset.POWER_SETPOINT);
        boolean supportsExport = storageAsset.isSupportsExport().orElse(false);
        boolean supportsImport = storageAsset.isSupportsImport().orElse(false);
        LOG.finer(getLogPrefix(optimisationAssetId) + "Optimising power set points for storage asset: " + storageAsset);
        if (!supportsExport && !supportsImport) {
            LOG.finest(getLogPrefix(optimisationAssetId) + "Storage asset doesn't support import or export: " + storageAsset.getId());
            continue;
        }
        if (!hasSetpoint) {
            LOG.info(getLogPrefix(optimisationAssetId) + "Storage asset has no '" + ElectricityStorageAsset.POWER_SETPOINT.getName() + "' attribute so cannot be controlled: " + storageAsset.getId());
            continue;
        }
        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());
            continue;
        }
        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();
        boolean hasEnergyMinRequirement = energyLevelMin > 0 || energyLevelScheduleOptional.isPresent();
        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(i -> i != null ? i : 0).toArray()).toArray(int[][]::new)).orElse(null);
        if (energySchedule != null) {
            LOG.finer(getLogPrefix(optimisationAssetId) + "Applying energy schedule for storage asset: " + storageAsset.getId());
            optimiser.applyEnergySchedule(energyLevelMins, energyLevelMaxs, energyCapacity, energySchedule, LocalDateTime.ofInstant(Instant.ofEpochMilli(timerService.getCurrentTimeMillis()), ZoneId.systemDefault()));
        }
        double maxEnergyLevelMin = Arrays.stream(energyLevelMins).max().orElse(0);
        boolean isConnected = storageAssetConnected(storageAsset);
        // TODO: Make these a function of energy level
        Function<Integer, Double> powerImportMaxCalculator = interval -> interval == 0 && !isConnected ? 0 : powerImportMax;
        Function<Integer, Double> powerExportMaxCalculator = interval -> interval == 0 && !isConnected ? 0 : powerExportMax;
        if (hasEnergyMinRequirement) {
            LOG.finer(getLogPrefix(optimisationAssetId) + "Normalising min energy requirements for storage asset: " + storageAsset.getId());
            optimiser.normaliseEnergyMinRequirements(energyLevelMins, powerImportMaxCalculator, powerExportMaxCalculator, energyLevel);
            if (LOG.isLoggable(Level.FINEST)) {
                LOG.finest(getLogPrefix(optimisationAssetId) + "Min energy requirements for storage asset '" + storageAsset.getId() + "': " + Arrays.toString(energyLevelMins));
            }
        }
        // Calculate the power setpoints for this asset and update power net values for each interval
        double[] setpoints = getStoragePowerSetpoints(optimisationInstance, storageAsset, energyLevelMins, energyLevelMaxs, 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++) {
                if (i == 0) {
                    if (!storageAssetConnected(storageAsset)) {
                        LOG.finer("Optimised storage asset not connected so interval 0 will not be counted or actioned: " + storageAsset.getId());
                        setpoints[i] = 0;
                        continue;
                    }
                    // Update savings/cost data with costs specific to this asset
                    if (setpoints[i] > 0) {
                        financialCost += storageAsset.getTariffImport().orElse(0d) * setpoints[i] * intervalSize;
                    } else {
                        financialCost += storageAsset.getTariffExport().orElse(0d) * -1 * setpoints[i] * intervalSize;
                    }
                }
                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);
        }
        assetProcessingService.sendAttributeEvent(new AttributeEvent(storageAsset.getId(), ElectricityAsset.POWER_SETPOINT, setpoints != null ? setpoints[0] : null));
        // Update unoptimised power for this asset
        obsoleteUnoptimisedAssetIds.remove(storageAsset.getId());
        double assetUnoptimisedPower = getStorageUnoptimisedImportPower(optimisationInstance, optimisationAssetId, storageAsset, maxEnergyLevelMin, Math.max(0, powerImportMax - unoptimisedPower));
        unoptimisedPower += assetUnoptimisedPower;
        unoptimisedFinancialCost += storageAsset.getTariffImport().orElse(0d) * assetUnoptimisedPower * intervalSize;
    }
    // Clear out un-optimised data for not found assets
    obsoleteUnoptimisedAssetIds.forEach(optimisationInstance.unoptimisedStorageAssetEnergyLevels.keySet()::remove);
    // Calculate and store savings data
    carbonCost = (powerNets[0] >= 0 ? supplierAsset.getCarbonImport().orElse(0d) : -1 * supplierAsset.getCarbonExport().orElse(0d)) * powerNets[0] * intervalSize;
    financialCost += (powerNets[0] >= 0 ? supplierAsset.getTariffImport().orElse(0d) : -1 * supplierAsset.getTariffExport().orElse(0d)) * powerNets[0] * intervalSize;
    unoptimisedCarbonCost = (unoptimisedPower >= 0 ? supplierAsset.getCarbonImport().orElse(0d) : -1 * supplierAsset.getCarbonExport().orElse(0d)) * unoptimisedPower * intervalSize;
    unoptimisedFinancialCost += (unoptimisedPower >= 0 ? supplierAsset.getTariffImport().orElse(0d) : -1 * supplierAsset.getTariffExport().orElse(0d)) * unoptimisedPower * intervalSize;
    double financialSaving = unoptimisedFinancialCost - financialCost;
    double carbonSaving = unoptimisedCarbonCost - carbonCost;
    LOG.info(getLogPrefix(optimisationAssetId) + "Current interval financial saving = " + financialSaving);
    LOG.info(getLogPrefix(optimisationAssetId) + "Current interval carbon saving = " + carbonSaving);
    financialSaving += optimisationInstance.optimisationAsset.getFinancialSaving().orElse(0d);
    carbonSaving += optimisationInstance.optimisationAsset.getCarbonSaving().orElse(0d);
    // Update in memory asset
    optimisationInstance.optimisationAsset.setFinancialSaving(financialSaving);
    optimisationInstance.optimisationAsset.setCarbonSaving(carbonSaving);
    // Push new values into the DB
    assetProcessingService.sendAttributeEvent(new AttributeEvent(optimisationAssetId, EnergyOptimisationAsset.FINANCIAL_SAVING, financialSaving));
    assetProcessingService.sendAttributeEvent(new AttributeEvent(optimisationAssetId, EnergyOptimisationAsset.CARBON_SAVING, carbonSaving));
}