small bug fixes
This commit is contained in:
znetsixe
1056
dependencies/machineGroup/machineGroup.js
vendored
1056
dependencies/machineGroup/machineGroup.js
vendored
File diff suppressed because it is too large
Load Diff
566
dependencies/machineGroup/machineGroup.test.js
vendored
566
dependencies/machineGroup/machineGroup.test.js
vendored
@@ -1,566 +0,0 @@
|
|||||||
const MachineGroup = require('./machineGroup');
|
|
||||||
const Machine = require('../../../rotatingMachine/dependencies/machine/machine');
|
|
||||||
const specs = require('../../../generalFunctions/datasets/assetData/pumps/hydrostal/centrifugal pumps/models.json');
|
|
||||||
|
|
||||||
class MachineGroupTester {
|
|
||||||
constructor() {
|
|
||||||
this.totalTests = 0;
|
|
||||||
this.passedTests = 0;
|
|
||||||
this.failedTests = 0;
|
|
||||||
this.machineCurve = specs[0].machineCurve;
|
|
||||||
}
|
|
||||||
|
|
||||||
assert(condition, message) {
|
|
||||||
this.totalTests++;
|
|
||||||
if (condition) {
|
|
||||||
console.log(`✓ PASS: ${message}`);
|
|
||||||
this.passedTests++;
|
|
||||||
} else {
|
|
||||||
console.log(`✗ FAIL: ${message}`);
|
|
||||||
this.failedTests++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
createBaseMachineConfig(name) {
|
|
||||||
return {
|
|
||||||
general: {
|
|
||||||
logging: { enabled: true, logLevel: "debug" },
|
|
||||||
name: name,
|
|
||||||
unit: "m3/h"
|
|
||||||
},
|
|
||||||
functionality: {
|
|
||||||
softwareType: "machine",
|
|
||||||
role: "RotationalDeviceController"
|
|
||||||
},
|
|
||||||
asset: {
|
|
||||||
type: "pump",
|
|
||||||
subType: "Centrifugal",
|
|
||||||
model: "TestModel",
|
|
||||||
supplier: "Hydrostal",
|
|
||||||
machineCurve: this.machineCurve
|
|
||||||
},
|
|
||||||
mode: {
|
|
||||||
current: "auto",
|
|
||||||
allowedActions: {
|
|
||||||
auto: ["execSequence", "execMovement", "statusCheck"],
|
|
||||||
virtualControl: ["execMovement", "statusCheck"],
|
|
||||||
fysicalControl: ["statusCheck"]
|
|
||||||
},
|
|
||||||
allowedSources: {
|
|
||||||
auto: ["parent", "GUI"],
|
|
||||||
virtualControl: ["GUI"],
|
|
||||||
fysicalControl: ["fysical"]
|
|
||||||
}
|
|
||||||
},
|
|
||||||
sequences: {
|
|
||||||
startup: ["starting", "warmingup", "operational"],
|
|
||||||
shutdown: ["stopping", "coolingdown", "idle"],
|
|
||||||
emergencystop: ["emergencystop", "off"],
|
|
||||||
boot: ["idle", "starting", "warmingup", "operational"]
|
|
||||||
},
|
|
||||||
calculationMode: "medium"
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
createBaseMachineGroupConfig(name) {
|
|
||||||
return {
|
|
||||||
general: {
|
|
||||||
logging: { enabled: true, logLevel: "debug" },
|
|
||||||
name: name
|
|
||||||
},
|
|
||||||
functionality: {
|
|
||||||
softwareType: "machineGroup",
|
|
||||||
role: "GroupController"
|
|
||||||
},
|
|
||||||
scaling: {
|
|
||||||
current: "normalized"
|
|
||||||
},
|
|
||||||
mode: {
|
|
||||||
current: "optimalControl"
|
|
||||||
}
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
async testSingleMachineOperation() {
|
|
||||||
console.log('\nTesting Single Machine Operation...');
|
|
||||||
|
|
||||||
const machineGroupConfig = this.createBaseMachineGroupConfig("TestMachineGroup");
|
|
||||||
const machineConfig = this.createBaseMachineConfig("TestMachine1");
|
|
||||||
|
|
||||||
try {
|
|
||||||
const mg = new MachineGroup(machineGroupConfig);
|
|
||||||
const machine = new Machine(machineConfig);
|
|
||||||
|
|
||||||
// Register machine with group
|
|
||||||
mg.childRegistrationUtils.registerChild(machine, "downstream");
|
|
||||||
machine.measurements.type("pressure").variant("measured").position("downstream").value(800);
|
|
||||||
await machine.state.transitionToState("idle");
|
|
||||||
|
|
||||||
// Test 1: Basic initialization
|
|
||||||
this.assert(
|
|
||||||
Object.keys(mg.machines).length === 0,
|
|
||||||
'Machine group should have exactly zero machine'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 2: Calculate demand with single machine
|
|
||||||
await machine.handleInput("parent", "execSequence", "startup");
|
|
||||||
await mg.handleFlowInput(50);
|
|
||||||
this.assert(
|
|
||||||
mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() > 0,
|
|
||||||
'Total flow should be greater than 0 for demand of 50'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 3: Check machine mode handling
|
|
||||||
machine.setMode("virtualControl");
|
|
||||||
const {single, machineNum} = mg.singleMachine();
|
|
||||||
this.assert(
|
|
||||||
single === true,
|
|
||||||
'Should identify as single machine when in virtual control'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 4: Zero demand handling
|
|
||||||
await mg.handleFlowInput(0);
|
|
||||||
this.assert(
|
|
||||||
!mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() ||
|
|
||||||
mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() === 0,
|
|
||||||
'Total flow should be 0 for zero demand'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 5: Max demand handling
|
|
||||||
await mg.handleFlowInput(100);
|
|
||||||
this.assert(
|
|
||||||
mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() > 0,
|
|
||||||
'Total flow should be greater than 0 for max demand'
|
|
||||||
);
|
|
||||||
|
|
||||||
} catch (error) {
|
|
||||||
console.error('Test failed with error:', error);
|
|
||||||
this.failedTests++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
async testMultipleMachineOperation() {
|
|
||||||
console.log('\nTesting Multiple Machine Operation...');
|
|
||||||
|
|
||||||
const machineGroupConfig = this.createBaseMachineGroupConfig("TestMachineGroup");
|
|
||||||
|
|
||||||
try {
|
|
||||||
const mg = new MachineGroup(machineGroupConfig);
|
|
||||||
const machine1 = new Machine(this.createBaseMachineConfig("Machine1"));
|
|
||||||
const machine2 = new Machine(this.createBaseMachineConfig("Machine2"));
|
|
||||||
|
|
||||||
mg.childRegistrationUtils.registerChild(machine1, "downstream");
|
|
||||||
mg.childRegistrationUtils.registerChild(machine2, "downstream");
|
|
||||||
|
|
||||||
machine1.measurements.type("pressure").variant("measured").position("downstream").value(800);
|
|
||||||
machine2.measurements.type("pressure").variant("measured").position("downstream").value(800);
|
|
||||||
|
|
||||||
await machine1.state.transitionToState("idle");
|
|
||||||
await machine2.state.transitionToState("idle");
|
|
||||||
|
|
||||||
await machine1.handleInput("parent", "execSequence", "startup");
|
|
||||||
await machine2.handleInput("parent", "execSequence", "startup");
|
|
||||||
|
|
||||||
// Test 1: Multiple machine registration
|
|
||||||
this.assert(
|
|
||||||
Object.keys(mg.machines).length === 2,
|
|
||||||
'Machine group should have exactly two machines'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 1.1: Calculate demand with multiple machines
|
|
||||||
await mg.handleFlowInput(0); // Testing with higher demand for two machines
|
|
||||||
const machineOutputs = Object.keys(mg.machines).filter(id =>
|
|
||||||
mg.machines[id].measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() > 0
|
|
||||||
);
|
|
||||||
|
|
||||||
this.assert(
|
|
||||||
mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() > 0 &&
|
|
||||||
machineOutputs.length > 0,
|
|
||||||
'Should distribute load between machines'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 1.2: Calculate demand with multiple machines with an increment of 10
|
|
||||||
for(let i = 0; i < 100; i+=10){
|
|
||||||
await mg.handleFlowInput(i); // Testing with incrementing demand
|
|
||||||
const flowValue = mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue();
|
|
||||||
this.assert(
|
|
||||||
flowValue !== undefined && !isNaN(flowValue),
|
|
||||||
`Should handle demand of ${i} units properly`
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test 2: Calculate nonsense demands with multiple machines
|
|
||||||
await mg.handleFlowInput(150); // Testing with higher demand for two machines
|
|
||||||
this.assert(
|
|
||||||
mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() > 0,
|
|
||||||
'Should handle excessive demand gracefully'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 3: Force single machine mode
|
|
||||||
machine2.setMode("maintenance");
|
|
||||||
const {single} = mg.singleMachine();
|
|
||||||
this.assert(
|
|
||||||
single === true,
|
|
||||||
'Should identify as single machine when one machine is in maintenance'
|
|
||||||
);
|
|
||||||
} catch (error) {
|
|
||||||
console.error('Test failed with error:', error);
|
|
||||||
this.failedTests++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
async testDynamicTotals() {
|
|
||||||
console.log('\nTesting Dynamic Totals...');
|
|
||||||
|
|
||||||
const mg = new MachineGroup(this.createBaseMachineGroupConfig("TestMachineGroup"));
|
|
||||||
const machine = new Machine(this.createBaseMachineConfig("TestMachine"));
|
|
||||||
|
|
||||||
try {
|
|
||||||
mg.childRegistrationUtils.registerChild(machine, "downstream");
|
|
||||||
machine.measurements.type("pressure").variant("measured").position("downstream").value(800);
|
|
||||||
await machine.state.transitionToState("idle");
|
|
||||||
await machine.handleInput("parent", "execSequence", "startup");
|
|
||||||
|
|
||||||
// Test 1: Dynamic totals initialization
|
|
||||||
const maxFlow = machine.predictFlow.currentFxyYMax;
|
|
||||||
const maxPower = machine.predictPower.currentFxyYMax;
|
|
||||||
|
|
||||||
this.assert(
|
|
||||||
mg.dynamicTotals.flow.max === maxFlow && mg.dynamicTotals.power.max === maxPower,
|
|
||||||
'Dynamic totals should reflect machine capabilities'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 2: Demand scaling
|
|
||||||
await mg.handleFlowInput(50); // 50% of max
|
|
||||||
const actualFlow = mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue();
|
|
||||||
this.assert(
|
|
||||||
actualFlow <= maxFlow * 0.6, // Allow some margin for interpolation
|
|
||||||
'Scaled demand should be approximately 50% of max flow'
|
|
||||||
);
|
|
||||||
} catch (error) {
|
|
||||||
console.error('Test failed with error:', error);
|
|
||||||
this.failedTests++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
async testInterpolation() {
|
|
||||||
console.log('\nTesting Interpolation...');
|
|
||||||
|
|
||||||
const machineGroupConfig = this.createBaseMachineGroupConfig("TestMachineGroup");
|
|
||||||
const machineConfig = this.createBaseMachineConfig("TestMachine");
|
|
||||||
|
|
||||||
try {
|
|
||||||
const mg = new MachineGroup(machineGroupConfig);
|
|
||||||
const machine = new Machine(machineConfig);
|
|
||||||
|
|
||||||
// Register machine and set initial state
|
|
||||||
mg.childRegistrationUtils.registerChild(machine, "downstream");
|
|
||||||
machine.measurements.type("pressure").variant("measured").position("downstream").value(1);
|
|
||||||
machine.state.transitionToState("idle");
|
|
||||||
|
|
||||||
// Test interpolation at different demand points
|
|
||||||
const testPoints = [0, 25, 50, 75, 100];
|
|
||||||
for (const demand of testPoints) {
|
|
||||||
await mg.handleFlowInput(demand);
|
|
||||||
const flowValue = mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue();
|
|
||||||
const powerValue = mg.measurements.type("power").variant("predicted").position("upstream").getCurrentValue();
|
|
||||||
|
|
||||||
this.assert(
|
|
||||||
flowValue !== undefined && !isNaN(flowValue),
|
|
||||||
`Interpolation should produce valid flow value for demand ${demand}`
|
|
||||||
);
|
|
||||||
this.assert(
|
|
||||||
powerValue !== undefined && !isNaN(powerValue),
|
|
||||||
`Interpolation should produce valid power value for demand ${demand}`
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test interpolation between curve points
|
|
||||||
const interpolatedPoint = 45; // Should interpolate between 40 and 60
|
|
||||||
await mg.handleFlowInput(interpolatedPoint);
|
|
||||||
this.assert(
|
|
||||||
mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() > 0,
|
|
||||||
`Interpolation should handle non-exact point ${interpolatedPoint}`
|
|
||||||
);
|
|
||||||
|
|
||||||
} catch (error) {
|
|
||||||
console.error('Test failed with error:', error);
|
|
||||||
this.failedTests++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
async testSingleMachineControlModes() {
|
|
||||||
console.log('\nTesting Single Machine Control Modes...');
|
|
||||||
|
|
||||||
const machineGroupConfig = this.createBaseMachineGroupConfig("TestMachineGroup");
|
|
||||||
const machineConfig = this.createBaseMachineConfig("TestMachine1");
|
|
||||||
|
|
||||||
try {
|
|
||||||
const mg = new MachineGroup(machineGroupConfig);
|
|
||||||
const machine = new Machine(machineConfig);
|
|
||||||
|
|
||||||
// Register machine and initialize
|
|
||||||
mg.childRegistrationUtils.registerChild(machine, "downstream");
|
|
||||||
machine.measurements.type("pressure").variant("measured").position("downstream").value(800);
|
|
||||||
await machine.state.transitionToState("idle");
|
|
||||||
await machine.handleInput("parent", "execSequence", "startup");
|
|
||||||
|
|
||||||
// Test 1: Virtual Control Mode
|
|
||||||
machine.setMode("virtualControl");
|
|
||||||
await mg.handleFlowInput(50);
|
|
||||||
this.assert(
|
|
||||||
machine.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() !== undefined,
|
|
||||||
'Should handle virtual control mode'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 2: Physical Control Mode
|
|
||||||
machine.setMode("fysicalControl");
|
|
||||||
await mg.handleFlowInput(75);
|
|
||||||
this.assert(
|
|
||||||
machine.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() !== undefined,
|
|
||||||
'Should handle physical control mode'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 3: Auto Mode Return
|
|
||||||
machine.setMode("auto");
|
|
||||||
await mg.handleFlowInput(60);
|
|
||||||
this.assert(
|
|
||||||
mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() > 0,
|
|
||||||
'Should return to normal operation in auto mode'
|
|
||||||
);
|
|
||||||
|
|
||||||
} catch (error) {
|
|
||||||
console.error('Test failed with error:', error);
|
|
||||||
this.failedTests++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
async testMachinesOffNormalized() {
|
|
||||||
console.log('\nTesting Machines Off with Normalized Flow...');
|
|
||||||
|
|
||||||
const machineGroupConfig = this.createBaseMachineGroupConfig("TestMachineGroup_OffNormalized");
|
|
||||||
// scaling is "normalized" by default
|
|
||||||
const mg = new MachineGroup(machineGroupConfig);
|
|
||||||
const machine = new Machine(this.createBaseMachineConfig("TestMachine_OffNormalized"));
|
|
||||||
|
|
||||||
mg.childRegistrationUtils.registerChild(machine, "downstream");
|
|
||||||
machine.measurements.type("pressure").variant("measured").position("downstream").value(800);
|
|
||||||
await machine.state.transitionToState("idle");
|
|
||||||
await machine.handleInput("parent", "execSequence", "startup");
|
|
||||||
|
|
||||||
// Turn machines off by setting demand to 0 with normalized scaling
|
|
||||||
await mg.handleFlowInput(-1);
|
|
||||||
this.assert(
|
|
||||||
!mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() ||
|
|
||||||
mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() === 0,
|
|
||||||
'Total flow should be 0 when demand is < 0 in normalized scaling'
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
async testMachinesOffAbsolute() {
|
|
||||||
console.log('\nTesting Machines Off with Absolute Flow...');
|
|
||||||
|
|
||||||
const machineGroupConfig = this.createBaseMachineGroupConfig("TestMachineGroup_OffAbsolute");
|
|
||||||
// Switch scaling to "absolute"
|
|
||||||
machineGroupConfig.scaling.current = "absolute";
|
|
||||||
const mg = new MachineGroup(machineGroupConfig);
|
|
||||||
const machine = new Machine(this.createBaseMachineConfig("TestMachine_OffAbsolute"));
|
|
||||||
|
|
||||||
mg.childRegistrationUtils.registerChild(machine, "downstream");
|
|
||||||
machine.measurements.type("pressure").variant("measured").position("downstream").value(800);
|
|
||||||
await machine.state.transitionToState("idle");
|
|
||||||
await machine.handleInput("parent", "execSequence", "startup");
|
|
||||||
|
|
||||||
// Turn machines off by setting demand to 0 with absolute scaling
|
|
||||||
await mg.handleFlowInput(0);
|
|
||||||
this.assert(
|
|
||||||
!mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() ||
|
|
||||||
mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() === 0,
|
|
||||||
'Total flow should be 0 when demand is 0 in absolute scaling'
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
async testPriorityControl() {
|
|
||||||
console.log('\nTesting Priority Control...');
|
|
||||||
|
|
||||||
const machineGroupConfig = this.createBaseMachineGroupConfig("TestMachineGroup_Priority");
|
|
||||||
const mg = new MachineGroup(machineGroupConfig);
|
|
||||||
|
|
||||||
try {
|
|
||||||
// Create 3 machines with different configurations for clearer testing
|
|
||||||
const machines = [];
|
|
||||||
for(let i = 1; i <= 3; i++) {
|
|
||||||
const machineConfig = this.createBaseMachineConfig(`Machine${i}`);
|
|
||||||
const machine = new Machine(machineConfig);
|
|
||||||
machines.push(machine);
|
|
||||||
mg.childRegistrationUtils.registerChild(machine, "downstream");
|
|
||||||
|
|
||||||
// Set different max flows to make priority visible
|
|
||||||
machine.predictFlow = {
|
|
||||||
currentFxyYMin: 10 * i, // Different min flows
|
|
||||||
currentFxyYMax: 50 * i // Different max flows
|
|
||||||
};
|
|
||||||
|
|
||||||
machine.measurements.type("pressure").variant("measured").position("downstream").value(800);
|
|
||||||
await machine.state.transitionToState("idle");
|
|
||||||
await machine.handleInput("parent", "execSequence", "startup");
|
|
||||||
|
|
||||||
// Mock the inputFlowCalcPower method for testing
|
|
||||||
machine.inputFlowCalcPower = (flow) => flow * 2; // Simple mock function
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test 1: Default priority (by machine ID)
|
|
||||||
// Use handleInput which routes to equalControl in prioritycontrol mode
|
|
||||||
await mg.handleInput("parent", 80);
|
|
||||||
const flowAfterDefaultPriority = Object.values(mg.machines).map(machine =>
|
|
||||||
machine.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() || 0
|
|
||||||
);
|
|
||||||
this.assert(
|
|
||||||
flowAfterDefaultPriority[0] > 0 && flowAfterDefaultPriority[1] > 0 && flowAfterDefaultPriority[2] === 0,
|
|
||||||
'Default priority should use machines in ID order until demand is met'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 2: Custom priority list
|
|
||||||
await mg.handleInput("parent", 120, Infinity, [3, 2, 1]);
|
|
||||||
await new Promise(resolve => setTimeout(resolve, 100));
|
|
||||||
const flowAfterCustomPriority = Object.values(mg.machines).map(machine =>
|
|
||||||
machine.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() || 0
|
|
||||||
);
|
|
||||||
this.assert(
|
|
||||||
flowAfterCustomPriority[2] > 0 && flowAfterCustomPriority[1] > 0 && flowAfterCustomPriority[0] === 0,
|
|
||||||
'Custom priority should use machines in specified order until demand is met'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 3: Zero demand should shut down all machines
|
|
||||||
await mg.handleInput("parent", 0);
|
|
||||||
const noFlowCondition = Object.values(mg.machines).every(machine =>
|
|
||||||
!machine.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() ||
|
|
||||||
machine.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() === 0
|
|
||||||
);
|
|
||||||
this.assert(
|
|
||||||
noFlowCondition,
|
|
||||||
'Zero demand should result in no flow from any machine'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 4: Handling excessive demand (more than total capacity)
|
|
||||||
const totalMaxFlow = machines.reduce((sum, machine) => sum + machine.predictFlow.currentFxyYMax, 0);
|
|
||||||
await mg.handleInput("parent", totalMaxFlow + 100);
|
|
||||||
const totalActualFlow = mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue();
|
|
||||||
this.assert(
|
|
||||||
totalActualFlow <= totalMaxFlow && totalActualFlow > 0,
|
|
||||||
'Excessive demand should be capped to maximum possible flow'
|
|
||||||
);
|
|
||||||
|
|
||||||
// Test 5: Check all measurements are updated correctly
|
|
||||||
this.assert(
|
|
||||||
mg.measurements.type("power").variant("predicted").position("upstream").getCurrentValue() > 0 &&
|
|
||||||
mg.measurements.type("efficiency").variant("predicted").position("downstream").getCurrentValue() > 0,
|
|
||||||
'All measurements should be updated after priority control'
|
|
||||||
);
|
|
||||||
|
|
||||||
} catch (error) {
|
|
||||||
console.error('Priority control test failed with error:', error);
|
|
||||||
this.failedTests++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
async runAllTests() {
|
|
||||||
console.log('Starting MachineGroup Tests...\n');
|
|
||||||
|
|
||||||
await this.testSingleMachineOperation();
|
|
||||||
await this.testMultipleMachineOperation();
|
|
||||||
await this.testDynamicTotals();
|
|
||||||
await this.testInterpolation();
|
|
||||||
await this.testSingleMachineControlModes();
|
|
||||||
await this.testMachinesOffNormalized();
|
|
||||||
await this.testMachinesOffAbsolute();
|
|
||||||
await this.testPriorityControl(); // Add the new test
|
|
||||||
await testCombinationIterations();
|
|
||||||
|
|
||||||
console.log('\nTest Summary:');
|
|
||||||
console.log(`Total Tests: ${this.totalTests}`);
|
|
||||||
console.log(`Passed: ${this.passedTests}`);
|
|
||||||
console.log(`Failed: ${this.failedTests}`);
|
|
||||||
|
|
||||||
// Return exit code based on test results
|
|
||||||
process.exit(this.failedTests > 0 ? 1 : 0);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Add a custom logger to capture debug logs during tests
|
|
||||||
class CapturingLogger {
|
|
||||||
constructor() {
|
|
||||||
this.logs = [];
|
|
||||||
}
|
|
||||||
debug(message) {
|
|
||||||
this.logs.push({ level: "debug", message });
|
|
||||||
console.debug(message);
|
|
||||||
}
|
|
||||||
info(message) {
|
|
||||||
this.logs.push({ level: "info", message });
|
|
||||||
console.info(message);
|
|
||||||
}
|
|
||||||
warn(message) {
|
|
||||||
this.logs.push({ level: "warn", message });
|
|
||||||
console.warn(message);
|
|
||||||
}
|
|
||||||
error(message) {
|
|
||||||
this.logs.push({ level: "error", message });
|
|
||||||
console.error(message);
|
|
||||||
}
|
|
||||||
getAll() {
|
|
||||||
return this.logs;
|
|
||||||
}
|
|
||||||
clear() {
|
|
||||||
this.logs = [];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Modify one of the test functions to override the machineGroup logger
|
|
||||||
async function testCombinationIterations() {
|
|
||||||
console.log('\nTesting Combination Iterations Logging...');
|
|
||||||
|
|
||||||
const machineGroupConfig = tester.createBaseMachineGroupConfig("TestCombinationIterations");
|
|
||||||
const mg = new MachineGroup(machineGroupConfig);
|
|
||||||
|
|
||||||
// Override logger with a capturing logger
|
|
||||||
const customLogger = new CapturingLogger();
|
|
||||||
mg.logger = customLogger;
|
|
||||||
|
|
||||||
// Create one machine for simplicity (or two if you like)
|
|
||||||
const machine = new Machine(tester.createBaseMachineConfig("TestMachineForCombo"));
|
|
||||||
mg.childRegistrationUtils.registerChild(machine, "downstream");
|
|
||||||
machine.measurements.type("pressure").variant("measured").position("downstream").value(800);
|
|
||||||
await machine.state.transitionToState("idle");
|
|
||||||
await machine.handleInput("parent", "execSequence", "startup");
|
|
||||||
|
|
||||||
// For testing, force dynamic totals so that combination search is exercised
|
|
||||||
mg.dynamicTotals.flow = { min: 0, max: 200 }; // example totalling
|
|
||||||
// Call handleFlowInput with a demand that requires iterations
|
|
||||||
await mg.handleFlowInput(120);
|
|
||||||
|
|
||||||
// After running, output captured iteration debug logs
|
|
||||||
console.log("\n-- Captured Debug Logs for Combination Search Iterations --");
|
|
||||||
customLogger.getAll().forEach(log => {
|
|
||||||
if(log.level === "debug") {
|
|
||||||
console.log(log.message);
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
// Also output best result details if any needed for further improvement
|
|
||||||
console.log("\n-- Final Output --");
|
|
||||||
const totalFlow = mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue();
|
|
||||||
console.log("Total Flow: ", totalFlow);
|
|
||||||
|
|
||||||
// Get machine outputs by checking each machine's measurements
|
|
||||||
const machineOutputs = {};
|
|
||||||
Object.entries(mg.machines).forEach(([id, machine]) => {
|
|
||||||
const flow = machine.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue();
|
|
||||||
if (flow) machineOutputs[id] = flow;
|
|
||||||
});
|
|
||||||
console.log("Machine Outputs: ", machineOutputs);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Run the tests
|
|
||||||
const tester = new MachineGroupTester();
|
|
||||||
tester.runAllTests().catch(console.error);
|
|
||||||
188
dependencies/machineGroup/machineGroupConfig.json
vendored
188
dependencies/machineGroup/machineGroupConfig.json
vendored
@@ -1,188 +0,0 @@
|
|||||||
{
|
|
||||||
"general": {
|
|
||||||
"name": {
|
|
||||||
"default": "Machine Group Configuration",
|
|
||||||
"rules": {
|
|
||||||
"type": "string",
|
|
||||||
"description": "A human-readable name or label for this machine group configuration."
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"id": {
|
|
||||||
"default": null,
|
|
||||||
"rules": {
|
|
||||||
"type": "string",
|
|
||||||
"nullable": true,
|
|
||||||
"description": "A unique identifier for this configuration. If not provided, defaults to null."
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"logging": {
|
|
||||||
"logLevel": {
|
|
||||||
"default": "info",
|
|
||||||
"rules": {
|
|
||||||
"type": "enum",
|
|
||||||
"values": [
|
|
||||||
{
|
|
||||||
"value": "debug",
|
|
||||||
"description": "Log messages are printed for debugging purposes."
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"value": "info",
|
|
||||||
"description": "Informational messages are printed."
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"value": "warn",
|
|
||||||
"description": "Warning messages are printed."
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"value": "error",
|
|
||||||
"description": "Error messages are printed."
|
|
||||||
}
|
|
||||||
]
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"enabled": {
|
|
||||||
"default": true,
|
|
||||||
"rules": {
|
|
||||||
"type": "boolean",
|
|
||||||
"description": "Indicates whether logging is active. If true, log messages will be generated."
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"functionality": {
|
|
||||||
"softwareType": {
|
|
||||||
"default": "machineGroup",
|
|
||||||
"rules": {
|
|
||||||
"type": "string",
|
|
||||||
"description": "Logical name identifying the software type."
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"role": {
|
|
||||||
"default": "GroupController",
|
|
||||||
"rules": {
|
|
||||||
"type": "string",
|
|
||||||
"description": "Controls a group of machines within the system."
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"mode": {
|
|
||||||
"current": {
|
|
||||||
"default": "optimalControl",
|
|
||||||
"rules": {
|
|
||||||
"type": "enum",
|
|
||||||
"values": [
|
|
||||||
{
|
|
||||||
"value": "optimalControl",
|
|
||||||
"description": "The group controller selects the most optimal combination of machines based on their real-time performance curves."
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"value": "priorityControl",
|
|
||||||
"description": "Machines are controlled sequentially from minimum to maximum output until each is maxed out, then additional machines are added."
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"value": "prioritypercentagecontrol",
|
|
||||||
"description": "Machines are controlled sequentially from minimum to maximum output until each is maxed out, then additional machines are added based on a percentage of the total demand."
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"value": "maintenance",
|
|
||||||
"description": "The group is in maintenance mode with limited actions (monitoring only)."
|
|
||||||
}
|
|
||||||
],
|
|
||||||
"description": "The operational mode of the machine group controller."
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"allowedActions": {
|
|
||||||
"default": {},
|
|
||||||
"rules": {
|
|
||||||
"type": "object",
|
|
||||||
"schema": {
|
|
||||||
"optimalControl": {
|
|
||||||
"default": ["statusCheck", "execOptimalCombination", "balanceLoad", "emergencyStop"],
|
|
||||||
"rules": {
|
|
||||||
"type": "set",
|
|
||||||
"itemType": "string",
|
|
||||||
"description": "Actions allowed in optimalControl mode."
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"priorityControl": {
|
|
||||||
"default": ["statusCheck", "execSequentialControl", "balanceLoad", "emergencyStop"],
|
|
||||||
"rules": {
|
|
||||||
"type": "set",
|
|
||||||
"itemType": "string",
|
|
||||||
"description": "Actions allowed in priorityControl mode."
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"prioritypercentagecontrol": {
|
|
||||||
"default": ["statusCheck", "execSequentialControl", "balanceLoad", "emergencyStop"],
|
|
||||||
"rules": {
|
|
||||||
"type": "set",
|
|
||||||
"itemType": "string",
|
|
||||||
"description": "Actions allowed in manualOverride mode."
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"maintenance": {
|
|
||||||
"default": ["statusCheck"],
|
|
||||||
"rules": {
|
|
||||||
"type": "set",
|
|
||||||
"itemType": "string",
|
|
||||||
"description": "Actions allowed in maintenance mode."
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"description": "Defines the actions available for each operational mode of the machine group controller."
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"allowedSources": {
|
|
||||||
"default": {},
|
|
||||||
"rules": {
|
|
||||||
"type": "object",
|
|
||||||
"schema": {
|
|
||||||
"optimalcontrol": {
|
|
||||||
"default": ["parent", "GUI", "physical", "API"],
|
|
||||||
"rules": {
|
|
||||||
"type": "set",
|
|
||||||
"itemType": "string",
|
|
||||||
"description": "Command sources allowed in optimalControl mode."
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"prioritycontrol": {
|
|
||||||
"default": ["parent", "GUI", "physical", "API"],
|
|
||||||
"rules": {
|
|
||||||
"type": "set",
|
|
||||||
"itemType": "string",
|
|
||||||
"description": "Command sources allowed in priorityControl mode."
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"prioritypercentagecontrol": {
|
|
||||||
"default": ["parent", "GUI", "physical", "API"],
|
|
||||||
"rules": {
|
|
||||||
"type": "set",
|
|
||||||
"itemType": "string",
|
|
||||||
"description": "Command sources allowed "
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"description": "Specifies the valid command sources recognized by the machine group controller for each mode."
|
|
||||||
}
|
|
||||||
}
|
|
||||||
},
|
|
||||||
"scaling": {
|
|
||||||
"current": {
|
|
||||||
"default": "normalized",
|
|
||||||
"rules": {
|
|
||||||
"type": "enum",
|
|
||||||
"values": [
|
|
||||||
{
|
|
||||||
"value": "normalized",
|
|
||||||
"description": "Scales the demand between 0–100% of the total flow capacity, interpolating to calculate the effective demand."
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"value": "absolute",
|
|
||||||
"description": "Uses the absolute demand value directly, capped between the min and max machine flow capacities."
|
|
||||||
}
|
|
||||||
],
|
|
||||||
"description": "The scaling mode for demand calculations."
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
137
dependencies/test.js
vendored
137
dependencies/test.js
vendored
@@ -1,137 +0,0 @@
|
|||||||
/**
|
|
||||||
* This file implements a pump optimization algorithm that:
|
|
||||||
* 1. Models different pumps with efficiency characteristics
|
|
||||||
* 2. Determines all possible pump combinations that can meet a demand flow
|
|
||||||
* 3. Finds the optimal combination that minimizes power consumption
|
|
||||||
* 4. Tests the algorithm with different demand levels
|
|
||||||
*/
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Pump Class
|
|
||||||
* Represents a pump with specific operating characteristics including:
|
|
||||||
* - Maximum flow capacity
|
|
||||||
* - Center of Gravity (CoG) for efficiency
|
|
||||||
* - Efficiency curve mapping flow percentages to power consumption
|
|
||||||
*/
|
|
||||||
class Pump {
|
|
||||||
constructor(name, maxFlow, cog, efficiencyCurve) {
|
|
||||||
this.name = name;
|
|
||||||
this.maxFlow = maxFlow; // Maximum flow at a given pressure
|
|
||||||
this.CoG = cog; // Efficiency center of gravity percentage
|
|
||||||
this.efficiencyCurve = efficiencyCurve; // Flow % -> Power usage mapping
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns pump flow at a given pressure
|
|
||||||
* Currently assumes constant flow regardless of pressure
|
|
||||||
*/
|
|
||||||
getFlow(pressure) {
|
|
||||||
return this.maxFlow; // Assume constant flow at a given pressure
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Calculates power consumption based on flow and pressure
|
|
||||||
* Uses the efficiency curve when available, otherwise uses linear approximation
|
|
||||||
*/
|
|
||||||
getPowerConsumption(flow, pressure) {
|
|
||||||
let flowPercent = flow / this.maxFlow;
|
|
||||||
return this.efficiencyCurve[flowPercent] || (1.2 * flow); // Default linear approximation
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Test pump definitions
|
|
||||||
* Three pump models with different flow capacities and efficiency characteristics
|
|
||||||
*/
|
|
||||||
const pumps = [
|
|
||||||
new Pump("Pump A", 100, 0.6, {0.6: 50, 0.8: 70, 1.0: 100}),
|
|
||||||
new Pump("Pump B", 120, 0.7, {0.6: 55, 0.8: 75, 1.0: 110}),
|
|
||||||
new Pump("Pump C", 90, 0.5, {0.5: 40, 0.7: 60, 1.0: 90}),
|
|
||||||
];
|
|
||||||
|
|
||||||
const pressure = 1.0; // Assume constant pressure
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Get all valid pump combinations that meet the required demand flow (Qd)
|
|
||||||
*
|
|
||||||
* @param {Array} pumps - Available pump array
|
|
||||||
* @param {Number} Qd - Required demand flow
|
|
||||||
* @param {Number} pressure - System pressure
|
|
||||||
* @returns {Array} Array of valid pump combinations that can meet or exceed the demand
|
|
||||||
*
|
|
||||||
* This function:
|
|
||||||
* 1. Generates all possible subsets of pumps (power set)
|
|
||||||
* 2. Filters for non-empty subsets that can meet or exceed demand flow
|
|
||||||
*/
|
|
||||||
function getValidPumpCombinations(pumps, Qd, pressure) {
|
|
||||||
let subsets = [[]];
|
|
||||||
for (let pump of pumps) {
|
|
||||||
let newSubsets = subsets.map(set => [...set, pump]);
|
|
||||||
subsets = subsets.concat(newSubsets);
|
|
||||||
}
|
|
||||||
return subsets.filter(subset => subset.length > 0 &&
|
|
||||||
subset.reduce((sum, p) => sum + p.getFlow(pressure), 0) >= Qd);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Find the optimal pump combination that minimizes power consumption
|
|
||||||
*
|
|
||||||
* @param {Array} pumps - Available pump array
|
|
||||||
* @param {Number} Qd - Required demand flow
|
|
||||||
* @param {Number} pressure - System pressure
|
|
||||||
* @returns {Object} Object containing the best pump combination and its power consumption
|
|
||||||
*
|
|
||||||
* This function:
|
|
||||||
* 1. Gets all valid pump combinations that meet demand
|
|
||||||
* 2. For each combination, distributes flow based on CoG proportions
|
|
||||||
* 3. Calculates total power consumption for each distribution
|
|
||||||
* 4. Returns the combination with minimum power consumption
|
|
||||||
*/
|
|
||||||
function optimizePumpSelection(pumps, Qd, pressure) {
|
|
||||||
let validCombinations = getValidPumpCombinations(pumps, Qd, pressure);
|
|
||||||
let bestCombination = null;
|
|
||||||
let minPower = Infinity;
|
|
||||||
|
|
||||||
validCombinations.forEach(combination => {
|
|
||||||
let totalFlow = combination.reduce((sum, pump) => sum + pump.getFlow(pressure), 0);
|
|
||||||
let totalCoG = combination.reduce((sum, pump) => sum + pump.CoG, 0);
|
|
||||||
|
|
||||||
// Distribute flow based on CoG proportions
|
|
||||||
let flowDistribution = combination.map(pump => ({
|
|
||||||
pump,
|
|
||||||
flow: (pump.CoG / totalCoG) * Qd
|
|
||||||
}));
|
|
||||||
|
|
||||||
let totalPower = flowDistribution.reduce((sum, { pump, flow }) =>
|
|
||||||
sum + pump.getPowerConsumption(flow, pressure), 0);
|
|
||||||
|
|
||||||
if (totalPower < minPower) {
|
|
||||||
minPower = totalPower;
|
|
||||||
bestCombination = flowDistribution;
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
return { bestCombination, minPower };
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Test function that runs optimization for different demand levels
|
|
||||||
* Tests from 0% to 100% of total available flow in 10% increments
|
|
||||||
* Outputs the selected pumps, flow allocation, and power consumption for each scenario
|
|
||||||
*/
|
|
||||||
console.log("Pump Optimization Results:");
|
|
||||||
const totalAvailableFlow = pumps.reduce((sum, pump) => sum + pump.getFlow(pressure), 0);
|
|
||||||
|
|
||||||
for (let i = 0; i <= 10; i++) {
|
|
||||||
let Qd = (i / 10) * totalAvailableFlow; // Incremental flow demand
|
|
||||||
let { bestCombination, minPower } = optimizePumpSelection(pumps, Qd, pressure);
|
|
||||||
|
|
||||||
console.log(`\nTotal Demand Flow: ${Qd.toFixed(2)}`);
|
|
||||||
console.log("Selected Pumps and Allocated Flow:");
|
|
||||||
|
|
||||||
bestCombination.forEach(({ pump, flow }) => {
|
|
||||||
console.log(` ${pump.name}: ${flow.toFixed(2)} units`);
|
|
||||||
});
|
|
||||||
|
|
||||||
console.log(`Total Power Consumption: ${minPower.toFixed(2)} kW`);
|
|
||||||
}
|
|
||||||
15
mgc.html
15
mgc.html
@@ -57,13 +57,13 @@
|
|||||||
const node = this;
|
const node = this;
|
||||||
|
|
||||||
// Validate logger properties using the logger menu
|
// Validate logger properties using the logger menu
|
||||||
if (window.EVOLV?.nodes?.measurement?.loggerMenu?.saveEditor) {
|
if (window.EVOLV?.nodes?.machineGroupControl?.loggerMenu?.saveEditor) {
|
||||||
success = window.EVOLV.nodes.measurement.loggerMenu.saveEditor(node);
|
success = window.EVOLV.nodes.machineGroupControl.loggerMenu.saveEditor(node);
|
||||||
}
|
}
|
||||||
|
|
||||||
// save position field
|
// save position field
|
||||||
if (window.EVOLV?.nodes?.rotatingMachine?.positionMenu?.saveEditor) {
|
if (window.EVOLV?.nodes?.machineGroupControl?.positionMenu?.saveEditor) {
|
||||||
window.EVOLV.nodes.rotatingMachine.positionMenu.saveEditor(this);
|
window.EVOLV.nodes.machineGroupControl.positionMenu.saveEditor(this);
|
||||||
}
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
@@ -78,13 +78,6 @@
|
|||||||
|
|
||||||
<!-- Position fields injected here -->
|
<!-- Position fields injected here -->
|
||||||
<div id="position-fields-placeholder"></div>
|
<div id="position-fields-placeholder"></div>
|
||||||
|
|
||||||
|
|
||||||
<div class="form-tips"></div>
|
|
||||||
<b>Tip:</b> Ensure that the "Name" field is unique to easily identify the node.
|
|
||||||
Enable logging if you need detailed information for debugging purposes.
|
|
||||||
Choose the appropriate log level based on the verbosity required.
|
|
||||||
</div>
|
|
||||||
|
|
||||||
</script>
|
</script>
|
||||||
|
|
||||||
|
|||||||
@@ -94,7 +94,7 @@ class nodeClass {
|
|||||||
// Determine overall status based on available machines
|
// Determine overall status based on available machines
|
||||||
const status =
|
const status =
|
||||||
availableMachines.length > 0
|
availableMachines.length > 0
|
||||||
? `${availableMachines.length} machines`
|
? `${availableMachines.length} machine(s) connected`
|
||||||
: "No machines";
|
: "No machines";
|
||||||
|
|
||||||
let scalingSymbol = "";
|
let scalingSymbol = "";
|
||||||
@@ -197,7 +197,7 @@ class nodeClass {
|
|||||||
const RED = this.RED;
|
const RED = this.RED;
|
||||||
switch (msg.topic) {
|
switch (msg.topic) {
|
||||||
case "registerChild":
|
case "registerChild":
|
||||||
console.log(`Registering child in mgc: ${msg.payload}`);
|
//console.log(`Registering child in mgc: ${msg.payload}`);
|
||||||
const childId = msg.payload;
|
const childId = msg.payload;
|
||||||
const childObj = RED.nodes.getNode(childId);
|
const childObj = RED.nodes.getNode(childId);
|
||||||
mg.childRegistrationUtils.registerChild(
|
mg.childRegistrationUtils.registerChild(
|
||||||
|
|||||||
@@ -56,7 +56,7 @@ class MachineGroup {
|
|||||||
this.measurements = new MeasurementContainer();
|
this.measurements = new MeasurementContainer();
|
||||||
this.interpolation = new interpolation();
|
this.interpolation = new interpolation();
|
||||||
|
|
||||||
// Machines and children data
|
// Machines and child data
|
||||||
this.machines = {};
|
this.machines = {};
|
||||||
this.child = {};
|
this.child = {};
|
||||||
this.scaling = this.config.scaling.current;
|
this.scaling = this.config.scaling.current;
|
||||||
|
|||||||
Reference in New Issue
Block a user