added lagged value functionality for retrieving values further down in memory; Converted position always to lower case strings to avoid problems with caps sensitivity names; added examples for use in examples.js

src/configs/pumpingStation.json

@@ -206,21 +206,18 @@
         }
     },
     "basin": {
-        "shape": {
-            "default": "cylindrical",
+        "volume": {
+            "default": "1",
             "rules": {
-                "type": "enum",
-                "values": [
-                    {
-                        "value": "cylindrical",
-                        "description": "The wet well is primarily cylindrical."
-                    },
-                    {
-                        "value": "rectangular",
-                        "description": "The wet well is rectangular or box shaped."
+                "type": "number",
+                "description": "Total volume of empty basin in m3"
             }
-                ],
-                "description": "General geometry of the basin or wet well."
+        },
+        "height": {
+            "default": "1",
+            "rules": {
+                "type": "number",
+                "description": "Total height of basin in m"
             }
         },
         "levelUnit": {
@@ -272,7 +269,6 @@
         }
     },
     "hydraulics": {
-        
         "maxInflowRate": {
             "default": 200,
             "rules": {
@@ -281,6 +277,28 @@
                 "description": "Maximum expected inflow during peak events (m3/h)."
             }
         },
+        "refHeight": {
+            "default": "NAP",
+            "rules": {
+                "type": "enum",
+                "values": [
+                    {
+                        "value": "NAP",
+                        "description": "NAP (Normaal Amsterdams Peil)"
+                    },
+                    {
+                        "value": "EVRF",
+                        "description": "EVRF (European Vertical Reference Frame)"
+                    },
+                    {
+                        "value": "EGM2008",
+                        "description": "EGM2008 / EGM96 (satellietmetingen) Geopotentieel model earth "
+                    }
+                    
+                ],
+                "description": "Reference height to use to identify the height vs other basins with. This will say something more about the expected pressure loss in m head"
+            }
+        },
         "staticHead": {
             "default": 12,
             "rules": {

src/measurements/Measurement.js

@@ -68,6 +68,23 @@ class Measurement {
     return this.values[this.values.length - 1];
   }
 
+  getLaggedValue(lag){
+    if(this.values.length <= lag) return null;
+    return this.values[this.values.length - lag];
+  }
+
+  getLaggedSample(lag){
+    if (lag < 0) throw new Error('lag must be >= 0');
+      const index = this.values.length - 1 - lag;
+    if (index < 0) return null;
+
+    return {
+      value: this.values[index],
+      timestamp: this.timestamps[index],
+      unit: this.unit,
+    };
+  }
+  
   getAverage() {
     if (this.values.length === 0) return null;
     const sum = this.values.reduce((acc, val) => acc + val, 0);

src/measurements/MeasurementContainer.js

@@ -94,7 +94,8 @@ class MeasurementContainer {
       throw new Error('Variant must be specified before position');
     }
 
-    this._currentPosition = positionValue;
+    
+    this._currentPosition = positionValue.toString().toLowerCase();;
     
     return this;
   }
@@ -247,37 +248,64 @@ class MeasurementContainer {
     return measurement ? measurement.getAllValues() : null;
   }
 
+  getLaggedValue(lag = 1,requestedUnit = null ){
+    const measurement = this.get();
+    if (!measurement) return null;
+    
+    const value = measurement.getLaggedSample(lag);
+    if (value === null) return null;
+
+    // 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) {
+          this.logger.error(`Unit conversion failed: ${error.message}`);
+        }
+        return value; // Return original value if conversion fails
+      }
+    }
+
+    return value;
+  }
 
 
   // Difference calculations between positions
-  difference(requestedUnit = null) {
-    
+difference({ from = "downstream", to = "upstream", unit: requestedUnit } = {}) {
   if (!this._currentType || !this._currentVariant) {
-      throw new Error('Type and variant must be specified for difference calculation');
+    throw new Error("Type and variant must be specified for difference calculation");
   }
-    const upstream = this.measurements?.[this._currentType]?.[this._currentVariant]?.['upstream'] || null;
-    const downstream = this.measurements?.[this._currentType]?.[this._currentVariant]?.['downstream'] || null;
 
-    if (!upstream || !downstream || upstream.values.length === 0 || downstream.values.length === 0) {
+  const get = pos =>
+    this.measurements?.[this._currentType]?.[this._currentVariant]?.[pos] || null;
+
+  const a = get(from);
+  const b = get(to);
+  if (!a || !b || a.values.length === 0 || b.values.length === 0) {
     return null;
   }
 
-    // Get target unit for conversion
-    const targetUnit = requestedUnit || upstream.unit || downstream.unit;
+  const targetUnit = requestedUnit || a.unit || b.unit;
+  const aVal = this._convertValueToUnit(a.getCurrentValue(), a.unit, targetUnit);
+  const bVal = this._convertValueToUnit(b.getCurrentValue(), b.unit, targetUnit);
 
-    // Get values in the same unit
-    const upstreamValue = this._convertValueToUnit(upstream.getCurrentValue(), upstream.unit, targetUnit);
-    const downstreamValue = this._convertValueToUnit(downstream.getCurrentValue(), downstream.unit, targetUnit);
-    
-    const upstreamAvg = this._convertValueToUnit(upstream.getAverage(), upstream.unit, targetUnit);
-    const downstreamAvg = this._convertValueToUnit(downstream.getAverage(), downstream.unit, targetUnit);
+  const aAvg = this._convertValueToUnit(a.getAverage(), a.unit, targetUnit);
+  const bAvg = this._convertValueToUnit(b.getAverage(), b.unit, targetUnit);
 
   return {
-      value: downstreamValue - upstreamValue,
-      avgDiff: downstreamAvg - upstreamAvg,
-      unit: targetUnit
+    value: aVal - bVal,
+    avgDiff: aAvg - bAvg,
+    unit: targetUnit,
+    from,
+    to,
   };
-  }
+}
 
   // Helper methods
   _ensureChainIsValid() {

src/measurements/examples.js

@@ -213,6 +213,10 @@ const pressureDiff = basicContainer
 
 console.log(`Pressure difference: ${pressureDiff.value} ${pressureDiff.unit}\n`);
 
+//reversable difference
+const deltaP = basicContainer.type("pressure").variant("measured").difference(); // defaults to downstream - upstream
+const netFlow = basicContainer.type("flow").variant("measured").difference({ from: "upstream", to: "downstream" });
+
 // ====================================
 // ADVANCED STATISTICS & HISTORY
 // ====================================
@@ -248,6 +252,28 @@ const allValues = stats.getAllValues();
 console.log(`  Samples: ${allValues.values.length}`);
 console.log(`  History: [${allValues.values.join(', ')}]\n`);
 
+console.log('--- Lagged sample comparison ---');
+
+const latest = stats.getCurrentValue();               // existing helper
+const prevSample = stats.getLaggedValue(1);           // new helper
+const prevPrevSample = stats.getLaggedValue(2);       // optional
+
+if (prevSample) {
+  const delta = latest - prevSample.value;
+  console.log(
+    `Current vs previous: ${latest} ${statsData.unit} (t=${stats.get().getLatestTimestamp()}) vs ` +
+    `${prevSample.value} ${prevSample.unit} (t=${prevSample.timestamp})`
+  );
+  console.log(`Δ = ${delta.toFixed(2)} ${statsData.unit}`);
+}
+
+if (prevPrevSample) {
+  console.log(
+    `Previous vs 2-steps-back timestamps: ${new Date(prevSample.timestamp).toISOString()} vs ` +
+    `${new Date(prevPrevSample.timestamp).toISOString()}`
+  );
+}
+
 // ====================================
 // DYNAMIC UNIT MANAGEMENT
 // ====================================
@@ -299,8 +325,11 @@ basicContainer.getTypes().forEach(type => {
   }
 });
 
+
+
 console.log('\n✅ All examples complete!\n');
 
+
 // ====================================
 // BEST PRACTICES
 // ====================================