EVOLV · machineGroupControl

141        this.router
142            .onRegister('machine', (child) => {
143                const id = child.config.general.id;
144                if (this.machines[id]) {
145                    this.logger.warn(`Machine ${id} is already registered.`);
146                    return;
147                }
148                this.machines[id] = child;
149            })
150            .onMeasurement('machine', { type: 'pressure', position: POSITIONS.DOWNSTREAM },   () => this.handlePressureChange())
151            .onMeasurement('machine', { type: 'pressure', position: 'differential' },          () => this.handlePressureChange())
152            .onPrediction('machine',  { type: 'flow',     position: POSITIONS.DOWNSTREAM },   () => this.handlePressureChange())
153            .onRegister('measurement', (child) => {
154                const position = child.config?.functionality?.positionVsParent || child.config?.general?.positionVsParent;
155                const measurementType = child.config?.asset?.type;
156                if (!measurementType || !position) {
157                    this.logger.warn(`Measurement child ${child.config?.general?.id} missing asset.type or positionVsParent — skipping`);
158                    return;
159                }
160                const eventName = `${measurementType}.measured.${String(position).toLowerCase()}`;
161                child.measurements.emitter.on(eventName, (eventData = {}) => {
162                    this.measurements
163                        .type(measurementType).variant('measured').position(position)
164                        .value(eventData.value, eventData.timestamp, eventData.unit);
165                    if (measurementType === 'pressure') this.handlePressureChange();
166                });
167            });

468    _fireSchedulerCommand(cmd) {
469        const machine = this.machines[cmd.machineId];
470        if (!machine) {
471            this.logger?.warn?.(`Scheduler fired ${cmd.action} for unknown machine ${cmd.machineId}`);
472            return undefined;
473        }
474        const handle = typeof machine.handleInput === 'function' ? machine.handleInput.bind(machine) : null;
475        if (!handle) return undefined;
476        if (cmd.action === 'execsequence') {
477            return Promise.resolve(handle('parent', 'execsequence', cmd.sequence))
478                .catch((e) => this.logger?.error?.(`execsequence ${cmd.sequence} on ${cmd.machineId} failed: ${e?.message || e}`));
479        }
480        if (cmd.action === 'flowmovement') {
481            const outFlow = this._canonicalToOutputFlow(cmd.flow);
482            return Promise.resolve(handle('parent', 'flowmovement', outFlow))
483                .catch((e) => this.logger?.error?.(`flowmovement on ${cmd.machineId} failed: ${e?.message || e}`));
484        }
485        return undefined;
486    }

[
    {
        "id": "grp_drv_mode",
        "type": "group",
        "z": "tab_mgc_basic",
        "name": "1. Control mode",
        "style": {
            "stroke": "#666666",
            "fill": "#ffdf7f",
            "fill-opacity": "0.15",
            "label": true,
            "color": "#333333"
        },
        "nodes": [
            "inj_mode_optimal",
            "inj_mode_priority"
        ],
        "x": 714,
        "y": 19,
        "w": 292,
        "h": 122
    },
    {
        "id": "inj_mode_optimal",
        "type": "inject",
        "z": "tab_mgc_basic",
        "g": "grp_drv_mode",
        "name": "mode = optimalControl",
        "props": [
            {
                "p": "command",
                "v": "{\"mode\": {\"value\": \"optimalControl\"}}",
                "vt": "json"
            }
        ],
        "repeat": "",
        "crontab": "",
        "once": false,
        "onceDelay": "",
        "x": 870,
        "y": 60,
        "wires": [
            [
                "mgc_basic_node"
            ]
        ]
    },
    {
        "id": "inj_mode_priority",
        "type": "inject",
        "z": "tab_mgc_basic",
        "g": "grp_drv_mode",
        "name": "mode = priorityControl",
        "props": [
            {
                "p": "command",
                "v": "{\"mode\": {\"value\": \"priorityControl\"}}",
                "vt": "json"
            }
        ],
        "repeat": "",
        "crontab": "",
        "once": false,
        "onceDelay": "",
        "x": 870,
        "y": 100,
        "wires": [
            [
                "mgc_basic_node"
            ]
        ]
    }
]

530    async setDemand(value, unit = '%') {
531        const v = Number(value);
532        if (!Number.isFinite(v)) {
533            this.logger?.error?.(`setDemand: invalid value '${value}'`);
534            return undefined;
535        }
536        if (v < 0) {
537            await this.turnOffAllMachines();
538            return undefined;
539        }
540        let canonical;
541        if (unit === '%') {
542            const dt = this.calcDynamicTotals();
543            canonical = this.interpolation.interpolate_lin_single_point(
544                v, 0, 100, dt.flow.min, dt.flow.max);
545        } else {
546            try {
547                canonical = this.unitPolicy.convert(v, unit, 'm3/s', 'setDemand absolute flow');
548            } catch (err) {
549                this.logger?.error?.(`setDemand: cannot convert ${v} ${unit} -> m3/s: ${err?.message || err}`);
550                return undefined;
551            }
552        }
553        return this.handleInput('parent', canonical);
554    }
555
556    async _runDispatch(source, demand, powerCap, priorityList, opts = {}) {
557        const demandQ = parseFloat(demand);
558        if (!Number.isFinite(demandQ)) {
559            this.logger.error(`Invalid flow demand input: ${demand}.`);
560            return;
561        }
562        // Demand is canonical m³/s (the handler has already resolved units).
563        // The handler routes negatives directly to turnOffAllMachines, but
564        // keep a defensive check in case turnOff-state arrives some other way.
565        if (demandQ <= 0) { await this.turnOffAllMachines(); return; }
566

1'use strict';
2
3const { LatestWinsGate } = require('generalFunctions');
4
5// Thin wrapper around LatestWinsGate for the MGC demand path. Replaces
6// the original `_dispatchInFlight` + `_delayedCall` pair in
7// specificClass.handleInput: a new demand arriving while a dispatch is
8// in flight overwrites any pending one, so the latest value always wins
9// and intermediates are dropped silently.
10
11class DemandDispatcher {
12    constructor(ctx = {}, runFn) {
13        if (typeof runFn !== 'function') {
14            throw new TypeError('DemandDispatcher requires a runFn');
15        }
16        this.ctx = ctx;
17        this.logger = ctx.logger || null;
18        this._runFn = runFn;
19        this._gate = new LatestWinsGate(
20            async (demand) => this._runFn(demand, this.ctx),
21            { logger: this.logger },
22        );
23    }
24
25    fire(demand) {
26        this._gate.fire(demand);
27    }
28
29    // Returns a promise that resolves when THIS demand's dispatch settles.
30    // If superseded by a later fireAndWait while parked, the promise
31    // resolves with the LatestWinsGate SUPERSEDED sentinel
32    // ({ superseded: true }) — callers can branch on it without try/catch.
33    fireAndWait(demand) {
34        return this._gate.fireAndWait(demand);
35    }
36
37    drain() {
38        return this._gate.drain();
39    }
40
41    // Cancels any parked pending value so it cannot run. The currently
42    // in-flight dispatch (if any) still runs to completion. A parked
43    // fireAndWait promise resolves with the SUPERSEDED sentinel.
44    cancelPending() {
45        if (this._gate._pending) this._gate._supersedePending();
46    }
47
48    get inFlight() {
49        return this._gate.size > 0;
50    }
51}
52
53module.exports = DemandDispatcher;

608        switch (String(this.mode || '').toLowerCase()) {
609            case 'prioritycontrol':           await control.equalFlowControl(ctx, demandQout, powerCap, priorityList); break;
610            // Duty rotation: dispatch sequentially (same as priorityControl) but
611            // with a lead order rotated by _rotationIndex. A live (>0) dispatch
612            // arms the rotation so the next demand→0 hands the lead to the next
613            // pump. An explicit priorityList from the caller still wins (lets an
614            // operator override the rotated order for one dispatch).
615            case 'rotationcontrol':           this._rotationArmed = true;
616                                              await control.equalFlowControl(ctx, demandQout, powerCap, priorityList || this._rotationOrderedIds()); break;
617            case 'optimalcontrol':            await this._optimalControl(demandQout, powerCap); break;
618            default: this.logger.warn(`${this.mode} is not a valid mode.`);
619        }

83        case (Qd < activeTotals.flow.min && activeTotals.flow.min !== 0): {
84            let availableFlow = activeTotals.flow.min;
85            for (let i = machinesInPriorityOrder.length - 1; i >= 0 && availableFlow > Qd; i--) {
86                const m = machinesInPriorityOrder[i];
87                if (isMachineActive(m.id)) {
88                    flowDistribution.push({ machineId: m.id, flow: 0 });
89                    availableFlow -= groupFlow(m.machine).currentFxyYMin;
90                }
91            }
92            const remaining = machinesInPriorityOrder.filter(({ id }) =>
93                isMachineActive(id) && !flowDistribution.some(it => it.machineId === id));
94            const distributedFlow = Qd / remaining.length;
95            for (const m of remaining) {
96                flowDistribution.push({ machineId: m.id, flow: distributedFlow });
97                totalFlow += distributedFlow;
98                totalPower += groupCalcPower(m.machine, distributedFlow);
99            }
100            break;
101        }
102        case (Qd > activeTotals.flow.max): {
103            // Demand exceeds what the active set can deliver: bring machines
104            // online in priority order until their combined max covers Qd,
105            // then split equally, clamped to each pump's envelope. (The
106            // legacy loop compounded `Qd /= i` across iterations — per-pump
107            // flow shrank to Qd/(i!) instead of Qd/i — and assigned flow only
108            // to INACTIVE pumps, leaving running pumps without a setpoint.
109            // Fixed deliberately; the old behaviour was pinned as a known
110            // quirk in equalFlowDistribution.basic.test.js.)
111            const selected = [];
112            let cap = 0;
113            for (const m of machinesInPriorityOrder) {
114                selected.push(m);
115                cap += groupFlow(m.machine).currentFxyYMax;
116                if (cap >= Qd) break;
117            }
118            const per = selected.length > 0 ? Qd / selected.length : 0;
119            for (const m of selected) {
120                const env = groupFlow(m.machine);
121                const flow = Math.min(env.currentFxyYMax, Math.max(env.currentFxyYMin, per));
122                flowDistribution.push({ machineId: m.id, flow });
123                totalFlow += flow;
124                totalPower += groupCalcPower(m.machine, flow);
125            }
126            break;
127        }
128        default: {
129            // Qd lies inside the active set's envelope: split equally across
130            // the machines that are actually ACTIVE, in priority order. (The
131            // legacy code counted the active machines but then handed flow to
132            // the FIRST countActive entries of the priority list — which
133            // could include inactive pumps while skipping active ones. Fixed
134            // deliberately; old behaviour was pinned as a latent bug in
135            // equalFlowDistribution.basic.test.js.)
136            const activeMachines = machinesInPriorityOrder.filter(({ id }) => isMachineActive(id));
137            const per = activeMachines.length > 0 ? Qd / activeMachines.length : 0;
138            for (const m of activeMachines) {
139                flowDistribution.push({ machineId: m.id, flow: per });
140                totalFlow += per;
141                totalPower += groupCalcPower(m.machine, per);
142            }
143            break;
144        }
145    }
146
147    return { flowDistribution, totalFlow, totalPower, totalCog };
148}

215    _rotationOrderedIds() {
216        const ids = Object.keys(this.machines).sort((a, b) => String(a).localeCompare(String(b)));
217        if (ids.length === 0) return null;
218        const n = ids.length;
219        const lead = ((this._rotationIndex % n) + n) % n;
220        return ids.slice(lead).concat(ids.slice(0, lead));
221    }
222
223    // The current lead machine id (or null when no machines registered).
224    leadMachineId() {
225        const ids = this._rotationOrderedIds();
226        return ids ? ids[0] : null;
227    }
228
229    // Advance the duty-rotation lead by one (round-robin) on a running→0 edge.
230    // Wrapping past the last machine counts one completed full rotation. No-op
231    // when ≤1 machine is registered (nothing to rotate between).
232    _advanceRotation() {
233        this._rotationArmed = false;
234        const n = Object.keys(this.machines).length;
235        if (n <= 1) return;
236        const next = (this._rotationIndex + 1) % n;
237        if (next <= (this._rotationIndex % n)) this._rotationsCompleted += 1;
238        this._rotationIndex = next;
239        this.logger.info(`rotationControl: demand→0 — lead advanced to index ${this._rotationIndex} (${this.leadMachineId()}); rotations completed: ${this._rotationsCompleted}.`);
240    }

84
85function _marginalCostRefine(flowDistribution, pumpInfos, Qd, ctx) {
86    const { groupCalcPower } = ctx.groupCurves;
87    const mcDelta = Math.max(1e-6, (Qd / pumpInfos.length) * 0.005);
88
89    for (let iter = 0; iter < MC_ITER_CAP; iter++) {
90        const mcEntries = flowDistribution.map(entry => {
91            const info = pumpInfos.find(i => i.id === entry.machineId);
92            const pNow = groupCalcPower(info.machine, entry.flow);
93            const pUp = groupCalcPower(info.machine, Math.min(info.maxFlow, entry.flow + mcDelta));
94            return { entry, info, mc: (pUp - pNow) / mcDelta };
95        });
96
97        let expensive = null;
98        let cheap = null;
99        for (const e of mcEntries) {
100            if (e.entry.flow > e.info.minFlow + mcDelta && (!expensive || e.mc > expensive.mc)) expensive = e;
101            if (e.entry.flow < e.info.maxFlow - mcDelta && (!cheap || e.mc < cheap.mc)) cheap = e;
102        }
103        if (!expensive || !cheap || expensive === cheap) break;
104        if (expensive.mc - cheap.mc < expensive.mc * MC_RELATIVE_EXIT) break;
105
106        const before = groupCalcPower(expensive.info.machine, expensive.entry.flow)
107                     + groupCalcPower(cheap.info.machine, cheap.entry.flow);
108        const after = groupCalcPower(expensive.info.machine, expensive.entry.flow - mcDelta)
109                    + groupCalcPower(cheap.info.machine, cheap.entry.flow + mcDelta);
110        if (after < before) {
111            expensive.entry.flow -= mcDelta;
112            cheap.entry.flow += mcDelta;
113        } else {
114            break;
115        }
116    }
117}
118
119function calcBestCombinationBEPGravitation(combinations, Qd, ctx, method = 'BEP-Gravitation-Directional') {
120    const { machines, groupCurves } = ctx;
121    const { groupFlow, groupNCog, groupCalcPower } = groupCurves;
122    const directional = method === 'BEP-Gravitation-Directional';
123
124    let bestCombination = null;
125    let bestPower = Infinity;
126    let bestFlow = 0;
127    let bestCog = 0;
128    let bestDeviation = Infinity;
129

60                    ? Math.min(entry.max, entry.flow + delta)
61                    : Math.max(entry.min, entry.flow + delta);
62                remainder -= (next - entry.flow);
63                entry.flow = next;
64            });
65        }
66
67        flowDistribution = clamped;
68
69        let totalFlow = 0;
70        let totalPower = 0;
71        flowDistribution.forEach(({ machineId, flow }) => {
72            totalFlow += flow;
73            totalPower += groupCalcPower(machines[machineId], flow);
74        });
75
76        if (totalPower < bestPower) {
77            logger?.debug?.(`New best combination found: ${totalPower} < ${bestPower}`);
78            bestPower = totalPower;
79            bestFlow = totalFlow;
80            bestCog = totalCoG;
81            bestCombination = flowDistribution;
82        }
83    });
84
85    return { bestCombination, bestPower, bestFlow, bestCog };
86}
87
88module.exports = { calcBestCombination };

60    let subsets = [[]];
61    Object.keys(machines).forEach(machineId => {
62        const machine = machines[machineId];
63        const state = machine.state?.getCurrentState?.();
64        const validActionForMode =
65            typeof machine.isValidActionForMode === 'function'
66                ? machine.isValidActionForMode('execsequence', 'auto')
67                : true;
68
69        if (EXCLUDED_STATES.has(state) || !validActionForMode) return;
70
71        const newSubsets = subsets.map(set => [...set, machineId]);
72        subsets = subsets.concat(newSubsets);
73    });
74
75    return subsets.filter(subset => {
76        if (subset.length === 0) return false;
77
78        const { maxFlow, minFlow, maxPower } = subset.reduce(
79            (acc, machineId) => {
80                const machine = machines[machineId];
81                const f = groupFlow(machine);
82                const p = groupPower(machine);
83                return {
84                    maxFlow: acc.maxFlow + f.currentFxyYMax,
85                    minFlow: acc.minFlow + f.currentFxyYMin,
86                    maxPower: acc.maxPower + p.currentFxyYMax,
87                };
88            },
89            { maxFlow: 0, minFlow: 0, maxPower: 0 },
90        );
91
92        return maxFlow >= Qd && minFlow <= Qd && maxPower <= powerCap;
93    });

46    etaToTargetS() {
47        const p = this.profile;
48        const v = p.velocityPctPerS;
49        const target = this.targetPosition;
50
51        if (SHUTDOWN_LADDER.has(p.state)) return null;
52
53        if (!Number.isFinite(v) || v <= 0) return Infinity;
54
55        if (p.state === 'operational' || ACTIVE_OPERATIONAL.has(p.state)) {
56            const dist = Math.abs(target - p.position);
57            return dist / v;
58        }
59
60        if (p.state === 'warmingup') {
61            // Remaining warmup, then ramp from minPosition to target.
62            // Ramp starts from minPosition because the pump is not moving
63            // during warmup — position is held at min.
64            const remW = p.remainingTransitionS ?? p.timings.warmingupS;
65            const rampDist = Math.max(0, target - p.minPosition);
66            return remW + rampDist / v;
67        }
68
69        if (p.state === 'starting') {
70            // Remaining-in-starting + full warmup duration + ramp from min.
71            const remS = p.remainingTransitionS ?? p.timings.startingS;
72            const rampDist = Math.max(0, target - p.minPosition);
73            return remS + p.timings.warmingupS + rampDist / v;
74        }
75
76        // idle / off / emergencystop / maintenance / any non-active state
77        // not in the ladders: full startup sequence to operational, then ramp.
78        const rampDist = Math.max(0, target - p.minPosition);
79        return p.timings.startingS + p.timings.warmingupS + rampDist / v;
80    }

159    // Rendezvous: t* = max eta over ALL non-noop moves. Includes
160    // increasing AND decreasing flow-moves so the slowest mover sets the
161    // deadline for everyone. When useRendezvous=false, tStar is forced
162    // to 0 so every command's delay collapses to 0 (legacy behaviour).
163    const allEtas = plans
164        .filter((q) => !q.skip && Number.isFinite(q.eta))
165        .map((q) => q.eta);
166    const tStar = useRendezvous && allEtas.length > 0 ? Math.max(...allEtas) : 0;
167
168    // Second pass: assign fireAtTickN. Every command is delayed so its
169    // move finishes at t*; the lone exception is the startup ladder's
170    // execsequence (the ladder must begin now because eta == ladder + ramp).
171    const commands = [];
172    for (const q of plans) {
173        if (q.skip) continue;
174
175        // Delay-to-rendezvous: fire (t* − eta) seconds from now so the
176        // move FINISHES at t*. Clamped to >= 0 (the eta == t* mover fires
177        // immediately).
178        const fireAtSDelayed = Math.max(0, tStar - q.eta);
179        const fireAtTickNDelayed = Math.round(fireAtSDelayed / tickS);
180        // Unchanged moves are no-ops; fire at 0 for simplicity (the pump
181        // ignores them and we don't pollute the schedule with delays).
182        const isUnchanged = q.direction === 'unchanged';
183
184        if (q.action === 'startup') {
185            // Just-in-time start. Delay the ENTIRE startup — ladder AND ramp —
186            // by (t* − eta), so the warmup ladder finishes (and the ramp
187            // begins) at (t* − rampS) and the flow lands exactly at t*.
188            //
189            // The ladder duration can't be compressed, but it CAN be delayed.
190            // Firing the execsequence at tick 0 (the old behaviour) made a
191            // faster-than-slowest startup reach `operational` early and sit at
192            // its minimum flow from warmup-end until its delayed ramp — leaking
193            // ~min-flow into the group total before t* (the staging bump). For
194            // the slowest pump (eta == t*) fireAtTickNDelayed is 0, so it still
195            // fires immediately. The flowmovement fires on the same tick; the
196            // pump holds it in delayedMove through the ladder, then ramps over
197            // rampS to finish at t*.
198            commands.push({
199                machineId: q.machineId,
200                action: 'execsequence',
201                sequence: 'startup',
202                fireAtTickN: fireAtTickNDelayed,
203                eta: q.eta,
204            });
205            commands.push({
206                machineId: q.machineId,
207                action: 'flowmovement',
208                flow: q.targetFlow,
209                fireAtTickN: fireAtTickNDelayed,
210                eta: q.eta,
211            });

48    equalize() {
49        const machines = this.machines || {};
50        if (Object.keys(machines).length === 0) return;
51
52        const pressureUnit = this.unitPolicy.canonical.pressure;
53        const groupHeaderDown = this.measurements
54            .type('pressure').variant('measured').position(POSITIONS.DOWNSTREAM)
55            .getCurrentValue(pressureUnit);
56        const groupHeaderUp = this.measurements
57            .type('pressure').variant('measured').position(POSITIONS.UPSTREAM)
58            .getCurrentValue(pressureUnit);
59
60        const childDown = [];
61        const childUp = [];
62        Object.values(machines).forEach(machine => {
63            const d = this.readChild(machine, 'pressure', 'measured', POSITIONS.DOWNSTREAM, pressureUnit);
64            const u = this.readChild(machine, 'pressure', 'measured', POSITIONS.UPSTREAM, pressureUnit);
65            if (Number.isFinite(d) && d > 0) childDown.push(d);
66            if (Number.isFinite(u) && u > 0) childUp.push(u);
67        });
68
69        const downIsHeader = Number.isFinite(groupHeaderDown) && groupHeaderDown > 0;
70        const upIsHeader   = Number.isFinite(groupHeaderUp)   && groupHeaderUp   > 0;
71        const headerDownstream = downIsHeader ? groupHeaderDown : (childDown.length ? Math.max(...childDown) : 0);
72        const headerUpstream   = upIsHeader   ? groupHeaderUp   : (childUp.length   ? Math.min(...childUp)   : 0);
73
74        const headerDiff = headerDownstream - headerUpstream;
75        if (!Number.isFinite(headerDiff) || headerDiff <= 0) {
76            this.logger?.debug?.(`Skipping equalization: invalid header diff ${headerDiff} (down=${headerDownstream}, up=${headerUpstream})`);
77            return;
78        }
79        // Stash so downstream callers (optimizer, strategies) can compute
80        // hydraulic efficiency without re-reading every machine's pressure.
81        this.headerDiffPa = headerDiff;
82
83        this.logger?.debug?.(`Equalizing operating point: down=${headerDownstream}, up=${headerUpstream}, diff=${headerDiff}`);
84
85        Object.values(machines).forEach(machine => {
86            if (typeof machine.setGroupOperatingPoint === 'function') {
87                machine.setGroupOperatingPoint(headerDownstream, headerUpstream);
88            } else {
89                // Older rotatingMachine without the group API — direct
90                // fDimension write keeps demos working while submodules
91                // are rolled forward.
92                if (machine.predictFlow)  machine.predictFlow.fDimension  = headerDiff;
93                if (machine.predictPower) machine.predictPower.fDimension = headerDiff;
94                if (machine.predictCtrl)  machine.predictCtrl.fDimension  = headerDiff;
95            }
96        });
97    }

72    calcDynamicTotals() {
73        const out = { flow: { min: Infinity, max: 0, act: 0 }, power: { min: Infinity, max: 0, act: 0 }, NCog: 0 };
74        const fUnit = this.unitPolicy.canonical.flow;
75        const pUnit = this.unitPolicy.canonical.power;
76
77        Object.values(this.machines).forEach(machine => {
78            if (!machine.hasCurve) {
79                this.logger?.error?.(`Machine ${machine.config?.general?.id} has no valid curve — skipping.`);
80                return;
81            }
82            const gpf = groupFlow(machine);
83            const gpp = groupPower(machine);
84
85            const minFlow  = gpf.currentFxyYMin;
86            const maxFlow  = gpf.currentFxyYMax;
87            const minPower = gpp.currentFxyYMin;
88            const maxPower = gpp.currentFxyYMax;
89
90            const actFlow  = this.operatingPoint?.readChild(machine, 'flow',  'predicted', POSITIONS.DOWNSTREAM,   fUnit) || 0;
91            const actPower = this.operatingPoint?.readChild(machine, 'power', 'predicted', POSITIONS.AT_EQUIPMENT, pUnit) || 0;
92
93            if (minFlow  < out.flow.min)  out.flow.min  = minFlow;
94            if (minPower < out.power.min) out.power.min = minPower;
95            out.flow.max   += maxFlow;
96            out.power.max  += maxPower;
97            out.flow.act   += actFlow;
98            out.power.act  += actPower;
99            out.NCog       += groupNCog(machine);
100        });
101
102        this.dynamicTotals = out;
103        return out;
104    }
105
106    activeTotals() {
107        const out = { flow: { min: 0, max: 0 }, power: { min: 0, max: 0 }, countActiveMachines: 0 };
108
109        Object.entries(this.machines).forEach(([id, machine]) => {
110            if (!this.isMachineActive(id)) return;
111            const gpf = groupFlow(machine);
112            const gpp = groupPower(machine);
113            out.flow.min  += gpf.currentFxyYMin;
114            out.flow.max  += gpf.currentFxyYMax;
115            out.power.min += gpp.currentFxyYMin;
116            out.power.max += gpp.currentFxyYMax;
117            out.countActiveMachines += 1;
118        });
119
120        return out;
121    }

20function getOutput(mgc) {
21    const out = {};
22    const { measurements, unitPolicy, mode, absDistFromPeak, relDistFromPeak } = mgc;
23    measurements.getTypes().forEach(type => {
24        measurements.getVariants(type).forEach(variant => {
25            const unit = _outputUnitForType(unitPolicy, type);
26            const read = (pos) => measurements.type(type).variant(variant).position(pos).getCurrentValue(unit || undefined);
27            const dn = read(POSITIONS.DOWNSTREAM);
28            const at = read(POSITIONS.AT_EQUIPMENT);
29            const up = read(POSITIONS.UPSTREAM);
30            if (dn != null) out[`downstream_${variant}_${type}`] = dn;
31            if (up != null) out[`upstream_${variant}_${type}`] = up;
32            if (at != null) out[`atEquipment_${variant}_${type}`] = at;
33            if (dn != null && up != null) {
34                const diff = measurements.type(type).variant(variant)
35                    .difference({ from: POSITIONS.DOWNSTREAM, to: POSITIONS.UPSTREAM, unit });
36                if (diff?.value != null) out[`differential_${variant}_${type}`] = diff.value;
37            }
38        });
39    });
40    out.mode = mode;
41    out.absDistFromPeak = absDistFromPeak;
42    out.relDistFromPeak = relDistFromPeak;
43
44    // System (header) differential pressure resolved by the last equalize.
45    // Dashboards use this to compute head = ΔP / (ρ · g) for Q-H plots
46    // and to scale the BEP indicators without re-reading every child.
47    // Emitted in canonical Pa and in the configured output unit (mbar
48    // by default) so the dashboard can pick whichever it prefers.
49    const headerDiffPa = mgc.operatingPoint?.headerDiffPa;
50    if (Number.isFinite(headerDiffPa) && headerDiffPa > 0) {
51        out.headerDiffPa = headerDiffPa;
52        const pUnit = unitPolicy.output.pressure;
53        // 1 mbar = 100 Pa. Only convert when we recognise mbar; otherwise
54        // leave the raw Pa to avoid a stale or silently wrong unit label.
55        if (pUnit === 'mbar') out.headerDiffMbar = headerDiffPa / 100;
56    }
57
58    // Group capacity + active-machine counts. Surfaced so dashboards can
59    // show the same numbers the status badge does without subscribing to
60    // every child node individually. Emitted in the output flow unit (m³/h)
61    // so the dashed capacity envelope lands on the SAME axis as the predicted-
62    // flow series — dynamicTotals is canonical m³/s, so convert here. (Both
63    // telemetry consumers — the Grafana flow panel and the FlowFuse fanout —
64    // assume m³/h; emitting raw m³/s made the capacity lines render as ~0.)