machineGroupControl/test/basic/groupEfficiency.basic.test.js

'use strict';

const test = require('node:test');
const assert = require('node:assert/strict');

const { interpolation } = require('generalFunctions');
const GroupEfficiency = require('../../src/efficiency/groupEfficiency.js');

function makeMachines(cogs) {
    const out = {};
    cogs.forEach((cog, i) => { out[`m${i}`] = { cog }; });
    return out;
}

function makeGE(extra = {}) {
    return new GroupEfficiency({
        interpolation: new interpolation(),
        logger: { warn() {}, error() {}, debug() {}, info() {} },
        ...extra,
    });
}

test('calcGroupEfficiency aggregates across 3 machines', () => {
    const ge = makeGE();
    const machines = makeMachines([0.9, 0.8, 0.7]);
    const { maxEfficiency, lowestEfficiency } = ge.calcGroupEfficiency(machines);
    assert.equal(lowestEfficiency, 0.7);
    // maxEfficiency in the original code is actually the MEAN cog.
    assert.ok(Math.abs(maxEfficiency - 0.8) < 1e-12);
});

test('calcDistanceFromPeak returns |a - b|', () => {
    const ge = makeGE();
    assert.ok(Math.abs(ge.calcDistanceFromPeak(0.85, 0.92) - 0.07) < 1e-12);
    assert.ok(Math.abs(ge.calcDistanceFromPeak(0.92, 0.85) - 0.07) < 1e-12);
});

test('calcRelativeDistanceFromPeak maps current onto [0..1]', () => {
    const ge = makeGE();
    // current=0.85, max=0.92, min=0.7 → maps 0.85 in [0.92..0.7] onto [0..1].
    // interpolate_lin_single_point treats first range as input domain:
    // 0.85 → ((0.85 - 0.92) / (0.7 - 0.92)) * (1 - 0) + 0 = 0.07/0.22 ≈ 0.3181818...
    const v = ge.calcRelativeDistanceFromPeak(0.85, 0.92, 0.7);
    const expected = (0.85 - 0.92) / (0.7 - 0.92);
    assert.ok(Math.abs(v - expected) < 1e-9, `got ${v} expected ${expected}`);
});

test('calcDistanceBEP returns both abs + rel', () => {
    const ge = makeGE();
    const { absDistFromPeak, relDistFromPeak } = ge.calcDistanceBEP(0.85, 0.92, 0.7);
    assert.ok(Math.abs(absDistFromPeak - 0.07) < 1e-12);
    const expectedRel = (0.85 - 0.92) / (0.7 - 0.92);
    assert.ok(Math.abs(relDistFromPeak - expectedRel) < 1e-9);
});

test('calcRelativeDistanceFromPeak returns undefined when max === min (degenerate)', () => {
    // For homogeneous pump groups (all cogs equal), the [max..min] band
    // collapses and the metric is mathematically undefined. Return undefined
    // so the dashboard displays "—" instead of a misleading 0% / 100%.
    const ge = makeGE();
    assert.equal(ge.calcRelativeDistanceFromPeak(0.85, 0.8, 0.8), undefined);
});

test('calcRelativeDistanceFromPeak returns undefined when max ≈ min within epsilon', () => {
    // Float noise from identical pumps: max-min might be 1e-12 rather than 0.
    // Must still report undefined — the interpolation extrapolates wildly here.
    const ge = makeGE();
    assert.equal(ge.calcRelativeDistanceFromPeak(0.85, 0.211264, 0.211263999), undefined);
});

test('calcRelativeDistanceFromPeak returns undefined when current is null', () => {
    const ge = makeGE();
    assert.equal(ge.calcRelativeDistanceFromPeak(null, 0.92, 0.7), undefined);
});

test('calcDistanceBEP propagates undefined relDist for degenerate input', () => {
    // Regression: if currentEff is finite, absDist is still computed (it's
    // just |current - peak|), but relDist must be undefined for degenerate.
    const ge = makeGE();
    const { absDistFromPeak, relDistFromPeak } = ge.calcDistanceBEP(0.206, 0.211, 0.211);
    assert.ok(Math.abs(absDistFromPeak - 0.005) < 1e-9);
    assert.equal(relDistFromPeak, undefined);
});

test('calcGroupEfficiency handles a single machine', () => {
    const ge = makeGE();
    const { maxEfficiency, lowestEfficiency } = ge.calcGroupEfficiency(makeMachines([0.77]));
    assert.equal(maxEfficiency, 0.77);
    assert.equal(lowestEfficiency, 0.77);
});