Add flowNumber configuration to define effluent flow handling

datasets/assetData/assetData.json

@@ -66,6 +66,15 @@
                   "units": ["g/m³", "mol/m³"]
                 }
               ]
+            },
+            {
+              "name": "Quantity (TSS)",
+              "models": [
+                { 
+                  "name": "VegaSolidsProbe", 
+                  "units": ["g/m³"]
+                }
+              ]
             }
           ]
         }

src/configs/rotatingMachine.json

@@ -412,6 +412,14 @@
         ],
         "description": "The frequency at which calculations are performed."
       }
+    },
+    "flowNumber": {
+      "default": 1,
+      "rules": {
+        "type": "number",
+        "nullable": false,
+        "description": "Defines which effluent flow of the parent node to handle."
+      }
     }
   }
   

src/helper/childRegistrationUtils.js

@@ -11,8 +11,12 @@ class ChildRegistrationUtils {
 
     this.logger.debug(`Registering child: ${name} (${id}) as ${softwareType} at ${positionVsParent}`);
 
-    // Enhanced child setup
+    // Enhanced child setup - multiple parents
-    child.parent = this.mainClass;
+    if (Array.isArray(child.parent)) {
+      child.parent.push(this.mainClass);
+    } else {
+      child.parent = [this.mainClass];
+    }
     child.positionVsParent = positionVsParent;
 
     // Enhanced measurement container with rich context

src/measurements/MeasurementBuilder.js

@@ -40,7 +40,7 @@ class MeasurementBuilder {
     if (!this.variant) {
       throw new Error('Measurement variant is required');
     }
-    if (Number.isNaN(this.position)) {
+    if (!this.position) {
       throw new Error('Measurement position is required');
     }
 

src/measurements/MeasurementContainer.js

@@ -105,60 +105,59 @@ class MeasurementContainer {
 
   // ENHANCED: Update your existing value method
   value(val, timestamp = Date.now(), sourceUnit = null) {
-    if (!this._ensureChainIsValid()) return this;
+      if (!this._ensureChainIsValid()) return this;
       
-    const measurement = this._getOrCreateMeasurement();
+      const measurement = this._getOrCreateMeasurement();
-    const targetUnit = this._getTargetUnit(this._currentType);
+      const targetUnit = this._getTargetUnit(this._currentType);
       
-    let convertedValue = val;
+      let convertedValue = val;
-    let finalUnit = sourceUnit || targetUnit;
+      let finalUnit = sourceUnit || targetUnit;
 
-    // Auto-convert if enabled and units are specified
+      // Auto-convert if enabled and units are specified
-    if (this.autoConvert && sourceUnit && targetUnit && sourceUnit !== targetUnit) {
+      if (this.autoConvert && sourceUnit && targetUnit && sourceUnit !== targetUnit) {
-      try {
+        try {
-        convertedValue = convertModule(val).from(sourceUnit).to(targetUnit);
+          convertedValue = convertModule(val).from(sourceUnit).to(targetUnit);
-        finalUnit = targetUnit;
+          finalUnit = targetUnit;
           
-        if (this.logger) {
+          if (this.logger) {
-          this.logger.debug(`Auto-converted ${val} ${sourceUnit} to ${convertedValue} ${targetUnit}`);
+            this.logger.debug(`Auto-converted ${val} ${sourceUnit} to ${convertedValue} ${targetUnit}`);
+          }
+        } catch (error) {
+          if (this.logger) {
+            this.logger.warn(`Auto-conversion failed from ${sourceUnit} to ${targetUnit}: ${error.message}`);
+          }
+          convertedValue = val;
+          finalUnit = sourceUnit;
         }
-      } catch (error) {
-        if (this.logger) {
-          this.logger.warn(`Auto-conversion failed from ${sourceUnit} to ${targetUnit}: ${error.message}`);
-        }
-        convertedValue = val;
-        finalUnit = sourceUnit;
       }
-    }
 
-    measurement.setValue(convertedValue, timestamp);
+      measurement.setValue(convertedValue, timestamp);
       
-    if (finalUnit && !measurement.unit) {
+      if (finalUnit && !measurement.unit) {
-      measurement.setUnit(finalUnit);
+        measurement.setUnit(finalUnit);
-    }
+      }
 
-    // ENHANCED: Emit event with rich context
+      // ENHANCED: Emit event with rich context
-    const eventData = {
+      const eventData = {
-      value: convertedValue,
+        value: convertedValue,
-      originalValue: val,
+        originalValue: val,
-      unit: finalUnit,
+        unit: finalUnit,
-      sourceUnit: sourceUnit,
+        sourceUnit: sourceUnit,
-      timestamp,
+        timestamp,
-      position: this._currentPosition,
+        position: this._currentPosition,
-      variant: this._currentVariant,
+        variant: this._currentVariant,
-      type: this._currentType,
+        type: this._currentType,
-      // NEW: Enhanced context
+        // NEW: Enhanced context
-      childId: this.childId,
+        childId: this.childId,
-      childName: this.childName,
+        childName: this.childName,
-      parentRef: this.parentRef
+        parentRef: this.parentRef
-    };
+      };
 
-    // Emit the exact event your parent expects
+      // Emit the exact event your parent expects
-    this.emitter.emit(`${this._currentType}.${this._currentVariant}.${this._convertPositionNum2Str(this._currentPosition)}`, eventData);
+      this.emitter.emit(`${this._currentType}.${this._currentVariant}.${this._currentPosition}`, eventData);
-    this.emitter.emit(`${this._currentType}.${this._currentVariant}.${this._currentPosition}`, eventData);
+      //console.log(`Emitted event: ${this._currentType}.${this._currentVariant}.${this._currentPosition}`, eventData);
-    // console.log(`Emitted event: ${this._currentType}.${this._currentVariant}.${this._currentPosition}`, eventData);
 
-    return this;
+      return this;
   }
 
 
@@ -284,7 +283,7 @@ class MeasurementContainer {
 
   // Helper methods
   _ensureChainIsValid() {
-    if (!this._currentType || !this._currentVariant || Number.isNaN(this._currentPosition)) {
+    if (!this._currentType || !this._currentVariant || !this._currentPosition) {
       if (this.logger) {
         this.logger.error('Incomplete measurement chain, required: type, variant, and position');
       }