@atelieruldetehnologii/node-red-custome-solutions 0.62.22

package/multi-inverter/lib/engine-core.js

@@ -0,0 +1,237 @@
+"use strict";
+
+function clamp(value, min, max) {
+    if (!Number.isFinite(value)) return min;
+    return Math.min(Math.max(value, min), max);
+}
+
+function roundAllocations(map) {
+    const out = {};
+    Object.keys(map || {}).forEach(function (k) {
+        out[k] = Math.round(Number(map[k] || 0));
+    });
+    return out;
+}
+
+function capacityOf(list) {
+    return list.reduce(function (sum, inv) { return sum + inv.maxW; }, 0);
+}
+
+function minCapacityOf(list) {
+    return list.reduce(function (sum, inv) { return sum + inv.minW; }, 0);
+}
+
+function totalFreshPower(map) {
+    return Object.keys(map || {}).reduce(function (sum, k) {
+        return sum + Number(map[k] || 0);
+    }, 0);
+}
+
+function weightMap(strategy, list, freshMap) {
+    const weights = {};
+
+    list.forEach(function (inv) {
+        if (strategy === "equal") {
+            weights[inv.id] = 1;
+        } else if (strategy === "max_power") {
+            weights[inv.id] = inv.maxW;
+        } else if (strategy === "headroom") {
+            const current = Number(freshMap[inv.id] || 0);
+            weights[inv.id] = Math.max(0, inv.maxW - current);
+        } else {
+            const current = Number(freshMap[inv.id] || 0);
+            weights[inv.id] = Math.max(0, current);
+        }
+    });
+
+    return weights;
+}
+
+function chooseEffectiveStrategy(strategy, activeList, freshMap, staleList) {
+    if (strategy !== "current_power") return strategy;
+
+    const haveFreshForAll = staleList.length === 0 && activeList.length > 0;
+    const positiveFresh = Object.values(freshMap).some(function (v) { return Number(v) > 0; });
+
+    if (haveFreshForAll && positiveFresh) {
+        return "current_power";
+    }
+
+    return "max_power";
+}
+
+function allocateIterative(siteLimitW, activeList, freshMap, strategy) {
+    const allocations = {};
+
+    activeList.forEach(function (inv) {
+        allocations[inv.id] = 0;
+    });
+
+    if (activeList.length === 0) {
+        return {
+            allocations: allocations,
+            clipped: siteLimitW > 0,
+            unallocatedW: Math.max(0, siteLimitW),
+            availableCapacityW: 0,
+            minCapacityW: 0
+        };
+    }
+
+    const totalMax = capacityOf(activeList);
+    const totalMin = minCapacityOf(activeList);
+    const cappedSiteLimit = clamp(siteLimitW, 0, totalMax);
+
+    let remaining = cappedSiteLimit;
+
+    activeList.forEach(function (inv) {
+        const baseMin = Math.min(inv.minW, inv.maxW);
+        allocations[inv.id] = baseMin;
+        remaining -= baseMin;
+    });
+
+    remaining = Math.max(0, remaining);
+
+    let eligible = activeList.filter(function (inv) {
+        return allocations[inv.id] < inv.maxW;
+    });
+
+    let loops = 0;
+
+    while (remaining > 0.5 && eligible.length > 0 && loops < 20) {
+        loops += 1;
+
+        const weights = weightMap(strategy, eligible, freshMap);
+        let sumWeights = eligible.reduce(function (sum, inv) {
+            return sum + Number(weights[inv.id] || 0);
+        }, 0);
+
+        if (sumWeights <= 0) {
+            eligible.forEach(function (inv) {
+                weights[inv.id] = 1;
+            });
+            sumWeights = eligible.length;
+        }
+
+        let distributed = 0;
+
+        eligible.forEach(function (inv) {
+            const share = remaining * (weights[inv.id] / sumWeights);
+            const room = inv.maxW - allocations[inv.id];
+            const add = Math.min(room, share);
+            allocations[inv.id] += add;
+            distributed += add;
+        });
+
+        if (distributed <= 0.001) break;
+
+        remaining -= distributed;
+        eligible = activeList.filter(function (inv) {
+            return allocations[inv.id] < inv.maxW - 0.001;
+        });
+    }
+
+    Object.keys(allocations).forEach(function (id) {
+        allocations[id] = Math.round(allocations[id]);
+    });
+
+    const allocated = Object.values(allocations).reduce(function (sum, v) {
+        return sum + Number(v || 0);
+    }, 0);
+
+    return {
+        allocations: allocations,
+        clipped: siteLimitW > totalMax,
+        unallocatedW: Math.max(0, Math.round(cappedSiteLimit - allocated)),
+        availableCapacityW: totalMax,
+        minCapacityW: totalMin
+    };
+}
+
+function perInverterPolicyValue(inv, behavior, fixedValueW) {
+    if (behavior === "set_inverter_min") {
+        return clamp(Number(inv.minW || 0), 0, Number(inv.maxW || 0));
+    }
+
+    if (behavior === "fixed_value") {
+        return clamp(Number(fixedValueW || 0), 0, Number(inv.maxW || 0));
+    }
+
+    return 0;
+}
+
+function buildPolicyAllocations(activeList, behavior, fixedValueW) {
+    const allocations = {};
+
+    activeList.forEach(function (inv) {
+        allocations[inv.id] = Math.round(perInverterPolicyValue(inv, behavior, fixedValueW));
+    });
+
+    const total = Object.values(allocations).reduce(function (sum, v) {
+        return sum + Number(v || 0);
+    }, 0);
+
+    return {
+        allocations: allocations,
+        totalW: total
+    };
+}
+
+function applyPolicyToStale(allocations, activeList, staleList, behavior, fixedValueW) {
+    const staleSet = new Set(staleList || []);
+    const out = Object.assign({}, allocations || {});
+    let changed = false;
+
+    activeList.forEach(function (inv) {
+        if (!staleSet.has(inv.id)) {
+            return;
+        }
+
+        const forced = Math.round(perInverterPolicyValue(inv, behavior, fixedValueW));
+        if (Number(out[inv.id] || 0) !== forced) {
+            changed = true;
+        }
+        out[inv.id] = forced;
+    });
+
+    return {
+        allocations: out,
+        changed: changed
+    };
+}
+
+function smoothAllocations(newAllocations, alpha, previousMap) {
+    const a = clamp(Number(alpha || 1), 0.01, 1);
+
+    if (a >= 0.999) {
+        const rounded = roundAllocations(newAllocations);
+        Object.keys(rounded).forEach(function (id) {
+            previousMap[id] = Number(rounded[id] || 0);
+        });
+        return rounded;
+    }
+
+    const out = {};
+
+    Object.keys(newAllocations || {}).forEach(function (id) {
+        const prev = Number.isFinite(previousMap[id]) ? previousMap[id] : Number(newAllocations[id] || 0);
+        const next = Number(newAllocations[id] || 0);
+        const smooth = a * next + (1 - a) * prev;
+        previousMap[id] = smooth;
+        out[id] = Math.round(smooth);
+    });
+
+    return out;
+}
+
+module.exports = {
+    clamp,
+    roundAllocations,
+    capacityOf,
+    minCapacityOf,
+    totalFreshPower,
+    chooseEffectiveStrategy,
+    allocateIterative,
+    buildPolicyAllocations,
+    applyPolicyToStale,
+    smoothAllocations
+};