264 lines
8.5 KiB
JavaScript
264 lines
8.5 KiB
JavaScript
/**
|
|
* Tests for settler specificClass (domain logic).
|
|
*
|
|
* The Settler class is a simple mass-balance separator:
|
|
* - Splits influent into effluent (clarified), surplus sludge, and return sludge
|
|
* - Concentrates particulate species (indices 7-12) into sludge stream
|
|
* - Removes particulates from effluent stream
|
|
* - registerChild: connects measurements, upstream reactors, machines
|
|
*/
|
|
|
|
const { Settler } = require('../src/specificClass');
|
|
|
|
// --------------- helpers ---------------
|
|
|
|
const NUM_SPECIES = 13;
|
|
|
|
function makeConfig(overrides = {}) {
|
|
return {
|
|
general: {
|
|
name: 'TestSettler',
|
|
id: 'settler-test-1',
|
|
logging: { enabled: false, logLevel: 'error' },
|
|
},
|
|
functionality: {
|
|
softwareType: 'settler',
|
|
role: 'separator',
|
|
positionVsParent: 'downstream',
|
|
},
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
// --------------- tests ---------------
|
|
|
|
describe('Settler specificClass', () => {
|
|
|
|
describe('constructor / initialization', () => {
|
|
it('should create an instance with default values', () => {
|
|
const s = new Settler(makeConfig());
|
|
expect(s).toBeDefined();
|
|
expect(s.F_in).toBe(0);
|
|
expect(s.Cs_in).toEqual(new Array(NUM_SPECIES).fill(0));
|
|
expect(s.C_TS).toBe(2500);
|
|
});
|
|
|
|
it('should have null upstreamReactor and returnPump initially', () => {
|
|
const s = new Settler(makeConfig());
|
|
expect(s.upstreamReactor).toBeNull();
|
|
expect(s.returnPump).toBeNull();
|
|
});
|
|
|
|
it('should initialize an EventEmitter', () => {
|
|
const s = new Settler(makeConfig());
|
|
expect(s.emitter).toBeDefined();
|
|
expect(typeof s.emitter.on).toBe('function');
|
|
});
|
|
|
|
it('should initialize a MeasurementContainer', () => {
|
|
const s = new Settler(makeConfig());
|
|
expect(s.measurements).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe('getEffluent', () => {
|
|
|
|
describe('with zero inflow', () => {
|
|
it('should return three streams with zero flows', () => {
|
|
const s = new Settler(makeConfig());
|
|
s.F_in = 0;
|
|
s.Cs_in = new Array(NUM_SPECIES).fill(0);
|
|
const result = s.getEffluent;
|
|
expect(result).toHaveLength(3);
|
|
expect(result[0].payload.F).toBe(0); // effluent
|
|
expect(result[1].payload.F).toBe(0); // surplus sludge
|
|
expect(result[2].payload.F).toBe(0); // return sludge
|
|
});
|
|
});
|
|
|
|
describe('with normal inflow and particulates', () => {
|
|
let s;
|
|
let result;
|
|
|
|
beforeAll(() => {
|
|
s = new Settler(makeConfig());
|
|
s.F_in = 100;
|
|
s.C_TS = 5000;
|
|
// Set concentrations: solubles at indices 0-6, particulates at 7-12
|
|
const C = new Array(NUM_SPECIES).fill(10);
|
|
C[12] = 5000; // X_TS
|
|
s.Cs_in = C;
|
|
result = s.getEffluent;
|
|
});
|
|
|
|
it('should return 3 output streams', () => {
|
|
expect(result).toHaveLength(3);
|
|
});
|
|
|
|
it('should have effluent topic "Fluent"', () => {
|
|
expect(result[0].topic).toBe('Fluent');
|
|
});
|
|
|
|
it('should calculate sludge flow F_s = min(F_in * X_TS_in / C_TS, F_in)', () => {
|
|
// F_s = min(100 * 5000 / 5000, 100) = min(100, 100) = 100
|
|
const F_eff = result[0].payload.F;
|
|
const F_so = result[1].payload.F;
|
|
const F_sr = result[2].payload.F;
|
|
// Total out should equal F_in (mass balance)
|
|
expect(F_eff + F_so + F_sr).toBeCloseTo(100, 5);
|
|
});
|
|
|
|
it('should set effluent particulate indices to zero when F_s > 0', () => {
|
|
const Cs_eff = result[0].payload.C;
|
|
for (let i = 7; i <= 12; i++) {
|
|
expect(Cs_eff[i]).toBe(0);
|
|
}
|
|
});
|
|
|
|
it('should keep effluent soluble indices unchanged', () => {
|
|
const Cs_eff = result[0].payload.C;
|
|
for (let i = 0; i < 7; i++) {
|
|
expect(Cs_eff[i]).toBe(10);
|
|
}
|
|
});
|
|
|
|
it('should concentrate particulates in sludge stream', () => {
|
|
const Cs_s = result[1].payload.C;
|
|
const F_s = Math.min((s.F_in * s.Cs_in[12]) / s.C_TS, s.F_in);
|
|
// Cs_s[i] = F_in * Cs_in[i] / F_s for particulate indices
|
|
for (let i = 7; i <= 12; i++) {
|
|
const expected = s.F_in * s.Cs_in[i] / F_s;
|
|
expect(Cs_s[i]).toBeCloseTo(expected, 5);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('with low X_TS and high C_TS (dilute sludge)', () => {
|
|
it('should produce mostly effluent flow', () => {
|
|
const s = new Settler(makeConfig());
|
|
s.F_in = 100;
|
|
s.C_TS = 10000; // high target concentration
|
|
const C = new Array(NUM_SPECIES).fill(10);
|
|
C[12] = 100; // low X_TS in
|
|
s.Cs_in = C;
|
|
const result = s.getEffluent;
|
|
// F_s = min(100 * 100 / 10000, 100) = min(1, 100) = 1
|
|
expect(result[0].payload.F).toBeCloseTo(99, 5); // most flow is effluent
|
|
});
|
|
});
|
|
|
|
describe('mass balance', () => {
|
|
it('should conserve total flow (F_eff + F_so + F_sr = F_in)', () => {
|
|
const s = new Settler(makeConfig());
|
|
s.F_in = 200;
|
|
s.C_TS = 3000;
|
|
const C = new Array(NUM_SPECIES).fill(5);
|
|
C[12] = 2000;
|
|
s.Cs_in = C;
|
|
const result = s.getEffluent;
|
|
const totalOut = result[0].payload.F + result[1].payload.F + result[2].payload.F;
|
|
expect(totalOut).toBeCloseTo(200, 5);
|
|
});
|
|
|
|
it('should not produce negative flows', () => {
|
|
const s = new Settler(makeConfig());
|
|
s.F_in = 50;
|
|
s.C_TS = 1000;
|
|
const C = new Array(NUM_SPECIES).fill(0);
|
|
C[12] = 500;
|
|
s.Cs_in = C;
|
|
const result = s.getEffluent;
|
|
result.forEach(stream => {
|
|
expect(stream.payload.F).toBeGreaterThanOrEqual(0);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('no return pump', () => {
|
|
it('should have F_sr = 0 when there is no return pump', () => {
|
|
const s = new Settler(makeConfig());
|
|
s.F_in = 100;
|
|
s.C_TS = 5000;
|
|
s.Cs_in = new Array(NUM_SPECIES).fill(10);
|
|
s.Cs_in[12] = 3000;
|
|
const result = s.getEffluent;
|
|
expect(result[2].payload.F).toBe(0);
|
|
});
|
|
});
|
|
|
|
describe('edge case: X_TS > C_TS (F_s clamped to F_in)', () => {
|
|
it('should clamp F_s to F_in when X_TS/C_TS ratio exceeds 1', () => {
|
|
const s = new Settler(makeConfig());
|
|
s.F_in = 100;
|
|
s.C_TS = 1000;
|
|
s.Cs_in = new Array(NUM_SPECIES).fill(10);
|
|
s.Cs_in[12] = 5000; // X_TS_in > C_TS => F_s = min(500, 100) = 100
|
|
const result = s.getEffluent;
|
|
expect(result[0].payload.F).toBe(0); // all flow goes to sludge
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('registerChild()', () => {
|
|
it('should not throw for null child', () => {
|
|
const s = new Settler(makeConfig());
|
|
// null child should trigger the error log but not crash
|
|
expect(() => s.registerChild(null, 'measurement')).not.toThrow();
|
|
});
|
|
|
|
it('should not throw for unknown software type with valid child', () => {
|
|
const s = new Settler(makeConfig());
|
|
const fakeChild = {
|
|
config: {
|
|
general: { name: 'fake', id: 'fake-1' },
|
|
functionality: { positionVsParent: 'upstream' },
|
|
asset: { type: 'pressure' },
|
|
},
|
|
measurements: { emitter: { on: jest.fn() } },
|
|
};
|
|
expect(() => s.registerChild(fakeChild, 'unknownType')).not.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('_connectMachine()', () => {
|
|
it('should set returnPump for downstream machine', () => {
|
|
const s = new Settler(makeConfig());
|
|
const fakeMachine = {
|
|
config: {
|
|
general: { name: 'pump', id: 'pump-1' },
|
|
functionality: { positionVsParent: 'downstream' },
|
|
},
|
|
};
|
|
s._connectMachine(fakeMachine);
|
|
expect(s.returnPump).toBe(fakeMachine);
|
|
expect(fakeMachine.upstreamSource).toBe(s);
|
|
});
|
|
|
|
it('should not set returnPump for non-downstream machine', () => {
|
|
const s = new Settler(makeConfig());
|
|
const fakeMachine = {
|
|
config: {
|
|
general: { name: 'pump', id: 'pump-2' },
|
|
functionality: { positionVsParent: 'upstream' },
|
|
},
|
|
};
|
|
s._connectMachine(fakeMachine);
|
|
expect(s.returnPump).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('_updateMeasurement()', () => {
|
|
it('should update C_TS when measurement type is "quantity (tss)"', () => {
|
|
const s = new Settler(makeConfig());
|
|
s._updateMeasurement('quantity (tss)', 7000, 'atEquipment', {});
|
|
expect(s.C_TS).toBe(7000);
|
|
});
|
|
|
|
it('should not change C_TS for unrecognized measurement type', () => {
|
|
const s = new Settler(makeConfig());
|
|
s._updateMeasurement('temperature', 25, 'atEquipment', {});
|
|
expect(s.C_TS).toBe(2500); // unchanged
|
|
});
|
|
});
|
|
});
|