woutverheijen/machineGroupControl
1
0
Fork 0
forked from RnD/machineGroupControl
Code Pull Requests Activity

small bug fixes

Browse Source
This commit is contained in:
znetsixe
2025-07-31 09:10:34 +02:00
parent 2aeb876c0d
commit de5652b73d
7 changed files with 7 additions and 1961 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1056
dependencies/machineGroup/machineGroup.js vendored
View File

File diff suppressed because it is too large Load Diff

566
dependencies/machineGroup/machineGroup.test.js vendored
View File

@@ -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
View File

@@ -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
View File

@@ -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
View File

@@ -57,13 +57,13 @@
const node = this;
// Validate logger properties using the logger menu
if (window.EVOLV?.nodes?.measurement?.loggerMenu?.saveEditor) {
success = window.EVOLV.nodes.measurement.loggerMenu.saveEditor(node);
if (window.EVOLV?.nodes?.machineGroupControl?.loggerMenu?.saveEditor) {
success = window.EVOLV.nodes.machineGroupControl.loggerMenu.saveEditor(node);
}
// save position field
if (window.EVOLV?.nodes?.rotatingMachine?.positionMenu?.saveEditor) {
window.EVOLV.nodes.rotatingMachine.positionMenu.saveEditor(this);
if (window.EVOLV?.nodes?.machineGroupControl?.positionMenu?.saveEditor) {
window.EVOLV.nodes.machineGroupControl.positionMenu.saveEditor(this);
}
}
@@ -78,13 +78,6 @@
<!-- Position fields injected here -->
<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>

4
src/nodeClass.js
View File

@@ -94,7 +94,7 @@ class nodeClass {
// Determine overall status based on available machines
const status =
availableMachines.length > 0
? `${availableMachines.length} machines`
? `${availableMachines.length} machine(s) connected`
: "No machines";
let scalingSymbol = "";
@@ -197,7 +197,7 @@ class nodeClass {
const RED = this.RED;
switch (msg.topic) {
case "registerChild":
console.log(`Registering child in mgc: ${msg.payload}`);
//console.log(`Registering child in mgc: ${msg.payload}`);
const childId = msg.payload;
const childObj = RED.nodes.getNode(childId);
mg.childRegistrationUtils.registerChild(

2
src/specificClass.js
View File

@@ -56,7 +56,7 @@ class MachineGroup {
this.measurements = new MeasurementContainer();
this.interpolation = new interpolation();
// Machines and children data
// Machines and child data
this.machines = {};
this.child = {};
this.scaling = this.config.scaling.current;