RnD/machineGroupControl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: RnD:dev-Rene
Branches Tags
RnD:main RnD:dev-Rene
..
compare: RnD:ffb2072baa86e61b0e7d80d57d7cf978eccd42c3
Branches Tags
RnD:main RnD:dev-Rene

2 Commits
dev-Rene ... ffb2072baa

Author SHA1 Message Date
znetsixe
ffb2072baa Merge commit '85797b5' into HEAD 
# Conflicts:
#	src/nodeClass.js
#	src/specificClass.js
 2026-03-31 18:17:41 +02:00
Rene De Ren
85797b5b8b Align machineGroupControl with current architecture 2026-03-12 16:43:29 +01:00
3 changed files with 203 additions and 180 deletions
Expand all files Collapse all files

20
mgc.html
View File

@@ -18,6 +18,8 @@
defaults: { defaults: {
// Define default properties // Define default properties
name: { value: "" }, name: { value: "" },
processOutputFormat: { value: "process" },
dbaseOutputFormat: { value: "influxdb" },
// Logger properties // Logger properties
enableLog: { value: false }, enableLog: { value: false },
@@ -74,6 +76,24 @@
<script type="text/html" data-template-name="machineGroupControl"> <script type="text/html" data-template-name="machineGroupControl">
<h3>Output Formats</h3>
<div class="form-row">
<label for="node-input-processOutputFormat"><i class="fa fa-random"></i> Process Output</label>
<select id="node-input-processOutputFormat" style="width:60%;">
<option value="process">process</option>
<option value="json">json</option>
<option value="csv">csv</option>
</select>
</div>
<div class="form-row">
<label for="node-input-dbaseOutputFormat"><i class="fa fa-database"></i> Database Output</label>
<select id="node-input-dbaseOutputFormat" style="width:60%;">
<option value="influxdb">influxdb</option>
<option value="json">json</option>
<option value="csv">csv</option>
</select>
</div>
<!-- Logger fields injected here --> <!-- Logger fields injected here -->
<div id="logger-fields-placeholder"></div> <div id="logger-fields-placeholder"></div>

45
src/nodeClass.js
View File

@@ -39,21 +39,9 @@ class nodeClass {
this.defaultConfig = cfgMgr.getConfig(this.name); this.defaultConfig = cfgMgr.getConfig(this.name);
const flowUnit = this._resolveUnitOrFallback(uiConfig.unit, 'volumeFlowRate', 'm3/h', 'flow'); const flowUnit = this._resolveUnitOrFallback(uiConfig.unit, 'volumeFlowRate', 'm3/h', 'flow');
// Merge UI config over defaults // Build config: base sections (no domain-specific config for group controller)
this.config = { this.config = cfgMgr.buildConfig(this.name, uiConfig, node.id);
general: {
name: uiConfig.name,
id: node.id, // node.id is for the child registration process
unit: flowUnit,
logging: {
enabled: uiConfig.enableLog,
logLevel: uiConfig.logLevel,
},
},
functionality: {
positionVsParent: uiConfig.positionVsParent || "atEquipment", // Default to 'atEquipment' if not set
},
};
// Utility for formatting outputs // Utility for formatting outputs
this._output = new outputUtils(); this._output = new outputUtils();
} }
@@ -81,14 +69,14 @@ class nodeClass {
const mg = this.source; const mg = this.source;
const mode = mg.mode; const mode = mg.mode;
const scaling = mg.scaling; const scaling = mg.scaling;
// Add safety checks for measurements // Add safety checks for measurements
const totalFlow = mg.measurements const totalFlow = mg.measurements
?.type("flow") ?.type("flow")
?.variant("predicted") ?.variant("predicted")
?.position("atequipment") ?.position("atequipment")
?.getCurrentValue(mg?.unitPolicy?.output?.flow || 'm3/h') || 0; ?.getCurrentValue(mg?.unitPolicy?.output?.flow || 'm3/h') || 0;
const totalPower = mg.measurements const totalPower = mg.measurements
?.type("power") ?.type("power")
?.variant("predicted") ?.variant("predicted")
@@ -102,7 +90,7 @@ class nodeClass {
mg.logger?.warn(`Machine missing or invalid: ${machine?.config?.general?.id || 'unknown'}`); mg.logger?.warn(`Machine missing or invalid: ${machine?.config?.general?.id || 'unknown'}`);
return false; return false;
} }
const state = machine.state.getCurrentState(); const state = machine.state.getCurrentState();
const mode = machine.currentMode; const mode = machine.currentMode;
return !( return !(
@@ -225,15 +213,27 @@ class nodeClass {
mg.logger.warn(`registerChild skipped: missing child/source for id=${childId}`); mg.logger.warn(`registerChild skipped: missing child/source for id=${childId}`);
break; break;
} }
mg.logger.debug(`Registering child: ${childId}, found: ${!!childObj}, source: ${!!childObj?.source}`);
mg.childRegistrationUtils.registerChild(childObj.source, msg.positionVsParent); mg.childRegistrationUtils.registerChild(childObj.source, msg.positionVsParent);
mg.logger.debug(`Total machines after registration: ${Object.keys(mg.machines || {}).length}`);
break; break;
} }
case "setMode":
mg.setMode(msg.payload); case "setMode": {
const mode = msg.payload;
mg.setMode(mode);
break; break;
case "setScaling": }
mg.setScaling(msg.payload);
case "setScaling": {
const scaling = msg.payload;
mg.setScaling(scaling);
break; break;
}
case "Qd": { case "Qd": {
const Qd = parseFloat(msg.payload); const Qd = parseFloat(msg.payload);
const sourceQd = "parent"; const sourceQd = "parent";
@@ -251,6 +251,7 @@ class nodeClass {
} }
break; break;
} }
default: default:
mg.logger.warn(`Unknown topic: ${msg.topic}`); mg.logger.warn(`Unknown topic: ${msg.topic}`);
break; break;

318
src/specificClass.js
View File

@@ -1,6 +1,6 @@
//load local dependencies //load local dependencies
const EventEmitter = require("events"); const EventEmitter = require("events");
const {logger,configUtils,configManager, MeasurementContainer, interpolation , childRegistrationUtils, convert} = require('generalFunctions'); const {logger,configUtils,configManager, MeasurementContainer, interpolation , childRegistrationUtils, convert, POSITIONS} = require('generalFunctions');
const CANONICAL_UNITS = Object.freeze({ const CANONICAL_UNITS = Object.freeze({
pressure: 'Pa', pressure: 'Pa',
@@ -37,7 +37,7 @@ class MachineGroup {
// Init after config is set // Init after config is set
this.logger = new logger(this.config.general.logging.enabled,this.config.general.logging.logLevel, this.config.general.name); this.logger = new logger(this.config.general.logging.enabled,this.config.general.logging.logLevel, this.config.general.name);
// Initialize measurements // Initialize measurements
this.measurements = new MeasurementContainer({ this.measurements = new MeasurementContainer({
autoConvert: true, autoConvert: true,
@@ -87,11 +87,11 @@ class MachineGroup {
// Prefer functionality-scoped position metadata; keep general fallback for legacy nodes. // Prefer functionality-scoped position metadata; keep general fallback for legacy nodes.
const position = child.config?.functionality?.positionVsParent || child.config?.general?.positionVsParent; const position = child.config?.functionality?.positionVsParent || child.config?.general?.positionVsParent;
if(softwareType == "machine"){ if(softwareType == "machine"){
// Check if the machine is already registered // Check if the machine is already registered
this.machines[child.config.general.id] === undefined ? this.machines[child.config.general.id] = child : this.logger.warn(`Machine ${child.config.general.id} is already registered.`); this.machines[child.config.general.id] === undefined ? this.machines[child.config.general.id] = child : this.logger.warn(`Machine ${child.config.general.id} is already registered.`);
//listen for machine pressure changes //listen for machine pressure changes
this.logger.debug(`Listening for pressure changes from machine ${child.config.general.id}`); this.logger.debug(`Listening for pressure changes from machine ${child.config.general.id}`);
@@ -119,11 +119,11 @@ class MachineGroup {
calcAbsoluteTotals() { calcAbsoluteTotals() {
const absoluteTotals = { flow: { min: Infinity, max: 0 }, power: { min: Infinity, max: 0 } }; const absoluteTotals = { flow: { min: Infinity, max: 0 }, power: { min: Infinity, max: 0 } };
Object.values(this.machines).forEach(machine => { Object.values(this.machines).forEach(machine => {
const totals = { flow: { min: Infinity, max: 0 }, power: { min: Infinity, max: 0 } }; const totals = { flow: { min: Infinity, max: 0 }, power: { min: Infinity, max: 0 } };
//fetch min flow ever seen over all machines //fetch min flow ever seen over all machines
Object.entries(machine.predictFlow.inputCurve).forEach(([pressure, xyCurve], index) => { Object.entries(machine.predictFlow.inputCurve).forEach(([pressure, xyCurve], _index) => {
const minFlow = Math.min(...xyCurve.y); const minFlow = Math.min(...xyCurve.y);
const maxFlow = Math.max(...xyCurve.y); const maxFlow = Math.max(...xyCurve.y);
@@ -143,27 +143,27 @@ class MachineGroup {
if( totals.power.min < absoluteTotals.power.min ){ absoluteTotals.power.min = totals.power.min; } if( totals.power.min < absoluteTotals.power.min ){ absoluteTotals.power.min = totals.power.min; }
absoluteTotals.flow.max += totals.flow.max; absoluteTotals.flow.max += totals.flow.max;
absoluteTotals.power.max += totals.power.max; absoluteTotals.power.max += totals.power.max;
}); });
if(absoluteTotals.flow.min === Infinity) { if(absoluteTotals.flow.min === Infinity) {
this.logger.warn(`Flow min ${absoluteTotals.flow.min} is Infinity. Setting to 0.`); this.logger.warn(`Flow min ${absoluteTotals.flow.min} is Infinity. Setting to 0.`);
absoluteTotals.flow.min = 0; absoluteTotals.flow.min = 0;
} }
if(absoluteTotals.power.min === Infinity) { if(absoluteTotals.power.min === Infinity) {
this.logger.warn(`Power min ${absoluteTotals.power.min} is Infinity. Setting to 0.`); this.logger.warn(`Power min ${absoluteTotals.power.min} is Infinity. Setting to 0.`);
absoluteTotals.power.min = 0; absoluteTotals.power.min = 0;
} }
if(absoluteTotals.flow.max === -Infinity) { if(absoluteTotals.flow.max === -Infinity) {
this.logger.warn(`Flow max ${absoluteTotals.flow.max} is -Infinity. Setting to 0.`); this.logger.warn(`Flow max ${absoluteTotals.flow.max} is -Infinity. Setting to 0.`);
absoluteTotals.flow.max = 0; absoluteTotals.flow.max = 0;
} }
if(absoluteTotals.power.max === -Infinity) { if(absoluteTotals.power.max === -Infinity) {
this.logger.warn(`Power max ${absoluteTotals.power.max} is -Infinity. Setting to 0.`); this.logger.warn(`Power max ${absoluteTotals.power.max} is -Infinity. Setting to 0.`);
absoluteTotals.power.max = 0; absoluteTotals.power.max = 0;
} }
// Place data in object for external use // Place data in object for external use
@@ -173,13 +173,13 @@ class MachineGroup {
} }
//max and min current flow and power based on their actual pressure curve //max and min current flow and power based on their actual pressure curve
calcDynamicTotals() { calcDynamicTotals() {
const dynamicTotals = { flow: { min: Infinity, max: 0, act: 0 }, power: { min: Infinity, max: 0, act: 0 }, NCog : 0 }; const dynamicTotals = { flow: { min: Infinity, max: 0, act: 0 }, power: { min: Infinity, max: 0, act: 0 }, NCog : 0 };
this.logger.debug(`\n --------- Calculating dynamic totals for ${Object.keys(this.machines).length} machines. @ current pressure settings : ----------`); this.logger.debug(`\n --------- Calculating dynamic totals for ${Object.keys(this.machines).length} machines. @ current pressure settings : ----------`);
Object.values(this.machines).forEach(machine => { Object.values(this.machines).forEach(machine => {
//skip machines without valid curve //skip machines without valid curve
if(!machine.hasCurve){ if(!machine.hasCurve){
@@ -191,13 +191,13 @@ class MachineGroup {
this.logger.debug(`Current pressure settings: ${JSON.stringify(machine.predictFlow.currentF)}`); this.logger.debug(`Current pressure settings: ${JSON.stringify(machine.predictFlow.currentF)}`);
//fetch min flow ever seen over all machines //fetch min flow ever seen over all machines
const minFlow = machine.predictFlow.currentFxyYMin; const minFlow = machine.predictFlow.currentFxyYMin;
const maxFlow = machine.predictFlow.currentFxyYMax; const maxFlow = machine.predictFlow.currentFxyYMax;
const minPower = machine.predictPower.currentFxyYMin; const minPower = machine.predictPower.currentFxyYMin;
const maxPower = machine.predictPower.currentFxyYMax; const maxPower = machine.predictPower.currentFxyYMax;
const actFlow = this._readChildMeasurement(machine, "flow", "predicted", "atequipment", this.unitPolicy.canonical.flow) || 0; const actFlow = this._readChildMeasurement(machine, "flow", "predicted", POSITIONS.DOWNSTREAM, this.unitPolicy.canonical.flow) || 0;
const actPower = this._readChildMeasurement(machine, "power", "predicted", "atequipment", this.unitPolicy.canonical.power) || 0; const actPower = this._readChildMeasurement(machine, "power", "predicted", POSITIONS.AT_EQUIPMENT, this.unitPolicy.canonical.power) || 0;
this.logger.debug(`Machine ${machine.config.general.id} - Min Flow: ${minFlow}, Max Flow: ${maxFlow}, Min Power: ${minPower}, Max Power: ${maxPower}, NCog: ${machine.NCog}`); this.logger.debug(`Machine ${machine.config.general.id} - Min Flow: ${minFlow}, Max Flow: ${maxFlow}, Min Power: ${minPower}, Max Power: ${maxPower}, NCog: ${machine.NCog}`);
@@ -211,7 +211,7 @@ class MachineGroup {
//fetch total Normalized Cog over all machines //fetch total Normalized Cog over all machines
dynamicTotals.NCog += machine.NCog; dynamicTotals.NCog += machine.NCog;
}); });
// Place data in object for external use // Place data in object for external use
@@ -227,19 +227,19 @@ class MachineGroup {
this.logger.debug(`Processing machine with id: ${id}`); this.logger.debug(`Processing machine with id: ${id}`);
if(this.isMachineActive(id)){ if(this.isMachineActive(id)){
//fetch min flow ever seen over all machines //fetch min flow ever seen over all machines
const minFlow = machine.predictFlow.currentFxyYMin; const minFlow = machine.predictFlow.currentFxyYMin;
const maxFlow = machine.predictFlow.currentFxyYMax; const maxFlow = machine.predictFlow.currentFxyYMax;
const minPower = machine.predictPower.currentFxyYMin; const minPower = machine.predictPower.currentFxyYMin;
const maxPower = machine.predictPower.currentFxyYMax; const maxPower = machine.predictPower.currentFxyYMax;
totals.flow.min += minFlow; totals.flow.min += minFlow;
totals.flow.max += maxFlow; totals.flow.max += maxFlow;
totals.power.min += minPower; totals.power.min += minPower;
totals.power.max += maxPower; totals.power.max += maxPower;
totals.countActiveMachines++; totals.countActiveMachines++;
} }
}); });
return totals; return totals;
@@ -251,11 +251,11 @@ class MachineGroup {
const { flow, power } = this.calcDynamicTotals(); const { flow, power } = this.calcDynamicTotals();
this.logger.debug(`Dynamic Totals after pressure change - Flow: Min ${flow.min}, Max ${flow.max}, Act ${flow.act} | Power: Min ${power.min}, Max ${power.max}, Act ${power.act}`); this.logger.debug(`Dynamic Totals after pressure change - Flow: Min ${flow.min}, Max ${flow.max}, Act ${flow.act} | Power: Min ${power.min}, Max ${power.max}, Act ${power.act}`);
this._writeMeasurement("flow", "predicted", "atequipment", flow.act, this.unitPolicy.canonical.flow); this._writeMeasurement("flow", "predicted", POSITIONS.AT_EQUIPMENT, flow.act, this.unitPolicy.canonical.flow);
this._writeMeasurement("power", "predicted", "atequipment", power.act, this.unitPolicy.canonical.power); this._writeMeasurement("power", "predicted", POSITIONS.AT_EQUIPMENT, power.act, this.unitPolicy.canonical.power);
const { maxEfficiency, lowestEfficiency } = this.calcGroupEfficiency(this.machines); const { maxEfficiency, lowestEfficiency } = this.calcGroupEfficiency(this.machines);
const efficiency = this.measurements.type("efficiency").variant("predicted").position("atequipment").getCurrentValue(); const efficiency = this.measurements.type("efficiency").variant("predicted").position(POSITIONS.AT_EQUIPMENT).getCurrentValue();
this.calcDistanceBEP(efficiency,maxEfficiency,lowestEfficiency); this.calcDistanceBEP(efficiency,maxEfficiency,lowestEfficiency);
} }
@@ -274,11 +274,11 @@ class MachineGroup {
calcDistanceBEP(efficiency,maxEfficiency,minEfficiency){ calcDistanceBEP(efficiency,maxEfficiency,minEfficiency){
const absDistFromPeak = this.calcDistanceFromPeak(efficiency,maxEfficiency); const absDistFromPeak = this.calcDistanceFromPeak(efficiency,maxEfficiency);
const relDistFromPeak = this.calcRelativeDistanceFromPeak(efficiency,maxEfficiency,minEfficiency); const relDistFromPeak = this.calcRelativeDistanceFromPeak(efficiency,maxEfficiency,minEfficiency);
//store internally //store internally
this.absDistFromPeak = absDistFromPeak ; this.absDistFromPeak = absDistFromPeak ;
this.relDistFromPeak = relDistFromPeak; this.relDistFromPeak = relDistFromPeak;
return { absDistFromPeak: absDistFromPeak, relDistFromPeak: relDistFromPeak }; return { absDistFromPeak: absDistFromPeak, relDistFromPeak: relDistFromPeak };
} }
@@ -287,15 +287,15 @@ class MachineGroup {
const state = machine.state.getCurrentState(); const state = machine.state.getCurrentState();
const mode = machine.currentMode; const mode = machine.currentMode;
//add special cases //add special cases
if( state === "operational" && ( mode == "virtualControl" || mode === "fysicalControl") ){ if( state === "operational" && ( mode == "virtualControl" || mode === "fysicalControl") ){
let flow = 0; let flow = 0;
const measuredFlow = this._readChildMeasurement(machine, "flow", "measured", "downstream", this.unitPolicy.canonical.flow); const measuredFlow = this._readChildMeasurement(machine, "flow", "measured", POSITIONS.DOWNSTREAM, this.unitPolicy.canonical.flow);
const predictedFlow = this._readChildMeasurement(machine, "flow", "predicted", "atequipment", this.unitPolicy.canonical.flow); const predictedFlow = this._readChildMeasurement(machine, "flow", "predicted", POSITIONS.DOWNSTREAM, this.unitPolicy.canonical.flow);
if (Number.isFinite(measuredFlow) && measuredFlow !== 0) { if (Number.isFinite(measuredFlow) && measuredFlow !== 0) {
flow = measuredFlow; flow = measuredFlow;
} }
else if (Number.isFinite(predictedFlow) && predictedFlow !== 0) { else if (Number.isFinite(predictedFlow) && predictedFlow !== 0) {
flow = predictedFlow; flow = predictedFlow;
} }
@@ -304,7 +304,7 @@ class MachineGroup {
//abort the calculation //abort the calculation
return false; return false;
} }
//Qd is less because we allready have machines delivering flow on manual control //Qd is less because we allready have machines delivering flow on manual control
Qd = Qd - flow; Qd = Qd - flow;
} }
@@ -317,28 +317,28 @@ class MachineGroup {
// adjust demand flow when there are machines being controlled by a manual source // adjust demand flow when there are machines being controlled by a manual source
Qd = this.checkSpecialCases(machines, Qd); Qd = this.checkSpecialCases(machines, Qd);
// Generate all possible subsets of machines (power set) // Generate all possible subsets of machines (power set)
Object.keys(machines).forEach(machineId => { Object.keys(machines).forEach(machineId => {
const state = machines[machineId].state.getCurrentState(); const state = machines[machineId].state.getCurrentState();
const validActionForMode = machines[machineId].isValidActionForMode("execsequence", "auto"); const validActionForMode = machines[machineId].isValidActionForMode("execsequence", "auto");
// Reasons why a machine is not valid for the combination // Reasons why a machine is not valid for the combination
if( state === "off" || state === "coolingdown" || state === "stopping" || state === "emergencystop" || !validActionForMode){ if( state === "off" || state === "coolingdown" || state === "stopping" || state === "emergencystop" || !validActionForMode){
return; return;
} }
// go through each machine and add it to the subsets // go through each machine and add it to the subsets
let newSubsets = subsets.map(set => [...set, machineId]); let newSubsets = subsets.map(set => [...set, machineId]);
subsets = subsets.concat(newSubsets); subsets = subsets.concat(newSubsets);
}); });
// Filter for non-empty subsets that can meet or exceed demand flow // Filter for non-empty subsets that can meet or exceed demand flow
const combinations = subsets.filter(subset => { const combinations = subsets.filter(subset => {
if (subset.length === 0) return false; if (subset.length === 0) return false;
// Calculate total and minimum flow for the subset in one pass // Calculate total and minimum flow for the subset in one pass
const { maxFlow, minFlow, maxPower } = subset.reduce( const { maxFlow, minFlow, maxPower } = subset.reduce(
(acc, machineId) => { (acc, machineId) => {
@@ -353,7 +353,7 @@ class MachineGroup {
maxPower: acc.maxPower + maxPower maxPower: acc.maxPower + maxPower
}; };
}, },
{ maxFlow: 0, minFlow: 0 , maxPower: 0 } { maxFlow: 0, minFlow: 0 , maxPower: 0 }
); );
@@ -365,7 +365,7 @@ class MachineGroup {
return false; return false;
} }
}); });
return combinations; return combinations;
} }
@@ -449,7 +449,7 @@ class MachineGroup {
return { bestCombination, bestPower, bestFlow, bestCog }; return { bestCombination, bestPower, bestFlow, bestCog };
} }
// Estimate the local dP/dQ slopes around the BEP for the provided machine. // Estimate the local dP/dQ slopes around the BEP for the provided machine.
estimateSlopesAtBEP(machine, Q_BEP, delta = 1.0) { estimateSlopesAtBEP(machine, Q_BEP, delta = 1.0) {
const fallback = { const fallback = {
@@ -572,7 +572,7 @@ class MachineGroup {
const flowDistribution = pumpInfos.map(info => ({ const flowDistribution = pumpInfos.map(info => ({
machineId: info.id, machineId: info.id,
flow: Math.min(info.maxFlow, Math.max(info.minFlow, info.Q_BEP)) flow: Math.min(info.maxFlow, Math.max(info.minFlow, info.Q_BEP))
})); }));
let totalFlow = flowDistribution.reduce((sum, entry) => sum + entry.flow, 0); // Initial total flow let totalFlow = flowDistribution.reduce((sum, entry) => sum + entry.flow, 0); // Initial total flow
const delta = Qd - totalFlow; // Difference to target demand const delta = Qd - totalFlow; // Difference to target demand
@@ -647,10 +647,10 @@ class MachineGroup {
try{ try{
//we need to force the pressures of all machines to be equal to the highest pressure measured in the group //we need to force the pressures of all machines to be equal to the highest pressure measured in the group
// this is to ensure a correct evaluation of the flow and power consumption // this is to ensure a correct evaluation of the flow and power consumption
const pressures = Object.entries(this.machines).map(([machineId, machine]) => { const pressures = Object.entries(this.machines).map(([_machineId, machine]) => {
return { return {
downstream: this._readChildMeasurement(machine, "pressure", "measured", "downstream", this.unitPolicy.canonical.pressure), downstream: this._readChildMeasurement(machine, "pressure", "measured", POSITIONS.DOWNSTREAM, this.unitPolicy.canonical.pressure),
upstream: this._readChildMeasurement(machine, "pressure", "measured", "upstream", this.unitPolicy.canonical.pressure) upstream: this._readChildMeasurement(machine, "pressure", "measured", POSITIONS.UPSTREAM, this.unitPolicy.canonical.pressure)
}; };
}); });
@@ -660,19 +660,19 @@ class MachineGroup {
this.logger.debug(`Max downstream pressure: ${maxDownstream}, Min upstream pressure: ${minUpstream}`); this.logger.debug(`Max downstream pressure: ${maxDownstream}, Min upstream pressure: ${minUpstream}`);
//set the pressures //set the pressures
Object.entries(this.machines).forEach(([machineId, machine]) => { Object.entries(this.machines).forEach(([_machineId, machine]) => {
if(machine.state.getCurrentState() !== "operational" && machine.state.getCurrentState() !== "accelerating" && machine.state.getCurrentState() !== "decelerating"){ if(machine.state.getCurrentState() !== "operational" && machine.state.getCurrentState() !== "accelerating" && machine.state.getCurrentState() !== "decelerating"){
//Equilize pressures over all machines so we can make a proper calculation //Equilize pressures over all machines so we can make a proper calculation
this._writeChildMeasurement(machine, "pressure", "measured", "downstream", maxDownstream, this.unitPolicy.canonical.pressure); this._writeChildMeasurement(machine, "pressure", "measured", POSITIONS.DOWNSTREAM, maxDownstream, this.unitPolicy.canonical.pressure);
this._writeChildMeasurement(machine, "pressure", "measured", "upstream", minUpstream, this.unitPolicy.canonical.pressure); this._writeChildMeasurement(machine, "pressure", "measured", POSITIONS.UPSTREAM, minUpstream, this.unitPolicy.canonical.pressure);
// after updating the measurement directly we need to force the update of the value OLIFANT this is not so clear now in the code // after updating the measurement directly we need to force the update of the value OLIFANT this is not so clear now in the code
// we need to find a better way to do this but for now it works // we need to find a better way to do this but for now it works
machine.getMeasuredPressure(); machine.getMeasuredPressure();
} }
}); });
//fetch dynamic totals //fetch dynamic totals
const dynamicTotals = this.dynamicTotals; const dynamicTotals = this.dynamicTotals;
@@ -697,7 +697,7 @@ class MachineGroup {
} }
// fetch all valid combinations that meet expectations // fetch all valid combinations that meet expectations
const combinations = this.validPumpCombinations(this.machines, Qd, powerCap); const combinations = this.validPumpCombinations(this.machines, Qd, powerCap);
if (!combinations || combinations.length === 0) { if (!combinations || combinations.length === 0) {
this.logger.warn(`Demand: ${Qd.toFixed(2)} -> No valid combination found (empty set).`); this.logger.warn(`Demand: ${Qd.toFixed(2)} -> No valid combination found (empty set).`);
@@ -726,12 +726,12 @@ class MachineGroup {
const debugInfo = bestResult.bestCombination.map(({ machineId, flow }) => `${machineId}: ${flow.toFixed(2)} units`).join(" | "); const debugInfo = bestResult.bestCombination.map(({ machineId, flow }) => `${machineId}: ${flow.toFixed(2)} units`).join(" | ");
this.logger.debug(`Moving to demand: ${Qd.toFixed(2)} -> Pumps: [${debugInfo}] => Total Power: ${bestResult.bestPower.toFixed(2)}`); this.logger.debug(`Moving to demand: ${Qd.toFixed(2)} -> Pumps: [${debugInfo}] => Total Power: ${bestResult.bestPower.toFixed(2)}`);
//store the total delivered power //store the total delivered power
this._writeMeasurement("power", "predicted", "atequipment", bestResult.bestPower, this.unitPolicy.canonical.power); this._writeMeasurement("power", "predicted", POSITIONS.AT_EQUIPMENT, bestResult.bestPower, this.unitPolicy.canonical.power);
this._writeMeasurement("flow", "predicted", "atequipment", bestResult.bestFlow, this.unitPolicy.canonical.flow); this._writeMeasurement("flow", "predicted", POSITIONS.DOWNSTREAM, bestResult.bestFlow, this.unitPolicy.canonical.flow);
this.measurements.type("efficiency").variant("predicted").position("atequipment").value(bestResult.bestFlow / bestResult.bestPower); this.measurements.type("efficiency").variant("predicted").position(POSITIONS.AT_EQUIPMENT).value(bestResult.bestFlow / bestResult.bestPower);
this.measurements.type("Ncog").variant("predicted").position("atequipment").value(bestResult.bestCog); this.measurements.type("Ncog").variant("predicted").position(POSITIONS.AT_EQUIPMENT).value(bestResult.bestCog);
await Promise.all(Object.entries(this.machines).map(async ([machineId, machine]) => { await Promise.all(Object.entries(this.machines).map(async ([machineId, machine]) => {
// Find the flow for this machine in the best combination // Find the flow for this machine in the best combination
@@ -767,22 +767,22 @@ class MachineGroup {
// Equalize pressure across all machines for machines that are not running. This is needed to ensure accurate flow and power predictions. // Equalize pressure across all machines for machines that are not running. This is needed to ensure accurate flow and power predictions.
equalizePressure(){ equalizePressure(){
// Get current pressures from all machines // Get current pressures from all machines
const pressures = Object.entries(this.machines).map(([machineId, machine]) => { const pressures = Object.entries(this.machines).map(([_machineId, machine]) => {
return { return {
downstream: this._readChildMeasurement(machine, "pressure", "measured", "downstream", this.unitPolicy.canonical.pressure), downstream: this._readChildMeasurement(machine, "pressure", "measured", POSITIONS.DOWNSTREAM, this.unitPolicy.canonical.pressure),
upstream: this._readChildMeasurement(machine, "pressure", "measured", "upstream", this.unitPolicy.canonical.pressure) upstream: this._readChildMeasurement(machine, "pressure", "measured", POSITIONS.UPSTREAM, this.unitPolicy.canonical.pressure)
}; };
}); });
// Find the highest downstream and lowest upstream pressure // Find the highest downstream and lowest upstream pressure
const maxDownstream = Math.max(...pressures.map(p => p.downstream)); const maxDownstream = Math.max(...pressures.map(p => p.downstream));
const minUpstream = Math.min(...pressures.map(p => p.upstream)); const minUpstream = Math.min(...pressures.map(p => p.upstream));
// Set consistent pressures across machines // Set consistent pressures across machines
Object.entries(this.machines).forEach(([machineId, machine]) => { Object.entries(this.machines).forEach(([machineId, machine]) => {
if(!this.isMachineActive(machineId)){ if(!this.isMachineActive(machineId)){
this._writeChildMeasurement(machine, "pressure", "measured", "downstream", maxDownstream, this.unitPolicy.canonical.pressure); this._writeChildMeasurement(machine, "pressure", "measured", POSITIONS.DOWNSTREAM, maxDownstream, this.unitPolicy.canonical.pressure);
this._writeChildMeasurement(machine, "pressure", "measured", "upstream", minUpstream, this.unitPolicy.canonical.pressure); this._writeChildMeasurement(machine, "pressure", "measured", POSITIONS.UPSTREAM, minUpstream, this.unitPolicy.canonical.pressure);
// Update the measured pressure value // Update the measured pressure value
const pressure = machine.getMeasuredPressure(); const pressure = machine.getMeasuredPressure();
this.logger.debug(`Setting pressure for machine ${machineId} to ${pressure}`); this.logger.debug(`Setting pressure for machine ${machineId} to ${pressure}`);
@@ -826,11 +826,11 @@ class MachineGroup {
} }
filterOutUnavailableMachines(list) { filterOutUnavailableMachines(list) {
const newList = list.filter(({ id, machine }) => { const newList = list.filter(({ machine }) => {
const state = machine.state.getCurrentState(); const state = machine.state.getCurrentState();
const validActionForMode = machine.isValidActionForMode("execsequence", "auto"); const validActionForMode = machine.isValidActionForMode("execsequence", "auto");
return !(state === "off" || state === "coolingdown" || state === "stopping" || state === "emergencystop" || !validActionForMode); return !(state === "off" || state === "coolingdown" || state === "stopping" || state === "emergencystop" || !validActionForMode);
}); });
return newList; return newList;
} }
@@ -841,7 +841,7 @@ class MachineGroup {
let lowestEfficiency = Infinity; let lowestEfficiency = Infinity;
// Calculate the average efficiency of all machines -> peak is the average of them all // Calculate the average efficiency of all machines -> peak is the average of them all
Object.entries(machines).forEach(([machineId, machine]) => { Object.entries(machines).forEach(([_machineId, machine]) => {
cumEfficiency += machine.cog; cumEfficiency += machine.cog;
if(machine.cog < lowestEfficiency){ if(machine.cog < lowestEfficiency){
lowestEfficiency = machine.cog; lowestEfficiency = machine.cog;
@@ -854,9 +854,9 @@ class MachineGroup {
return { maxEfficiency, lowestEfficiency }; return { maxEfficiency, lowestEfficiency };
} }
//move machines assuming equal control in flow and a priority list //move machines assuming equal control in flow and a priority list
async equalFlowControl(Qd, powerCap = Infinity, priorityList = null) { async equalFlowControl(Qd, _powerCap = Infinity, priorityList = null) {
try { try {
// equalize pressure across all machines // equalize pressure across all machines
@@ -893,14 +893,14 @@ class MachineGroup {
availableFlow -= machine.machine.predictFlow.currentFxyYMin; availableFlow -= machine.machine.predictFlow.currentFxyYMin;
} }
} }
// Determine remaining active machines (not shut down). // Determine remaining active machines (not shut down).
const remainingMachines = machinesInPriorityOrder.filter( const remainingMachines = machinesInPriorityOrder.filter(
({ id }) => ({ id }) =>
this.isMachineActive(id) && this.isMachineActive(id) &&
!flowDistribution.some(item => item.machineId === id) !flowDistribution.some(item => item.machineId === id)
); );
// Evenly distribute Qd among the remaining machines. // Evenly distribute Qd among the remaining machines.
const distributedFlow = Qd / remainingMachines.length; const distributedFlow = Qd / remainingMachines.length;
for (let machine of remainingMachines) { for (let machine of remainingMachines) {
@@ -910,14 +910,14 @@ class MachineGroup {
} }
break; break;
} }
case (Qd > activeTotals.flow.max): case (Qd > activeTotals.flow.max): {
// Case 2: Demand is above the maximum available flow. // Case 2: Demand is above the maximum available flow.
// Start the non-active machine with the highest priority and distribute Qd over all available machines. // Start the non-active machine with the highest priority and distribute Qd over all available machines.
let i = 1; let i = 1;
while (totalFlow < Qd && i <= machinesInPriorityOrder.length) { while (totalFlow < Qd && i <= machinesInPriorityOrder.length) {
Qd = Qd / i; Qd = Qd / i;
if(machinesInPriorityOrder[i-1].machine.predictFlow.currentFxyYMax >= Qd){ if(machinesInPriorityOrder[i-1].machine.predictFlow.currentFxyYMax >= Qd){
for ( let i2 = 0; i2 < i ; i2++){ for ( let i2 = 0; i2 < i ; i2++){
if(! this.isMachineActive(machinesInPriorityOrder[i2].id)){ if(! this.isMachineActive(machinesInPriorityOrder[i2].id)){
@@ -929,45 +929,47 @@ class MachineGroup {
} }
i++; i++;
} }
break;
break;
default: }
default: {
// Default case: Demand is within the active range. // Default case: Demand is within the active range.
const countActiveMachines = machinesInPriorityOrder.filter(({ id }) => this.isMachineActive(id)).length; const countActiveMachines = machinesInPriorityOrder.filter(({ id }) => this.isMachineActive(id)).length;
Qd /= countActiveMachines; Qd /= countActiveMachines;
// Simply distribute the demand equally among all available machines. // Simply distribute the demand equally among all available machines.
for ( let i = 0 ; i < countActiveMachines ; i++){ for ( let i = 0 ; i < countActiveMachines ; i++){
flowDistribution.push({ machineId: machinesInPriorityOrder[i].id, flow: Qd}); flowDistribution.push({ machineId: machinesInPriorityOrder[i].id, flow: Qd});
totalFlow += Qd ; totalFlow += Qd ;
totalPower += machinesInPriorityOrder[i].machine.inputFlowCalcPower(Qd); totalPower += machinesInPriorityOrder[i].machine.inputFlowCalcPower(Qd);
} }
break; break;
}
} }
// Log information about flow distribution // Log information about flow distribution
const debugInfo = flowDistribution const debugInfo = flowDistribution
.filter(({ flow }) => flow > 0) .filter(({ flow }) => flow > 0)
.map(({ machineId, flow }) => `${machineId}: ${flow.toFixed(2)} units`) .map(({ machineId, flow }) => `${machineId}: ${flow.toFixed(2)} units`)
.join(" | "); .join(" | ");
this.logger.debug(`Priority control for demand: ${totalFlow.toFixed(2)} -> Active pumps: [${debugInfo}] => Total Power: ${totalPower.toFixed(2)}`); this.logger.debug(`Priority control for demand: ${totalFlow.toFixed(2)} -> Active pumps: [${debugInfo}] => Total Power: ${totalPower.toFixed(2)}`);
// Store measurements // Store measurements
this._writeMeasurement("power", "predicted", "atequipment", totalPower, this.unitPolicy.canonical.power); this._writeMeasurement("power", "predicted", POSITIONS.AT_EQUIPMENT, totalPower, this.unitPolicy.canonical.power);
this._writeMeasurement("flow", "predicted", "atequipment", totalFlow, this.unitPolicy.canonical.flow); this._writeMeasurement("flow", "predicted", POSITIONS.DOWNSTREAM, totalFlow, this.unitPolicy.canonical.flow);
this.measurements.type("efficiency").variant("predicted").position("atequipment").value(totalFlow / totalPower); this.measurements.type("efficiency").variant("predicted").position(POSITIONS.AT_EQUIPMENT).value(totalFlow / totalPower);
this.measurements.type("Ncog").variant("predicted").position("atequipment").value(totalCog); this.measurements.type("Ncog").variant("predicted").position(POSITIONS.AT_EQUIPMENT).value(totalCog);
this.logger.debug(`Flow distribution: ${JSON.stringify(flowDistribution)}`); this.logger.debug(`Flow distribution: ${JSON.stringify(flowDistribution)}`);
// Apply the flow distribution to machines // Apply the flow distribution to machines
await Promise.all(flowDistribution.map(async ({ machineId, flow }) => { await Promise.all(flowDistribution.map(async ({ machineId, flow }) => {
const machine = this.machines[machineId]; const machine = this.machines[machineId];
this.logger.debug(this.machines[machineId].state); this.logger.debug(this.machines[machineId].state);
const currentState = this.machines[machineId].state.getCurrentState(); const currentState = this.machines[machineId].state.getCurrentState();
if (flow <= 0 && (currentState === "operational" || currentState === "accelerating" || currentState === "decelerating")) { if (flow <= 0 && (currentState === "operational" || currentState === "accelerating" || currentState === "decelerating")) {
@@ -999,7 +1001,7 @@ class MachineGroup {
} }
//capp input to 100 //capp input to 100
input > 100 ? input = 100 : input = input; if (input > 100) { input = 100; }
const numOfMachines = Object.keys(this.machines).length; const numOfMachines = Object.keys(this.machines).length;
const procentTotal = numOfMachines * input; const procentTotal = numOfMachines * input;
@@ -1011,9 +1013,9 @@ class MachineGroup {
const ctrlDistribution = []; //{machineId : 0, flow : 0} push for each machine const ctrlDistribution = []; //{machineId : 0, flow : 0} push for each machine
if(machinesNeeded > machinesActive){ if(machinesNeeded > machinesActive){
//start extra machine and put all active machines at min control //start extra machine and put all active machines at min control
machinesInPriorityOrder.forEach(({ id, machine }, index) => { machinesInPriorityOrder.forEach(({ id }, index) => {
if(index < machinesNeeded){ if(index < machinesNeeded){
ctrlDistribution.push({machineId : id, ctrl : 0}); ctrlDistribution.push({machineId : id, ctrl : 0});
} }
@@ -1021,8 +1023,8 @@ class MachineGroup {
} }
if(machinesNeeded < machinesActive){ if(machinesNeeded < machinesActive){
machinesInPriorityOrder.forEach(({ id, machine }, index) => { machinesInPriorityOrder.forEach(({ id }, index) => {
if(this.isMachineActive(id)){ if(this.isMachineActive(id)){
if(index < machinesNeeded){ if(index < machinesNeeded){
ctrlDistribution.push({machineId : id, ctrl : 100}); ctrlDistribution.push({machineId : id, ctrl : 100});
@@ -1038,11 +1040,11 @@ class MachineGroup {
if (machinesNeeded === machinesActive) { if (machinesNeeded === machinesActive) {
// distribute input equally among active machines (0 - 100%) // distribute input equally among active machines (0 - 100%)
const ctrlPerMachine = procentTotal / machinesActive; const ctrlPerMachine = procentTotal / machinesActive;
machinesInPriorityOrder.forEach(({ id, machine }) => { machinesInPriorityOrder.forEach(({ id }) => {
if (this.isMachineActive(id)) { if (this.isMachineActive(id)) {
// ensure ctrl is capped between 0 and 100% // ensure ctrl is capped between 0 and 100%
const ctrlValue = Math.max(0, Math.min(ctrlPerMachine, 100)); const ctrlValue = Math.max(0, Math.min(ctrlPerMachine, 100));
ctrlDistribution.push({ machineId: id, ctrl: ctrlValue }); ctrlDistribution.push({ machineId: id, ctrl: ctrlValue });
} }
}); });
@@ -1071,10 +1073,10 @@ class MachineGroup {
const totalFlow = []; const totalFlow = [];
// fetch and store measurements // fetch and store measurements
Object.entries(this.machines).forEach(([machineId, machine]) => { Object.entries(this.machines).forEach(([_machineId, machine]) => {
const powerValue = this._readChildMeasurement(machine, "power", "predicted", "atequipment", this.unitPolicy.canonical.power); const powerValue = this._readChildMeasurement(machine, "power", "predicted", POSITIONS.AT_EQUIPMENT, this.unitPolicy.canonical.power);
const flowValue = this._readChildMeasurement(machine, "flow", "predicted", "atequipment", this.unitPolicy.canonical.flow); const flowValue = this._readChildMeasurement(machine, "flow", "predicted", POSITIONS.DOWNSTREAM, this.unitPolicy.canonical.flow);
if (powerValue !== null) { if (powerValue !== null) {
totalPower.push(powerValue); totalPower.push(powerValue);
@@ -1084,11 +1086,11 @@ class MachineGroup {
} }
}); });
this._writeMeasurement("power", "predicted", "atequipment", totalPower.reduce((a, b) => a + b, 0), this.unitPolicy.canonical.power); this._writeMeasurement("power", "predicted", POSITIONS.AT_EQUIPMENT, totalPower.reduce((a, b) => a + b, 0), this.unitPolicy.canonical.power);
this._writeMeasurement("flow", "predicted", "atequipment", totalFlow.reduce((a, b) => a + b, 0), this.unitPolicy.canonical.flow); this._writeMeasurement("flow", "predicted", POSITIONS.DOWNSTREAM, totalFlow.reduce((a, b) => a + b, 0), this.unitPolicy.canonical.flow);
if(totalPower.reduce((a, b) => a + b, 0) > 0){ if(totalPower.reduce((a, b) => a + b, 0) > 0){
this.measurements.type("efficiency").variant("predicted").position("atequipment").value(totalFlow.reduce((a, b) => a + b, 0) / totalPower.reduce((a, b) => a + b, 0)); this.measurements.type("efficiency").variant("predicted").position(POSITIONS.AT_EQUIPMENT).value(totalFlow.reduce((a, b) => a + b, 0) / totalPower.reduce((a, b) => a + b, 0));
} }
} }
@@ -1096,9 +1098,9 @@ class MachineGroup {
this.logger.error(err); this.logger.error(err);
} }
} }
async handleInput(source, demand, powerCap = Infinity, priorityList = null) { async handleInput(source, demand, powerCap = Infinity, priorityList = null) {
const demandQ = parseFloat(demand); const demandQ = parseFloat(demand);
if(!Number.isFinite(demandQ)){ if(!Number.isFinite(demandQ)){
@@ -1123,13 +1125,13 @@ class MachineGroup {
demandQout = 0; demandQout = 0;
return; return;
} }
if (demandQ < absoluteTotals.flow.min) { if (demandQ < this.absoluteTotals.flow.min) {
this.logger.warn(`Flow demand ${demandQ} is below minimum possible flow ${absoluteTotals.flow.min}. Capping to minimum flow.`); this.logger.warn(`Flow demand ${demandQ} is below minimum possible flow ${this.absoluteTotals.flow.min}. Capping to minimum flow.`);
demandQout = this.absoluteTotals.flow.min; demandQout = this.absoluteTotals.flow.min;
} else if (demandQout > absoluteTotals.flow.max) { } else if (demandQout > this.absoluteTotals.flow.max) {
this.logger.warn(`Flow demand ${demandQ} is above maximum possible flow ${absoluteTotals.flow.max}. Capping to maximum flow.`); this.logger.warn(`Flow demand ${demandQ} is above maximum possible flow ${this.absoluteTotals.flow.max}. Capping to maximum flow.`);
demandQout = absoluteTotals.flow.max; demandQout = this.absoluteTotals.flow.max;
}else if(demandQout <= 0){ }else if(demandQout <= 0){
this.logger.debug(`Turning machines off`); this.logger.debug(`Turning machines off`);
demandQout = 0; demandQout = 0;
@@ -1170,9 +1172,9 @@ class MachineGroup {
this.logger.warn("Priority percentage control is only valid with normalized scaling."); this.logger.warn("Priority percentage control is only valid with normalized scaling.");
return; return;
} }
await this.prioPercentageControl(demandQout,priorityList); await this.prioPercentageControl(demandQout,priorityList);
break; break;
case "optimalcontrol": case "optimalcontrol":
this.logger.debug(`Calculating optimal control. Input flow demand: ${demandQ} scaling : ${scaling} -> ${demandQout}`); this.logger.debug(`Calculating optimal control. Input flow demand: ${demandQ} scaling : ${scaling} -> ${demandQout}`);
await this.optimalControl(demandQout,powerCap); await this.optimalControl(demandQout,powerCap);
@@ -1185,7 +1187,7 @@ class MachineGroup {
//recalc distance from BEP //recalc distance from BEP
const { maxEfficiency, lowestEfficiency } = this.calcGroupEfficiency(this.machines); const { maxEfficiency, lowestEfficiency } = this.calcGroupEfficiency(this.machines);
const efficiency = this.measurements.type("efficiency").variant("predicted").position("downstream").getCurrentValue(); const efficiency = this.measurements.type("efficiency").variant("predicted").position(POSITIONS.AT_EQUIPMENT).getCurrentValue();
this.calcDistanceBEP(efficiency,maxEfficiency,lowestEfficiency); this.calcDistanceBEP(efficiency,maxEfficiency,lowestEfficiency);
} }
@@ -1306,34 +1308,34 @@ class MachineGroup {
const output = {}; const output = {};
//build the output object //build the output object
Object.entries(this.measurements.measurements || {}).forEach(([type, variants]) => { this.measurements.getTypes().forEach(type => {
Object.keys(variants || {}).forEach((variant) => { this.measurements.getVariants(type).forEach(variant => {
const unit = this._outputUnitForType(type); const unit = this._outputUnitForType(type);
const downstreamVal = this._readMeasurement(type, variant, "downstream", unit); const downstreamVal = this._readMeasurement(type, variant, POSITIONS.DOWNSTREAM, unit);
const atEquipmentVal = this._readMeasurement(type, variant, "atequipment", unit); const atEquipmentVal = this._readMeasurement(type, variant, POSITIONS.AT_EQUIPMENT, unit);
const upstreamVal = this._readMeasurement(type, variant, "upstream", unit); const upstreamVal = this._readMeasurement(type, variant, POSITIONS.UPSTREAM, unit);
if (downstreamVal != null) { if (downstreamVal != null) {
output[`downstream_${variant}_${type}`] = downstreamVal; output[`downstream_${variant}_${type}`] = downstreamVal;
} }
if (upstreamVal != null) { if (upstreamVal != null) {
output[`upstream_${variant}_${type}`] = upstreamVal; output[`upstream_${variant}_${type}`] = upstreamVal;
} }
if (atEquipmentVal != null) { if (atEquipmentVal != null) {
output[`atequipment${variant}_${type}`] = atEquipmentVal; output[`atEquipment_${variant}_${type}`] = atEquipmentVal;
} }
if (downstreamVal != null && upstreamVal != null) { if (downstreamVal != null && upstreamVal != null) {
const diff = this.measurements const diff = this.measurements
.type(type) .type(type)
.variant(variant) .variant(variant)
.difference({ from: 'downstream', to: 'upstream', unit }); .difference({ from: POSITIONS.DOWNSTREAM, to: POSITIONS.UPSTREAM, unit });
if (diff?.value != null) { if (diff?.value != null) {
output[`differential_${variant}_${type}`] = diff.value; output[`differential_${variant}_${type}`] = diff.value;
} }
} }
}); });
}); });
//fill in the rest of the output object //fill in the rest of the output object
output["mode"] = this.mode; output["mode"] = this.mode;
output["scaling"] = this.scaling; output["scaling"] = this.scaling;
@@ -1343,10 +1345,10 @@ class MachineGroup {
output["absDistFromPeak"] = this.absDistFromPeak; output["absDistFromPeak"] = this.absDistFromPeak;
output["relDistFromPeak"] = this.relDistFromPeak; output["relDistFromPeak"] = this.relDistFromPeak;
//this.logger.debug(`Output: ${JSON.stringify(output)}`); //this.logger.debug(`Output: ${JSON.stringify(output)}`);
return output; return output;
} }
} }
module.exports = MachineGroup; module.exports = MachineGroup;
@@ -1359,8 +1361,8 @@ const { max } = require("mathjs");
function createBaseMachineConfig(machineNum, name,specs) { function createBaseMachineConfig(machineNum, name,specs) {
return { return {
general: { general: {
logging: { enabled: true, logLevel: "debug" }, logging: { enabled: true, logLevel: "debug" },
name: name, name: name,
id: machineNum, id: machineNum,
unit: "m3/h" unit: "m3/h"
@@ -1417,8 +1419,8 @@ function createStateConfig(){
function createBaseMachineGroupConfig(name) { function createBaseMachineGroupConfig(name) {
return { return {
general: { general: {
logging: { enabled: true, logLevel: "debug" }, logging: { enabled: true, logLevel: "debug" },
name: name name: name
}, },
functionality: { functionality: {
@@ -1489,28 +1491,28 @@ async function makeMachines(){
const percMax = 100; const percMax = 100;
try{ try{
for(let demand = mg.dynamicTotals.flow.min ; demand <= mg.dynamicTotals.flow.max ; demand += 2){ for(let demand = mg.dynamicTotals.flow.min ; demand <= mg.dynamicTotals.flow.max ; demand += 2){
//set pressure //set pressure
console.log("------------------------------------"); console.log("------------------------------------");
await mg.handleInput("parent",demand); await mg.handleInput("parent",demand);
pt1.calculateInput(1400); pt1.calculateInput(1400);
//await new Promise(resolve => setTimeout(resolve, 200)); //await new Promise(resolve => setTimeout(resolve, 200));
console.log("------------------------------------"); console.log("------------------------------------");
} }
for(let demand = 240 ; demand >= mg.dynamicTotals.flow.min ; demand -= 40){ for(let demand = 240 ; demand >= mg.dynamicTotals.flow.min ; demand -= 40){
//set pressure //set pressure
console.log("------------------------------------"); console.log("------------------------------------");
await mg.handleInput("parent",demand); await mg.handleInput("parent",demand);
pt1.calculateInput(1400); pt1.calculateInput(1400);
//await new Promise(resolve => setTimeout(resolve, 200)); //await new Promise(resolve => setTimeout(resolve, 200));
console.log("------------------------------------"); console.log("------------------------------------");
} }
//*//* //*//*
@@ -1518,7 +1520,7 @@ async function makeMachines(){
//set pressure //set pressure
console.log(`TESTING: processing demand of ${demand}`); console.log(`TESTING: processing demand of ${demand}`);
await mg.handleInput("parent",demand); await mg.handleInput("parent",demand);
Object.keys(mg.machines).forEach(machineId => { Object.keys(mg.machines).forEach(machineId => {
console.log(mg.machines[machineId].state.getCurrentState()); console.log(mg.machines[machineId].state.getCurrentState());
@@ -1527,7 +1529,7 @@ async function makeMachines(){
console.log(`updating pressure to 1400 mbar`); console.log(`updating pressure to 1400 mbar`);
pt1.calculateInput(1400); pt1.calculateInput(1400);
console.log("------------------------------------"); console.log("------------------------------------");
} }
} }
catch(err){ catch(err){
@@ -1535,7 +1537,7 @@ async function makeMachines(){
} }
} }
@@ -1543,4 +1545,4 @@ if (require.main === module) {
makeMachines(); makeMachines();
} }
//*/ //*/