Rename _updateSourceSink to updateSourceSink for outside access

Reviewed-on: #4

rotatingMachine.html

@@ -1,3 +1,13 @@
+<!--
+| S88-niveau             | Primair (blokkleur) | Tekstkleur |
+| ---------------------- | ------------------- | ---------- |
+| **Area**               | `#0f52a5`           | wit        |
+| **Process Cell**       | `#0c99d9`           | wit        |
+| **Unit**               | `#50a8d9`           | zwart      |
+| **Equipment (Module)** | `#86bbdd`           | zwart      |
+| **Control Module**     | `#a9daee`           | zwart      |
+
+-->
 <!-- Load the dynamic menu & config endpoints -->
 <script src="/rotatingMachine/menu.js"></script>
 <script src="/rotatingMachine/configData.js"></script>
@@ -5,10 +15,8 @@
 <script>
   RED.nodes.registerType("rotatingMachine", {
     category: "EVOLV",
-    color: "#4f8582",
+    color: "#86bbdd",
         defaults: {
-          // Define default properties
-          name: { value: ""}, // use asset category as name ?
 
           // Define specific properties
           speed: { value: 1, required: true },
@@ -16,7 +24,8 @@
           warmup: { value: 0 },
           shutdown: { value: 0 },
           cooldown: { value: 0 },
-          machineCurve : { value: {}},
+          machineCurve: { value: {}},
+          flowNumber: { value: 1, required: true },
 
           //define asset properties
           uuid: { value: "" },
@@ -33,13 +42,17 @@
           //physicalAspect
           positionVsParent: { value: "" },
           positionIcon: { value: "" },
+          hasDistance: { value: false },
+          distance: { value: 0 },
+          distanceUnit: { value: "m" },
+          distanceDescription: { value: "" }
 
     },
     inputs: 1,
     outputs: 3,
     inputLabels: ["Input"],
     outputLabels: ["process", "dbase", "parent"],
-    icon: "font-awesome/fa-tachometer",
+    icon: "font-awesome/fa-cog",
 
     label: function () {
       return this.positionIcon + " " + this.category.slice(0, -1) || "Machine";
@@ -66,6 +79,7 @@
     },
     oneditsave: function() {
       const node = this;
+
       // save asset fields
       if (window.EVOLV?.nodes?.rotatingMachine?.assetMenu?.saveEditor) {
         window.EVOLV.nodes.rotatingMachine.assetMenu.saveEditor(this);
@@ -114,6 +128,10 @@
     <label for="node-input-cooldown"><i class="fa fa-clock-o"></i> Cooldown Time</label>
     <input type="number" id="node-input-cooldown" style="width:60%;" />
   </div>
+  <div class="form-row">
+    <label for="node-input-flowNumber"><i class="fa fa-clock-o"></i> Flow Number</label>
+    <input type="number" id="node-input-flowNumber" style="width:60%;" />
+  </div>
 
   <!-- Asset fields injected here -->
   <div id="asset-fields-placeholder"></div>

src/nodeClass.js

@@ -45,7 +45,6 @@ class nodeClass {
     // Merge UI config over defaults
     this.config = {
       general: {
-        name: uiConfig.name,
         id: node.id, // node.id is for the child registration process
         unit: uiConfig.unit, // add converter options later to convert to default units (need like a model that defines this which units we are going to use and then conver to those standards)
         logging: {
@@ -63,8 +62,9 @@ class nodeClass {
         unit: uiConfig.unit
       },
       functionality: {
-        positionVsParent: uiConfig.positionVsParent || 'atEquipment', // Default to 'atEquipment' if not specified
-      }
+        positionVsParent: uiConfig.positionVsParent
+      },
+      flowNumber: uiConfig.flowNumber
     };
 
     // Utility for formatting outputs

src/specificClass.js

@@ -1,50 +1,6 @@
-/**
- * @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 { name } = require('../../generalFunctions/src/convert/lodash/lodash._shimkeys');
 
 class Machine {
 
@@ -65,9 +21,12 @@ class Machine {
 
     //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;
@@ -92,7 +51,6 @@ class Machine {
     this.measurements = new MeasurementContainer();
     this.interpolation = new interpolation();
 
-
     this.flowDrift = null;
 
     this.currentMode = this.config.mode.current;
@@ -110,160 +68,94 @@ class Machine {
       this.updatePosition();
     });
 
+    // used for holding the source and sink unit operations or other object with setInfluent / getEffluent method for e.g. recirculation.
+    this.upstreamSource = null;
+    this.downstreamSink = null;
+
     this.child = {}; // object to hold child information so we know on what to subscribe
     this.childRegistrationUtils = new childRegistrationUtils(this); // Child registration utility
 
   }
 
   /*-------------------               Register child events               -------------------*/
-registerOnChildEvents() {
-  this.logger.debug('Setting up child event listeners');
+  registerChild(child, softwareType) {
+    if(!child) {
+      this.logger.error(`Invalid ${softwareType} child provided.`);
+      return;
+    }
 
-  const sensors = this.childRegistrationUtils.getChildrenOfType('measurement', 'sensor');
-  
-  if (sensors.length === 0) {
-    this.logger.warn('No measurement sensors found to register events for');
-    return;
+    switch (softwareType) {
+      case "measurement":
+        this.logger.debug(`Registering measurement child...`);
+        this._connectMeasurement(child);
+        break;
+      case "reactor":
+        this.logger.debug(`Registering reactor child...`);
+        this._connectReactor(child);
+        break;
+      default:
+        this.logger.error(`Unrecognized softwareType: ${softwareType}`);
+    }
   }
 
-  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);
-  });
+  _connectMeasurement(measurementChild) {
+    const position = measurementChild.config.functionality.positionVsParent;
+    const distance = measurementChild.config.functionality.distanceVsParent || 0;
+    const measurementType = measurementChild.config.asset.type;
+    //rebuild to measurementype.variant no position and then switch based on values not strings or names.
+    const eventName = `${measurementType}.measured.${position}`;
 
-  // 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.debug(`Setting up listener for ${eventName} from child ${measurementChild.config.general.name}`);
+    // Register event listener for measurement updates
+    measurementChild.measurements.emitter.on(eventName, (eventData) => {
+      this.logger.debug(`🔄 ${position} ${measurementType} from ${eventData.childName}: ${eventData.value} ${eventData.unit}`);
 
-  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
+      // Store directly in parent's measurement container
       this.measurements
         .type(measurementType)
         .variant("measured")
         .position(position)
-        .value(eventData.value, eventData.timestamp, eventData.unit);
+        .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);
+      // Call the appropriate handler
+      switch (measurementType) {
+        case 'pressure':
+          this.updateMeasuredPressure(eventData.value, position, eventData);
+          break;
+          
+        case 'flow':
+          this.updateMeasuredFlow(eventData.value, position, eventData);
+          break;
+          
+        default:
+          this.logger.warn(`No handler for measurement type: ${measurementType}`);
+          // Generic handler - just update position
+          this.updatePosition();
+      }
     });
-  });
-  
-  this.logger.debug(`✅ Registered ${sensorCount} sensor events with averaging: ${eventName}`);
-}
-
-// Centralized handler dispatcher
-_callMeasurementHandler(measurementType, value, position, context) {
-  switch (measurementType) {
-    case 'pressure':
-      this.updateMeasuredPressure(value, position, context);
-      break;
-      
-    case 'flow':
-      this.updateMeasuredFlow(value, position, context);
-      break;
-      
-    case 'temperature':
-      this.updateMeasuredTemperature(value, position, context);
-      break;
-      
-    default:
-      this.logger.warn(`No handler for measurement type: ${measurementType}`);
-      // Generic handler - just update position
-      this.updatePosition();
-      break;
   }
-}
 
-//---------------- END child stuff -------------//
+  _connectReactor(reactorChild) {
+    this.downstreamSink = reactorChild; // downstream from the pumps perpective
+  }
 
-    // Method to assess drift using errorMetrics
-    assessDrift(measurement, processMin, processMax) {
-      this.logger.debug(`Assessing drift for measurement: ${measurement} processMin: ${processMin} processMax: ${processMax}`);
-      const predictedMeasurement = this.measurements.type(measurement).variant("predicted").position("downstream").getAllValues().values;
-      const measuredMeasurement = this.measurements.type(measurement).variant("measured").position("downstream").getAllValues().values;
+  //---------------- END child stuff -------------//
 
-      if (!predictedMeasurement || !measuredMeasurement) return null;
-      
-      return this.errorMetrics.assessDrift(
-        predictedMeasurement,
-        measuredMeasurement,
-        processMin,
-        processMax
-      );
-    }
+  // Method to assess drift using errorMetrics
+  assessDrift(measurement, processMin, processMax) {
+    this.logger.debug(`Assessing drift for measurement: ${measurement} processMin: ${processMin} processMax: ${processMax}`);
+    const predictedMeasurement = this.measurements.type(measurement).variant("predicted").position("downstream").getAllValues().values;
+    const measuredMeasurement = this.measurements.type(measurement).variant("measured").position("downstream").getAllValues().values;
+
+    if (!predictedMeasurement || !measuredMeasurement) return null;
+    
+    return this.errorMetrics.assessDrift(
+      predictedMeasurement,
+      measuredMeasurement,
+      processMin,
+      processMax
+    );
+  }
 
   reverseCurve(curve) {
     const reversedCurve = {};
@@ -293,37 +185,37 @@ _callMeasurementHandler(measurementType, value, position, context) {
   }
 
   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};
     }
     
-
     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;
+          return await this.executeSequence(parameter);
+
         case "execMovement":
-          await this.setpoint(parameter);
-          break;
+          return await this.setpoint(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;
+          return await this.setpoint(pos);
+
         case "emergencyStop":
           this.logger.warn(`Emergency stop activated by '${source}'.`);
-          await this.executeSequence("emergencyStop");
-          break;
+          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 +225,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 +272,9 @@ _callMeasurementHandler(measurementType, value, position, context) {
         break; // Exit sequence execution on error
       }
     }
+
+    //recalc flow and power
+    this.updatePosition();
   }
 
   async setpoint(setpoint) {
@@ -420,20 +322,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 +353,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 +363,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;
 
   }
@@ -477,9 +379,9 @@ _callMeasurementHandler(measurementType, value, position, context) {
   // this will be either the differential pressure, downstream or upstream pressure
   getMeasuredPressure() {
     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 +401,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;
@@ -581,18 +483,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,14 +498,19 @@ _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'}`);
       return;
     }
 
     this.logger.debug(`Flow update: ${value} at ${position} from ${context.childName || 'child'}`);
+
+    if (this.upstreamSource && this.downstreamSink) {
+      this.updateSourceSink();
+    }
     
     // Store in parent's measurement container
     this.measurements.type("flow").variant("measured").position(position).value(value, context.timestamp, context.unit);
@@ -620,6 +521,12 @@ _callMeasurementHandler(measurementType, value, position, context) {
     }
   }
 
+  updateSourceSink() {
+    // Handles flow according to the configured "flow number"
+    this.logger.debug(`Updating source-sink pair: ${this.upstreamSource.config.functionality.softwareType} - ${this.downstreamSink.config.functionality.softwareType}`);
+    this.downstreamSink.setInfluent = this.upstreamSource.getEffluent[this.config.flowNumber];
+  }
+
   // Helper method for operational state check
   _isOperationalState() {
     const state = this.state.getCurrentState();
@@ -628,6 +535,7 @@ _callMeasurementHandler(measurementType, value, position, context) {
 
   //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();
@@ -739,12 +647,12 @@ _callMeasurementHandler(measurementType, value, position, context) {
 
     if (power != 0 && flow != 0) {
       // Calculate efficiency after measurements update
-      this.measurements.type("efficiency").variant(variant).position('downstream').value((flow / power));
+      this.measurements.type("efficiency").variant(variant).position('atEquipment').value((flow / power));
     } else {
-      this.measurements.type("efficiency").variant(variant).position('downstream').value(null);
+      this.measurements.type("efficiency").variant(variant).position('atEquipment').value(null);
     }
 
-    return this.measurements.type("efficiency").variant(variant).position('downstream').getCurrentValue();
+    return this.measurements.type("efficiency").variant(variant).position('atEquipment').getCurrentValue();
 
   }