|
|
|
|
@@ -1,50 +1,5 @@
|
|
|
|
|
/**
|
|
|
|
|
* @file machine.js
|
|
|
|
|
*
|
|
|
|
|
* Permission is hereby granted to any person obtaining a copy of this software
|
|
|
|
|
* and associated documentation files (the "Software"), to use it for personal
|
|
|
|
|
* or non-commercial purposes, with the following restrictions:
|
|
|
|
|
*
|
|
|
|
|
* 1. **No Copying or Redistribution**: The Software or any of its parts may not
|
|
|
|
|
* be copied, merged, distributed, sublicensed, or sold without explicit
|
|
|
|
|
* prior written permission from the author.
|
|
|
|
|
*
|
|
|
|
|
* 2. **Commercial Use**: Any use of the Software for commercial purposes requires
|
|
|
|
|
* a valid license, obtainable only with the explicit consent of the author.
|
|
|
|
|
*
|
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
|
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
|
|
|
|
|
* OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
|
* SOFTWARE.
|
|
|
|
|
*
|
|
|
|
|
* Ownership of this code remains solely with the original author. Unauthorized
|
|
|
|
|
* use of this Software is strictly prohibited.
|
|
|
|
|
*
|
|
|
|
|
* @summary A class to interact and manipulate machines with a non-euclidian curve
|
|
|
|
|
* @description A class to interact and manipulate machines with a non-euclidian curve
|
|
|
|
|
* @module machine
|
|
|
|
|
* @exports machine
|
|
|
|
|
* @version 0.1.0
|
|
|
|
|
* @since 0.1.0
|
|
|
|
|
*
|
|
|
|
|
* Author:
|
|
|
|
|
* - Rene De Ren
|
|
|
|
|
* Email:
|
|
|
|
|
* - r.de.ren@brabantsedelta.nl
|
|
|
|
|
*
|
|
|
|
|
* Add functionality later
|
|
|
|
|
// -------- Operational Metrics -------- //
|
|
|
|
|
maintenanceAlert: this.state.checkMaintenanceStatus()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
//load local dependencies
|
|
|
|
|
const EventEmitter = require('events');
|
|
|
|
|
const {loadCurve,logger,configUtils,configManager,state, nrmse, MeasurementContainer, predict, interpolation , childRegistrationUtils} = require('generalFunctions');
|
|
|
|
|
const {loadCurve,gravity,logger,configUtils,configManager,state, nrmse, MeasurementContainer, predict, interpolation , childRegistrationUtils,coolprop} = require('generalFunctions');
|
|
|
|
|
|
|
|
|
|
class Machine {
|
|
|
|
|
|
|
|
|
|
@@ -61,13 +16,16 @@ class Machine {
|
|
|
|
|
|
|
|
|
|
// Load a specific curve
|
|
|
|
|
this.model = machineConfig.asset.model; // Get the model from the machineConfig
|
|
|
|
|
this.curve = this.model ? loadCurve(this.model) : null;
|
|
|
|
|
this.curve = this.model ? loadCurve(this.model) : null; // we need to convert the curve and add units to the curve information
|
|
|
|
|
|
|
|
|
|
//Init config and check if it is valid
|
|
|
|
|
this.config = this.configUtils.initConfig(machineConfig);
|
|
|
|
|
|
|
|
|
|
//add unique name for this node.
|
|
|
|
|
this.config = this.configUtils.updateConfig(this.config, {general:{name: this.config.functionality?.softwareType + "_" + machineConfig.general.id}}); // add unique name if not present
|
|
|
|
|
|
|
|
|
|
if (!this.model || !this.curve) {
|
|
|
|
|
this.logger.warn(`${!this.model ? 'Model not specified' : 'Curve not found for model ' + this.model} in machineConfig. Cannot make predictions.`);
|
|
|
|
|
this.logger.error(`${!this.model ? 'Model not specified' : 'Curve not found for model ' + this.model} in machineConfig. Cannot make predictions.`);
|
|
|
|
|
// Set prediction objects to null to prevent method calls
|
|
|
|
|
this.predictFlow = null;
|
|
|
|
|
this.predictPower = null;
|
|
|
|
|
@@ -76,10 +34,8 @@ class Machine {
|
|
|
|
|
}
|
|
|
|
|
else{
|
|
|
|
|
this.hasCurve = true;
|
|
|
|
|
this.config = this.configUtils.updateConfig(this.config, {
|
|
|
|
|
asset: { ...this.config.asset, machineCurve: this.curve }
|
|
|
|
|
});
|
|
|
|
|
machineConfig = { ...machineConfig, asset: { ...machineConfig.asset, machineCurve: this.curve } }; // Merge curve into machineConfig
|
|
|
|
|
this.config = this.configUtils.updateConfig(this.config, { asset: { ...this.config.asset, machineCurve: this.curve } });
|
|
|
|
|
//machineConfig = { ...machineConfig, asset: { ...machineConfig.asset, machineCurve: this.curve } }; // Merge curve into machineConfig
|
|
|
|
|
this.predictFlow = new predict({ curve: this.config.asset.machineCurve.nq }); // load nq (x : ctrl , y : flow relationship)
|
|
|
|
|
this.predictPower = new predict({ curve: this.config.asset.machineCurve.np }); // load np (x : ctrl , y : power relationship)
|
|
|
|
|
this.predictCtrl = new predict({ curve: this.reverseCurve(this.config.asset.machineCurve.nq) }); // load reversed nq (x: flow, y: ctrl relationship)
|
|
|
|
|
@@ -89,9 +45,18 @@ class Machine {
|
|
|
|
|
this.errorMetrics = new nrmse(errorMetricsConfig, this.logger);
|
|
|
|
|
|
|
|
|
|
// Initialize measurements
|
|
|
|
|
this.measurements = new MeasurementContainer();
|
|
|
|
|
this.interpolation = new interpolation();
|
|
|
|
|
this.measurements = new MeasurementContainer({
|
|
|
|
|
autoConvert: true,
|
|
|
|
|
windowSize: 50,
|
|
|
|
|
defaultUnits: {
|
|
|
|
|
pressure: 'mbar',
|
|
|
|
|
flow: this.config.general.unit,
|
|
|
|
|
power: 'kW',
|
|
|
|
|
temperature: 'C'
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
this.interpolation = new interpolation();
|
|
|
|
|
|
|
|
|
|
this.flowDrift = null;
|
|
|
|
|
|
|
|
|
|
@@ -110,120 +75,74 @@ class Machine {
|
|
|
|
|
this.updatePosition();
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
//When state changes look if we need to do other updates
|
|
|
|
|
this.state.emitter.on("stateChange", (newState) => {
|
|
|
|
|
this.logger.debug(`State change detected: ${newState}`);
|
|
|
|
|
this._updateState();
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//perform init for certain values
|
|
|
|
|
this._init();
|
|
|
|
|
|
|
|
|
|
this.child = {}; // object to hold child information so we know on what to subscribe
|
|
|
|
|
this.childRegistrationUtils = new childRegistrationUtils(this); // Child registration utility
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_init(){
|
|
|
|
|
//assume standard temperature is 20degrees
|
|
|
|
|
this.measurements.type('temperature').variant('measured').position('atEquipment').value(15).unit('C');
|
|
|
|
|
//assume standard atm pressure is at sea level
|
|
|
|
|
this.measurements.type('atmPressure').variant('measured').position('atEquipment').value(101325).unit('Pa');
|
|
|
|
|
//populate min and max
|
|
|
|
|
const flowunit = this.config.general.unit;
|
|
|
|
|
this.measurements.type('flow').variant('predicted').position('max').value(this.predictFlow.currentFxyYMax, Date.now() , flowunit)
|
|
|
|
|
this.measurements.type('flow').variant('predicted').position('min').value(this.predictFlow.currentFxyYMin).unit(this.config.general.unit);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_updateState(){
|
|
|
|
|
const isOperational = this._isOperationalState();
|
|
|
|
|
if(!isOperational){
|
|
|
|
|
//overrule the last prediction this should be 0 now
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("downstream").value(0,Date.now(),this.config.general.unit);
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("atEquipment").value(0,Date.now(),this.config.general.unit);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*------------------- Register child events -------------------*/
|
|
|
|
|
registerOnChildEvents() {
|
|
|
|
|
this.logger.debug('Setting up child event listeners');
|
|
|
|
|
registerChild(child, softwareType) {
|
|
|
|
|
this.logger.debug('Setting up child event for softwaretype ' + softwareType);
|
|
|
|
|
|
|
|
|
|
const sensors = this.childRegistrationUtils.getChildrenOfType('measurement', 'sensor');
|
|
|
|
|
if(softwareType === "measurement"){
|
|
|
|
|
const position = child.config.functionality.positionVsParent;
|
|
|
|
|
const distance = child.config.functionality.distanceVsParent || 0;
|
|
|
|
|
const measurementType = child.config.asset.type;
|
|
|
|
|
const key = `${measurementType}_${position}`;
|
|
|
|
|
//rebuild to measurementype.variant no position and then switch based on values not strings or names.
|
|
|
|
|
const eventName = `${measurementType}.measured.${position}`;
|
|
|
|
|
|
|
|
|
|
if (sensors.length === 0) {
|
|
|
|
|
this.logger.warn('No measurement sensors found to register events for');
|
|
|
|
|
return;
|
|
|
|
|
this.logger.debug(`Setting up listener for ${eventName} from child ${child.config.general.name}`);
|
|
|
|
|
// Register event listener for measurement updates
|
|
|
|
|
child.measurements.emitter.on(eventName, (eventData) => {
|
|
|
|
|
this.logger.debug(`🔄 ${position} ${measurementType} from ${eventData.childName}: ${eventData.value} ${eventData.unit}`);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
this.logger.debug(` Emitting... ${eventName} with data:`);
|
|
|
|
|
// Store directly in parent's measurement container
|
|
|
|
|
this.measurements
|
|
|
|
|
.type(measurementType)
|
|
|
|
|
.variant("measured")
|
|
|
|
|
.position(position)
|
|
|
|
|
.value(eventData.value, eventData.timestamp, eventData.unit);
|
|
|
|
|
|
|
|
|
|
// Call the appropriate handler
|
|
|
|
|
this._callMeasurementHandler(measurementType, eventData.value, position, eventData);
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
this.logger.debug(`Found ${sensors.length} sensors to register events for`);
|
|
|
|
|
|
|
|
|
|
// Group sensors by type and position to detect duplicates
|
|
|
|
|
const sensorGroups = new Map(); // Key: "type_position", Value: array of sensors
|
|
|
|
|
|
|
|
|
|
sensors.forEach(sensor => {
|
|
|
|
|
const position = sensor.config.functionality.positionVsParent;
|
|
|
|
|
const measurementType = sensor.config.asset.type;
|
|
|
|
|
const key = `${measurementType}_${position}`;
|
|
|
|
|
|
|
|
|
|
if (!sensorGroups.has(key)) {
|
|
|
|
|
sensorGroups.set(key, []);
|
|
|
|
|
}
|
|
|
|
|
sensorGroups.get(key).push(sensor);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
// Set up event handlers based on whether we have single or multiple sensors
|
|
|
|
|
sensorGroups.forEach((sensorsArray, key) => {
|
|
|
|
|
const [measurementType, position] = key.split('_');
|
|
|
|
|
|
|
|
|
|
if (sensorsArray.length === 1) {
|
|
|
|
|
// ✅ Single sensor - direct handler
|
|
|
|
|
const sensor = sensorsArray[0];
|
|
|
|
|
this._registerSingleSensorEvents(sensor, measurementType, position);
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
// ✅ Multiple sensors - averaging handler with warning
|
|
|
|
|
const sensorNames = sensorsArray.map(s => s.config.general.name).join(', ');
|
|
|
|
|
this.logger.warn(`⚠️ Multiple ${measurementType} sensors at ${position} position: ${sensorNames}. Using automatic averaging.`);
|
|
|
|
|
|
|
|
|
|
this._registerMultipleSensorEvents(sensorsArray, measurementType, position);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
this.logger.info(`✅ Event listeners registered for ${sensors.length} measurement sensors`);
|
|
|
|
|
this.childRegistrationUtils.logChildStructure();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Handle single sensor (no averaging needed)
|
|
|
|
|
_registerSingleSensorEvents(sensor, measurementType, position) {
|
|
|
|
|
const sensorName = sensor.config.general.name;
|
|
|
|
|
const eventName = `${measurementType}.measured.${position}`;
|
|
|
|
|
|
|
|
|
|
this.logger.debug(`Registering single ${measurementType} sensor: ${sensorName} at ${position}`);
|
|
|
|
|
|
|
|
|
|
sensor.measurements.emitter.on(eventName, (eventData) => {
|
|
|
|
|
this.logger.debug(`🔄 ${position} ${measurementType} from ${eventData.childName}: ${eventData.value} ${eventData.unit}`);
|
|
|
|
|
|
|
|
|
|
// Store directly in parent's measurement container
|
|
|
|
|
this.measurements
|
|
|
|
|
.type(measurementType)
|
|
|
|
|
.variant("measured")
|
|
|
|
|
.position(position)
|
|
|
|
|
.value(eventData.value, eventData.timestamp, eventData.unit);
|
|
|
|
|
|
|
|
|
|
// Call the appropriate handler
|
|
|
|
|
this._callMeasurementHandler(measurementType, eventData.value, position, eventData);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
this.logger.debug(`✅ Registered single sensor event: ${eventName}`);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Handle multiple sensors (with automatic averaging)
|
|
|
|
|
_registerMultipleSensorEvents(sensorsArray, measurementType, position) {
|
|
|
|
|
const eventName = `${measurementType}.measured.${position}`;
|
|
|
|
|
const sensorCount = sensorsArray.length;
|
|
|
|
|
|
|
|
|
|
this.logger.debug(`Registering ${sensorCount} ${measurementType} sensors at ${position} with averaging`);
|
|
|
|
|
|
|
|
|
|
// Register event handler for each sensor in the group
|
|
|
|
|
sensorsArray.forEach(sensor => {
|
|
|
|
|
sensor.measurements.emitter.on(eventName, (eventData) => {
|
|
|
|
|
this.logger.debug(`🔄 ${position} ${measurementType} from ${eventData.childName}: ${eventData.value} ${eventData.unit} (will be averaged)`);
|
|
|
|
|
|
|
|
|
|
// Store individual sensor value in parent's measurement container
|
|
|
|
|
this.measurements
|
|
|
|
|
.type(measurementType)
|
|
|
|
|
.variant("measured")
|
|
|
|
|
.position(position)
|
|
|
|
|
.value(eventData.value, eventData.timestamp, eventData.unit);
|
|
|
|
|
|
|
|
|
|
// Get the average from measurement container
|
|
|
|
|
const averageValue = this.measurements
|
|
|
|
|
.type(measurementType)
|
|
|
|
|
.variant("measured")
|
|
|
|
|
.position(position)
|
|
|
|
|
.getAverage();
|
|
|
|
|
|
|
|
|
|
this.logger.debug(`📊 Average ${position} ${measurementType} from ${sensorCount} sensors: ${averageValue}`);
|
|
|
|
|
|
|
|
|
|
// Call the handler with the averaged value
|
|
|
|
|
this._callMeasurementHandler(measurementType, averageValue, position, eventData);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
this.logger.debug(`✅ Registered ${sensorCount} sensor events with averaging: ${eventName}`);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Centralized handler dispatcher
|
|
|
|
|
_callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
switch (measurementType) {
|
|
|
|
|
@@ -284,46 +203,68 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
// -------- Mode and Input Management -------- //
|
|
|
|
|
isValidSourceForMode(source, mode) {
|
|
|
|
|
const allowedSourcesSet = this.config.mode.allowedSources[mode] || [];
|
|
|
|
|
return allowedSourcesSet.has(source);
|
|
|
|
|
const allowed = allowedSourcesSet.has(source);
|
|
|
|
|
allowed?
|
|
|
|
|
this.logger.debug(`source is allowed proceeding with ${source} for mode ${mode}`) :
|
|
|
|
|
this.logger.warn(`${source} is not allowed in mode ${mode}`);
|
|
|
|
|
|
|
|
|
|
return allowed;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
isValidActionForMode(action, mode) {
|
|
|
|
|
const allowedActionsSet = this.config.mode.allowedActions[mode] || [];
|
|
|
|
|
return allowedActionsSet.has(action);
|
|
|
|
|
const allowed = allowedActionsSet.has(action);
|
|
|
|
|
allowed ?
|
|
|
|
|
this.logger.debug(`Action is allowed proceeding with ${action} for mode ${mode}`) :
|
|
|
|
|
this.logger.warn(`${action} is not allowed in mode ${mode}`);
|
|
|
|
|
|
|
|
|
|
return allowed;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async handleInput(source, action, parameter) {
|
|
|
|
|
if (!this.isValidSourceForMode(source, this.currentMode)) {
|
|
|
|
|
let warningTxt = `Source '${source}' is not valid for mode '${this.currentMode}'.`;
|
|
|
|
|
this.logger.warn(warningTxt);
|
|
|
|
|
return {status : false , feedback: warningTxt};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//sanitize input
|
|
|
|
|
if( typeof action !== 'string'){this.logger.error(`Action must be string`); return;}
|
|
|
|
|
//convert to lower case to avoid to many mistakes in commands
|
|
|
|
|
action = action.toLowerCase();
|
|
|
|
|
|
|
|
|
|
// check for validity of the request
|
|
|
|
|
if(!this.isValidActionForMode(action,this.currentMode)){return ;}
|
|
|
|
|
if (!this.isValidSourceForMode(source, this.currentMode)) {return ;}
|
|
|
|
|
|
|
|
|
|
this.logger.info(`Handling input from source '${source}' with action '${action}' in mode '${this.currentMode}'.`);
|
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
switch (action) {
|
|
|
|
|
case "execSequence":
|
|
|
|
|
await this.executeSequence(parameter);
|
|
|
|
|
//recalc flow and power
|
|
|
|
|
this.updatePosition();
|
|
|
|
|
break;
|
|
|
|
|
case "execMovement":
|
|
|
|
|
await this.setpoint(parameter);
|
|
|
|
|
break;
|
|
|
|
|
case "flowMovement":
|
|
|
|
|
|
|
|
|
|
case "execsequence":
|
|
|
|
|
return await this.executeSequence(parameter);
|
|
|
|
|
|
|
|
|
|
case "execmovement":
|
|
|
|
|
return await this.setpoint(parameter);
|
|
|
|
|
|
|
|
|
|
case "entermaintenance":
|
|
|
|
|
|
|
|
|
|
return await this.executeSequence(parameter);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
case "exitmaintenance":
|
|
|
|
|
return await this.executeSequence(parameter);
|
|
|
|
|
|
|
|
|
|
case "flowmovement":
|
|
|
|
|
// Calculate the control value for a desired flow
|
|
|
|
|
const pos = this.calcCtrl(parameter);
|
|
|
|
|
// Move to the desired setpoint
|
|
|
|
|
await this.setpoint(pos);
|
|
|
|
|
break;
|
|
|
|
|
case "emergencyStop":
|
|
|
|
|
return await this.setpoint(pos);
|
|
|
|
|
|
|
|
|
|
case "emergencystop":
|
|
|
|
|
this.logger.warn(`Emergency stop activated by '${source}'.`);
|
|
|
|
|
await this.executeSequence("emergencyStop");
|
|
|
|
|
break;
|
|
|
|
|
case "statusCheck":
|
|
|
|
|
return await this.executeSequence("emergencyStop");
|
|
|
|
|
|
|
|
|
|
case "statuscheck":
|
|
|
|
|
this.logger.info(`Status Check: Mode = '${this.currentMode}', Source = '${source}'.`);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
this.logger.warn(`Action '${action}' is not implemented.`);
|
|
|
|
|
break;
|
|
|
|
|
@@ -333,6 +274,13 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
} catch (error) {
|
|
|
|
|
this.logger.error(`Error handling input: ${error}`);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
abortMovement(reason = "group override") {
|
|
|
|
|
if (this.state?.abortCurrentMovement) {
|
|
|
|
|
this.state.abortCurrentMovement(reason);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
setMode(newMode) {
|
|
|
|
|
@@ -373,6 +321,9 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
break; // Exit sequence execution on error
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//recalc flow and power
|
|
|
|
|
this.updatePosition();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async setpoint(setpoint) {
|
|
|
|
|
@@ -397,21 +348,23 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
calcFlow(x) {
|
|
|
|
|
if(this.hasCurve) {
|
|
|
|
|
if (!this._isOperationalState()) {
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("downstream").value(0);
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("downstream").value(0,Date.now(),this.config.general.unit);
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("atEquipment").value(0,Date.now(),this.config.general.unit);
|
|
|
|
|
this.logger.debug(`Machine is not operational. Setting predicted flow to 0.`);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//this.predictFlow.currentX = x; Decrepated
|
|
|
|
|
const cFlow = this.predictFlow.y(x);
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("downstream").value(cFlow);
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("downstream").value(cFlow,Date.now(),this.config.general.unit);
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("atEquipment").value(cFlow,Date.now(),this.config.general.unit);
|
|
|
|
|
//this.logger.debug(`Calculated flow: ${cFlow} for pressure: ${this.getMeasuredPressure()} and position: ${x}`);
|
|
|
|
|
return cFlow;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If no curve data is available, log a warning and return 0
|
|
|
|
|
this.logger.warn(`No curve data available for flow calculation. Returning 0.`);
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("downstream").value(0);
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("downstream").value(0, Date.now(),this.config.general.unit);
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("atEquipment").value(0, Date.now(),this.config.general.unit);
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
@@ -420,20 +373,20 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
calcPower(x) {
|
|
|
|
|
if(this.hasCurve) {
|
|
|
|
|
if (!this._isOperationalState()) {
|
|
|
|
|
this.measurements.type("power").variant("predicted").position('upstream').value(0);
|
|
|
|
|
this.measurements.type("power").variant("predicted").position('atEquipment').value(0);
|
|
|
|
|
this.logger.debug(`Machine is not operational. Setting predicted power to 0.`);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//this.predictPower.currentX = x; Decrepated
|
|
|
|
|
const cPower = this.predictPower.y(x);
|
|
|
|
|
this.measurements.type("power").variant("predicted").position('upstream').value(cPower);
|
|
|
|
|
this.measurements.type("power").variant("predicted").position('atEquipment').value(cPower);
|
|
|
|
|
//this.logger.debug(`Calculated power: ${cPower} for pressure: ${this.getMeasuredPressure()} and position: ${x}`);
|
|
|
|
|
return cPower;
|
|
|
|
|
}
|
|
|
|
|
// If no curve data is available, log a warning and return 0
|
|
|
|
|
this.logger.warn(`No curve data available for power calculation. Returning 0.`);
|
|
|
|
|
this.measurements.type("power").variant("predicted").position('upstream').value(0);
|
|
|
|
|
this.measurements.type("power").variant("predicted").position('atEquipment').value(0);
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
@@ -451,7 +404,7 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
|
|
|
|
|
// If no curve data is available, log a warning and return 0
|
|
|
|
|
this.logger.warn(`No curve data available for power calculation. Returning 0.`);
|
|
|
|
|
this.measurements.type("power").variant("predicted").position('upstream').value(0);
|
|
|
|
|
this.measurements.type("power").variant("predicted").position('atEquipment').value(0);
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
@@ -461,14 +414,14 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
if(this.hasCurve) {
|
|
|
|
|
this.predictCtrl.currentX = x;
|
|
|
|
|
const cCtrl = this.predictCtrl.y(x);
|
|
|
|
|
this.measurements.type("ctrl").variant("predicted").position('upstream').value(cCtrl);
|
|
|
|
|
this.measurements.type("ctrl").variant("predicted").position('atEquipment').value(cCtrl);
|
|
|
|
|
//this.logger.debug(`Calculated ctrl: ${cCtrl} for pressure: ${this.getMeasuredPressure()} and position: ${x}`);
|
|
|
|
|
return cCtrl;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If no curve data is available, log a warning and return 0
|
|
|
|
|
this.logger.warn(`No curve data available for control calculation. Returning 0.`);
|
|
|
|
|
this.measurements.type("ctrl").variant("predicted").position('upstream').value(0);
|
|
|
|
|
this.measurements.type("ctrl").variant("predicted").position('atEquipment').value(0);
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
@@ -476,10 +429,15 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
// returns the best available pressure measurement to use in the prediction calculation
|
|
|
|
|
// this will be either the differential pressure, downstream or upstream pressure
|
|
|
|
|
getMeasuredPressure() {
|
|
|
|
|
if(this.hasCurve === false){
|
|
|
|
|
this.logger.error(`No valid curve available to calculate prediction using last known pressure`);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const pressureDiff = this.measurements.type('pressure').variant('measured').difference();
|
|
|
|
|
|
|
|
|
|
// Both upstream & downstream => differential
|
|
|
|
|
if (pressureDiff != null) {
|
|
|
|
|
if (pressureDiff) {
|
|
|
|
|
this.logger.debug(`Pressure differential: ${pressureDiff.value}`);
|
|
|
|
|
this.predictFlow.fDimension = pressureDiff.value;
|
|
|
|
|
this.predictPower.fDimension = pressureDiff.value;
|
|
|
|
|
@@ -499,7 +457,7 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
|
|
|
|
|
// Only downstream => use it, warn that it's partial
|
|
|
|
|
if (downstreamPressure != null) {
|
|
|
|
|
this.logger.warn(`Using downstream pressure only for prediction: ${downstreamPressure} `);
|
|
|
|
|
this.logger.warn(`Using downstream pressure only for prediction: ${downstreamPressure} This is less acurate!!`);
|
|
|
|
|
this.predictFlow.fDimension = downstreamPressure;
|
|
|
|
|
this.predictPower.fDimension = downstreamPressure;
|
|
|
|
|
this.predictCtrl.fDimension = downstreamPressure;
|
|
|
|
|
@@ -524,6 +482,9 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
const efficiency = this.calcEfficiency(this.predictPower.outputY, this.predictFlow.outputY, "predicted");
|
|
|
|
|
//update the distance from peak
|
|
|
|
|
this.calcDistanceBEP(efficiency,cog,minEfficiency);
|
|
|
|
|
//place min and max flow capabilities in containerthis.predictFlow.currentFxyYMax - this.predictFlow.currentFxyYMin
|
|
|
|
|
this.measurements.type('flow').variant('predicted').position('max').value(this.predictFlow.currentFxyYMax).unit(this.config.general.unit);
|
|
|
|
|
this.measurements.type('flow').variant('predicted').position('min').value(this.predictFlow.currentFxyYMin).unit(this.config.general.unit);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@@ -581,18 +542,12 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ENHANCED: Your existing handler but with rich context
|
|
|
|
|
// context handler for pressure updates
|
|
|
|
|
updateMeasuredPressure(value, position, context = {}) {
|
|
|
|
|
// Your existing operational check
|
|
|
|
|
if (!this._isOperationalState()) {
|
|
|
|
|
this.logger.warn(`Machine not operational, skipping pressure update from ${context.childName || 'unknown'}`);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Enhanced logging with child context
|
|
|
|
|
this.logger.debug(`Pressure update: ${value} at ${position} from ${context.childName || 'child'} (${context.childId || 'unknown-id'})`);
|
|
|
|
|
|
|
|
|
|
// Store in parent's measurement container (your existing logic)
|
|
|
|
|
// Store in parent's measurement container
|
|
|
|
|
this.measurements.type("pressure").variant("measured").position(position).value(value, context.timestamp, context.unit);
|
|
|
|
|
|
|
|
|
|
// Determine what kind of value to use as pressure (upstream , downstream or difference)
|
|
|
|
|
@@ -602,7 +557,7 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
this.logger.debug(`Using pressure: ${pressure} for calculations`);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// NEW: Flow handler (following your pattern)
|
|
|
|
|
// NEW: Flow handler
|
|
|
|
|
updateMeasuredFlow(value, position, context = {}) {
|
|
|
|
|
if (!this._isOperationalState()) {
|
|
|
|
|
this.logger.warn(`Machine not operational, skipping flow update from ${context.childName || 'unknown'}`);
|
|
|
|
|
@@ -616,6 +571,7 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
|
|
|
|
|
// Update predicted flow if you have prediction capability
|
|
|
|
|
if (this.predictFlow) {
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("downstream").value(this.predictFlow.outputY || 0);
|
|
|
|
|
this.measurements.type("flow").variant("predicted").position("atEquipment").value(this.predictFlow.outputY || 0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
@@ -623,11 +579,13 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
// Helper method for operational state check
|
|
|
|
|
_isOperationalState() {
|
|
|
|
|
const state = this.state.getCurrentState();
|
|
|
|
|
this.logger.debug(`Checking operational state ${this.state.getCurrentState()} ? ${["operational", "accelerating", "decelerating"].includes(state)}`);
|
|
|
|
|
return ["operational", "accelerating", "decelerating"].includes(state);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//what is the internal functions that need updating when something changes that has influence on this.
|
|
|
|
|
updatePosition() {
|
|
|
|
|
|
|
|
|
|
if (this._isOperationalState()) {
|
|
|
|
|
|
|
|
|
|
const currentPosition = this.state.getCurrentPosition();
|
|
|
|
|
@@ -645,6 +603,7 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
this.calcDistanceBEP(efficiency,cog,minEfficiency);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
calcDistanceFromPeak(currentEfficiency,peakEfficiency){
|
|
|
|
|
@@ -675,7 +634,6 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Calculate the center of gravity for current pressure
|
|
|
|
|
calcCog() {
|
|
|
|
|
|
|
|
|
|
@@ -685,7 +643,7 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
const {efficiencyCurve, peak, peakIndex, minEfficiency } = this.calcEfficiencyCurve(powerCurve, flowCurve);
|
|
|
|
|
|
|
|
|
|
// Calculate the normalized center of gravity
|
|
|
|
|
const NCog = (flowCurve.y[peakIndex] - this.predictFlow.currentFxyYMin) / (this.predictFlow.currentFxyYMax - this.predictFlow.currentFxyYMin);
|
|
|
|
|
const NCog = (flowCurve.y[peakIndex] - this.predictFlow.currentFxyYMin) / (this.predictFlow.currentFxyYMax - this.predictFlow.currentFxyYMin); //
|
|
|
|
|
|
|
|
|
|
//store in object for later retrieval
|
|
|
|
|
this.currentEfficiencyCurve = efficiencyCurve;
|
|
|
|
|
@@ -735,16 +693,39 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
return { cPower, cFlow };
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
calcEfficiency(power, flow, variant) {
|
|
|
|
|
calcEfficiency(power,flow,variant) {
|
|
|
|
|
|
|
|
|
|
const pressureDiff = this.measurements.type('pressure').variant('measured').difference('Pa');
|
|
|
|
|
const g = gravity.getStandardGravity();
|
|
|
|
|
const temp = this.measurements.type('temperature').variant('measured').position('atEquipment').getCurrentValue('K');
|
|
|
|
|
const atmPressure = this.measurements.type('atmPressure').variant('measured').position('atEquipment').getCurrentValue('Pa');
|
|
|
|
|
|
|
|
|
|
console.log(`--------------------calc efficiency : Pressure diff:${pressureDiff},${temp}, ${g} `);
|
|
|
|
|
const rho = coolprop.PropsSI('D', 'T', temp, 'P', atmPressure, 'WasteWater');
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
this.logger.debug(`temp: ${temp} atmPressure : ${atmPressure} rho : ${rho} pressureDiff: ${pressureDiff?.value || 0}`);
|
|
|
|
|
const flowM3s = this.measurements.type('flow').variant('predicted').position('atEquipment').getCurrentValue('m3/s');
|
|
|
|
|
const powerWatt = this.measurements.type('power').variant('predicted').position('atEquipment').getCurrentValue('W');
|
|
|
|
|
this.logger.debug(`Flow : ${flowM3s} power: ${powerWatt}`);
|
|
|
|
|
|
|
|
|
|
if (power != 0 && flow != 0) {
|
|
|
|
|
// Calculate efficiency after measurements update
|
|
|
|
|
this.measurements.type("efficiency").variant(variant).position('downstream').value((flow / power));
|
|
|
|
|
} else {
|
|
|
|
|
this.measurements.type("efficiency").variant(variant).position('downstream').value(null);
|
|
|
|
|
const specificFlow = flow / power;
|
|
|
|
|
const specificEnergyConsumption = power / flow;
|
|
|
|
|
|
|
|
|
|
this.measurements.type("efficiency").variant(variant).position('atEquipment').value(specificFlow);
|
|
|
|
|
this.measurements.type("specificEnergyConsumption").variant(variant).position('atEquipment').value(specificEnergyConsumption);
|
|
|
|
|
|
|
|
|
|
if(pressureDiff?.value != null && flowM3s != null && powerWatt != null){
|
|
|
|
|
const meterPerBar = pressureDiff.value / rho * g;
|
|
|
|
|
const nHydraulicEfficiency = rho * g * flowM3s * (pressureDiff.value * meterPerBar ) / powerWatt;
|
|
|
|
|
this.measurements.type("nHydraulicEfficiency").variant(variant).position('atEquipment').value(nHydraulicEfficiency);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return this.measurements.type("efficiency").variant(variant).position('downstream').getCurrentValue();
|
|
|
|
|
//change this to nhydrefficiency ?
|
|
|
|
|
return this.measurements.type("efficiency").variant(variant).position('atEquipment').getCurrentValue();
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@@ -790,26 +771,8 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
getOutput() {
|
|
|
|
|
|
|
|
|
|
// Improved output object generation
|
|
|
|
|
const output = {};
|
|
|
|
|
//build the output object
|
|
|
|
|
this.measurements.getTypes().forEach(type => {
|
|
|
|
|
this.measurements.getVariants(type).forEach(variant => {
|
|
|
|
|
|
|
|
|
|
const downstreamVal = this.measurements.type(type).variant(variant).position("downstream").getCurrentValue();
|
|
|
|
|
const upstreamVal = this.measurements.type(type).variant(variant).position("upstream").getCurrentValue();
|
|
|
|
|
|
|
|
|
|
if (downstreamVal != null) {
|
|
|
|
|
output[`downstream_${variant}_${type}`] = downstreamVal;
|
|
|
|
|
}
|
|
|
|
|
if (upstreamVal != null) {
|
|
|
|
|
output[`upstream_${variant}_${type}`] = upstreamVal;
|
|
|
|
|
}
|
|
|
|
|
if (downstreamVal != null && upstreamVal != null) {
|
|
|
|
|
const diffVal = this.measurements.type(type).variant(variant).difference().value;
|
|
|
|
|
output[`differential_${variant}_${type}`] = diffVal;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
const output = this.measurements.getFlattenedOutput();
|
|
|
|
|
|
|
|
|
|
//fill in the rest of the output object
|
|
|
|
|
output["state"] = this.state.getCurrentState();
|
|
|
|
|
@@ -820,6 +783,7 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
output["cog"] = this.cog; // flow / power efficiency
|
|
|
|
|
output["NCog"] = this.NCog; // normalized cog
|
|
|
|
|
output["NCogPercent"] = Math.round(this.NCog * 100 * 100) / 100 ;
|
|
|
|
|
output["maintenanceTime"] = this.state.getMaintenanceTimeHours();
|
|
|
|
|
|
|
|
|
|
if(this.flowDrift != null){
|
|
|
|
|
const flowDrift = this.flowDrift;
|
|
|
|
|
@@ -843,8 +807,8 @@ _callMeasurementHandler(measurementType, value, position, context) {
|
|
|
|
|
module.exports = Machine;
|
|
|
|
|
|
|
|
|
|
/*------------------- Testing -------------------*/
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
curve = require('C:/Users/zn375/.node-red/public/fallbackData.json');
|
|
|
|
|
|
|
|
|
|
//import a child
|
|
|
|
|
|
