added sum and child id support

src/configs/rotatingMachine.json

@@ -16,7 +16,7 @@
         }
       },
       "unit": {
-        "default": "m3/h",
+        "default": "m3/s",
         "rules": {
           "type": "string",
           "description": "The default measurement unit for this configuration (e.g., 'meters', 'seconds', 'unitless')."

src/measurements/MeasurementContainer.js

@@ -9,6 +9,7 @@ class MeasurementContainer {
     this.windowSize = options.windowSize || 10; // Default window size
     
     // For chaining context
+    this._currentChildId = null;
     this._currentType = null;
     this._currentVariant = null;
     this._currentPosition = null;
@@ -49,6 +50,11 @@ class MeasurementContainer {
       return this;
   }
 
+  child(childId) {
+    this._currentChildId = childId || 'default';
+    return this;
+  }
+
   setChildName(childName) {
       this.childName = childName;
       return this;
@@ -72,6 +78,13 @@ class MeasurementContainer {
            null;
   }
 
+  getUnit(type) {
+    if (!type) return null;
+    if (this.preferredUnits && this.preferredUnits[type]) return this.preferredUnits[type];
+    if (this.defaultUnits && this.defaultUnits[type]) return this.defaultUnits[type];
+    return null;
+  }
+
   // Chainable methods
   type(typeName) {
     this._currentType = typeName;
@@ -226,35 +239,46 @@ class MeasurementContainer {
   // Terminal operations - get data out
     get() {
       if (!this._ensureChainIsValid()) return null;
-    return this._getOrCreateMeasurement();
+      const variantBucket = this.measurements[this._currentType]?.[this._currentVariant];
+      if (!variantBucket) return null;
+      const posBucket = variantBucket[this._currentPosition];
+      if (!posBucket) return null;
+
+      // Legacy single measurement
+      if (posBucket?.getCurrentValue) return posBucket;
+
+      // Child-aware: pick requested child, otherwise fall back to default, otherwise first available
+      if (posBucket && typeof posBucket === 'object') {
+        const requestedKey = this._currentChildId || this.childId;
+        const keys = Object.keys(posBucket);
+        if (!keys.length) return null;
+        const measurement =
+          (requestedKey && posBucket[requestedKey]) ||
+          posBucket.default ||
+          posBucket[keys[0]];
+        return measurement || null;
       }
 
+      return null;
+    }
+
+
+
   getCurrentValue(requestedUnit = null) {
     const measurement = this.get();
     if (!measurement) return null;
-    
     const value = measurement.getCurrentValue();
     if (value === null) return null;
-
+    if (!requestedUnit || !measurement.unit || requestedUnit === measurement.unit) {
-    // Return as-is if no unit conversion requested
-    if (!requestedUnit) {
       return value;
     }
-
-    // Convert if needed
-    if (measurement.unit && requestedUnit !== measurement.unit) {
     try {
       return convertModule(value).from(measurement.unit).to(requestedUnit);
     } catch (error) {
-        if (this.logger) {
+      if (this.logger) this.logger.error(`Unit conversion failed: ${error.message}`);
-          this.logger.error(`Unit conversion failed: ${error.message}`);
-        }
-        return value; // Return original value if conversion fails
-      }
-    }
-
       return value;
     }
+  }
 
   getAverage(requestedUnit = null) {
     const measurement = this.get();
@@ -357,6 +381,50 @@ class MeasurementContainer {
     return sample;
   }
 
+  sum(type, variant, positions = [], targetUnit = null) {
+    const bucket = this.measurements?.[type]?.[variant];
+    if (!bucket) return 0;
+    return positions
+      .map((pos) => {
+        const posBucket = bucket[pos];
+        if (!posBucket) return 0;
+        return Object.values(posBucket)
+          .map((m) => {
+            if (!m?.getCurrentValue) return 0;
+            const val = m.getCurrentValue();
+            if (val == null) return 0;
+            const fromUnit = m.unit || targetUnit;
+            if (!targetUnit || !fromUnit || fromUnit === targetUnit) return val;
+            try { return convertModule(val).from(fromUnit).to(targetUnit); } catch { return val; }
+          })
+          .reduce((acc, v) => acc + (Number.isFinite(v) ? v : 0), 0);
+      })
+      .reduce((acc, v) => acc + v, 0);
+  }
+
+    getFlattenedOutput() {
+      const out = {};
+      Object.entries(this.measurements).forEach(([type, variants]) => {
+        Object.entries(variants).forEach(([variant, positions]) => {
+          Object.entries(positions).forEach(([position, entry]) => {
+            // Legacy single series
+            if (entry?.getCurrentValue) {
+              out[`${type}.${variant}.${position}`] = entry.getCurrentValue();
+              return;
+            }
+            // Child-bucketed series
+            if (entry && typeof entry === 'object') {
+              Object.entries(entry).forEach(([childId, m]) => {
+                if (m?.getCurrentValue) {
+                  out[`${type}.${variant}.${position}.${childId}`] = m.getCurrentValue();
+                }
+              });
+            }
+          });
+        });
+      });
+      return out;
+  }
 
   // Difference calculations between positions
   difference({ from = "downstream", to = "upstream", unit: requestedUnit } = {}) {
@@ -364,12 +432,21 @@ difference({ from = "downstream", to = "upstream", unit: requestedUnit } = {}) {
       throw new Error("Type and variant must be specified for difference calculation");
     }
 
-  const get = pos =>
+    const get = pos => {
-    this.measurements?.[this._currentType]?.[this._currentVariant]?.[pos] || null;
+      const bucket = this.measurements?.[this._currentType]?.[this._currentVariant]?.[pos];
+      if (!bucket) return null;
+      // child-aware bucket: pick current childId/default or first available
+      if (bucket && typeof bucket === 'object' && !bucket.getCurrentValue) {
+        const childKey = this._currentChildId || this.childId || Object.keys(bucket)[0];
+        return bucket?.[childKey] || null;
+      }
+      // legacy single measurement
+      return bucket;
+    };
 
     const a = get(from);
     const b = get(to);
-  if (!a || !b || a.values.length === 0 || b.values.length === 0) {
+    if (!a || !b || !a.values || !b.values || a.values.length === 0 || b.values.length === 0) {
       return null;
     }
 
@@ -380,13 +457,7 @@ difference({ from = "downstream", to = "upstream", unit: requestedUnit } = {}) {
     const aAvg = this._convertValueToUnit(a.getAverage(), a.unit, targetUnit);
     const bAvg = this._convertValueToUnit(b.getAverage(), b.unit, targetUnit);
 
-  return {
+    return { value: aVal - bVal, avgDiff: aAvg - bAvg, unit: targetUnit, from, to };
-    value: aVal - bVal,
-    avgDiff: aAvg - bAvg,
-    unit: targetUnit,
-    from,
-    to,
-  };
   }
 
   // Helper methods
@@ -410,18 +481,26 @@ difference({ from = "downstream", to = "upstream", unit: requestedUnit } = {}) {
       this.measurements[this._currentType][this._currentVariant] = {};
     }
     
-    if (!this.measurements[this._currentType][this._currentVariant][this._currentPosition]) {
+    const positionKey = this._currentPosition;
-      this.measurements[this._currentType][this._currentVariant][this._currentPosition] = 
+    const childKey = this._currentChildId || this.childId || 'default';
-        new MeasurementBuilder()
+
+    if (!this.measurements[this._currentType][this._currentVariant][positionKey]) {
+      this.measurements[this._currentType][this._currentVariant][positionKey] = {};
+    }
+
+    const bucket = this.measurements[this._currentType][this._currentVariant][positionKey];
+
+    if (!bucket[childKey]) {
+      bucket[childKey] = new MeasurementBuilder()
         .setType(this._currentType)
         .setVariant(this._currentVariant)
-          .setPosition(this._currentPosition)
+        .setPosition(positionKey)
         .setWindowSize(this.windowSize)
         .setDistance(this._currentDistance)
         .build();
     }
 
-    return this.measurements[this._currentType][this._currentVariant][this._currentPosition];
+    return bucket[childKey];
   }
 
   // Additional utility methods

src/measurements/examples.js

@@ -177,18 +177,18 @@ const downstreamData = basicContainer
   .get();
 
   //check wether a serie exists
-const hasSeries = measurements
+const hasSeries = basicContainer
   .type("flow")
   .variant("measured")
   .exists();                // true if any position exists
 
-const hasUpstreamValues = measurements
+const hasUpstreamValues = basicContainer
   .type("flow")
   .variant("measured")
   .exists({ position: "upstream", requireValues: true });
 
 // Passing everything explicitly
-const hasPercent = measurements.exists({
+const hasPercent = basicContainer.exists({
   type: "volume",
   variant: "percent",
   position: "atEquipment",
@@ -274,14 +274,14 @@ console.log(`  History: [${allValues.values.join(', ')}]\n`);
 
 console.log('--- Lagged sample comparison ---');
 
-const latest = stats.getCurrentValue();               // existing helper
+const latestSample = stats.getLaggedSample(0);   // newest sample object
-const prevSample = stats.getLaggedValue(1);           // new helper
+const prevSample = stats.getLaggedSample(1);
-const prevPrevSample = stats.getLaggedValue(2);       // optional
+const prevPrevSample = stats.getLaggedSample(2);
 
 if (prevSample) {
-  const delta = latest - prevSample.value;
+  const delta = (latestSample?.value ?? 0) - (prevSample.value ?? 0);
   console.log(
-    `Current vs previous: ${latest} ${statsData.unit} (t=${stats.get().getLatestTimestamp()}) vs ` +
+    `Current vs previous: ${latestSample?.value} ${statsData.unit} (t=${latestSample?.timestamp}) vs ` +
     `${prevSample.value} ${prevSample.unit} (t=${prevSample.timestamp})`
   );
   console.log(`Δ = ${delta.toFixed(2)} ${statsData.unit}`);