rotatingMachine/test/basic/groupPredictors.basic.test.js

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

const { predict } = require('generalFunctions');
const { buildPredictors } = require('../../src/prediction/predictors');
const { buildGroupPredictors } = require('../../src/prediction/groupPredictors');

function makeCanonicalCurve() {
  return {
    nq: {
      100000: { x: [0, 50, 100], y: [0, 0.005, 0.01] },
      120000: { x: [0, 50, 100], y: [0, 0.006, 0.012] },
    },
    np: {
      100000: { x: [0, 50, 100], y: [0, 500, 1000] },
      120000: { x: [0, 50, 100], y: [0, 600, 1200] },
    },
  };
}

test('buildGroupPredictors: returns null when source predictors absent', () => {
  assert.equal(buildGroupPredictors(null), null);
  assert.equal(buildGroupPredictors({ predictFlow: null, predictPower: null, predictCtrl: null }), null);
});

test('buildGroupPredictors: returns three group-scope Predict instances', () => {
  const predictors = buildPredictors(makeCanonicalCurve());
  const group = buildGroupPredictors(predictors);
  assert.ok(group);
  assert.ok(group.groupPredictFlow instanceof predict);
  assert.ok(group.groupPredictPower instanceof predict);
  assert.ok(group.groupPredictCtrl instanceof predict);
});

test('buildGroupPredictors: group instances share input curves with individuals', () => {
  const predictors = buildPredictors(makeCanonicalCurve());
  const group = buildGroupPredictors(predictors);
  // Predict._adoptInputsFrom copies these refs from the source.
  assert.equal(group.groupPredictFlow.inputCurve, predictors.predictFlow.inputCurve);
  assert.equal(group.groupPredictPower.inputCurve, predictors.predictPower.inputCurve);
  assert.equal(group.groupPredictCtrl.inputCurve, predictors.predictCtrl.inputCurve);
});

test('buildGroupPredictors: group operating-point state is independent of individual', () => {
  const predictors = buildPredictors(makeCanonicalCurve());
  const group = buildGroupPredictors(predictors);
  predictors.predictFlow.fDimension = 100000;
  group.groupPredictFlow.fDimension = 120000;
  assert.equal(predictors.predictFlow.currentF, 100000);
  assert.equal(group.groupPredictFlow.currentF, 120000);
});