From 5a1eff37d7236d55d6091fed5d51c59483fb653b Mon Sep 17 00:00:00 2001
From: znetsixe <73483679+znetsixe@users.noreply.github.com>
Date: Mon, 27 Oct 2025 17:45:48 +0100
Subject: [PATCH] Need to remove wobble on level only

---
 src/specificClass.js | 43 +++++++++++++++++++++++--------------------
 1 file changed, 23 insertions(+), 20 deletions(-)

diff --git a/src/specificClass.js b/src/specificClass.js
index a9da992..85a6833 100644
--- a/src/specificClass.js
+++ b/src/specificClass.js
@@ -219,15 +219,14 @@ class pumpingStation {
     this._updateVolumePrediction("in"); // check for changes in incomming flow
 
     //calc the most important values back to determine state and net up or downstream flow
-    this._calcNetFlow();
+    //this._calcNetFlow();
     const {time:timeleft, source:variant} = this._calcTimeRemaining();
 
-
-    this.logger.debug(`Remaining time ${timeleft}, based on variant ${variant}  `);
+    this.logger.debug(`Remaining time ${Math.round(timeleft/60/60*100)/100} h, based on variant ${variant}  `);
   }
 
   _calcTimeRemaining(){
-        //init timeRemaining
+    //init timeRemaining
     const winningTime = {time:0,source:""};
 
     //calculate time left prioritise flow based variant
@@ -377,7 +376,7 @@ class pumpingStation {
     let netFlow = null;
 
     const netFlow_FlowSensor = Math.abs(this.measurements.type("flow").variant("measured").difference({ from: "downstream", to: "upstream", unit: "m3/s" }));
-    const netFlow_LevelSensor = this._calcNetFlowFromLevelDiff();
+    const netFlow_LevelSensor = this._calcNetFlowFromLevelDiff("measured");
     const netFlow_PredictedFlow = Math.abs(this.measurements.type('flow').variant('predicted').difference({ from: "in", to: "out", unit: "m3/s" }));
 
     switch (true){
@@ -442,36 +441,39 @@ class pumpingStation {
   //@params : variant : example "predicted","measured"
   _calcRemainingTimeBasedOnLevel(variant){
 
+    const {heightOverflow,heightOutlet} = this.basin;
     const levelObj = this.measurements.type("level").variant(variant).position("atEquipment");
     const level = levelObj.getCurrentValue("m");
-    const prevLevel = levelObj.getLaggedValue(2, "m"); // { value, timestamp, unit }
+    const prevLevelSample = levelObj.getLaggedSample(2, "m"); // { value, timestamp, unit }
     const measurement = levelObj.get();
     const latestTimestamp = measurement?.getLatestTimestamp();
 
-    if (level === null || !prevLevel || latestTimestamp == null) {
-      this.logger.warn(`no flowdiff ${level}, previous level ${prevLevel}, latestTimestamp ${latestTimestamp} found escaping`);
+    if (level === null || prevLevelSample == null || latestTimestamp == null) {
+      this.logger.warn(`no flowdiff ${level}, previous level ${prevLevelSample}, latestTimestamp ${latestTimestamp} found escaping`);
       return null;
     }
 
-    const deltaSeconds = (latestTimestamp - prevLevel.timestamp) / 1000;
+    const deltaSeconds = (latestTimestamp - prevLevelSample.timestamp) / 1000;
     if (deltaSeconds <= 0) {
-      this.logger.warn(`Level fallback: invalid Δt=${deltaSeconds} , LatestTimestamp : ${latestTimestamp}, PrevTimestamp : ${prevLevel.timestamp}`);
+      this.logger.warn(`Level fallback: invalid Δt=${deltaSeconds} , LatestTimestamp : ${latestTimestamp}, PrevTimestamp : ${prevLevelSample.value}`);
       return null;
     }
 
-    const lvlDiff = level - prevLevel.value;
-    const lvlRate = Math.abs(lvlDiff / deltaSeconds); // m/s
+    const lvlDiff = level - prevLevelSample.value;
+    const lvlRate = lvlDiff / deltaSeconds; // m/s
+    let secondsRemaining = 0;
+    let remainingHeight = 0;
 
     switch(true){
 
       case(lvlRate>0):
         remainingHeight = Math.max(heightOverflow - level, 0);
-        secondsRemaining = remainingHeight / lvlRate; // seconds
+        secondsRemaining = remainingHeight / Math.abs(lvlRate); // seconds
         return secondsRemaining;
 
       case(lvlRate<0):
         remainingHeight = Math.max(level - heightOutlet, 0);
-        secondsRemaining = remainingHeight / lvlRate;
+        secondsRemaining = remainingHeight / Math.abs(lvlRate);
         return secondsRemaining;
 
       default:
@@ -511,22 +513,22 @@ class pumpingStation {
     const { surfaceArea } = this.basin;
     const levelObj = this.measurements.type("level").variant(variant).position("atEquipment");
     const level = levelObj.getCurrentValue("m");
-    const prevLevel = levelObj.getLaggedValue(2, "m"); // { value, timestamp, unit }
+    const prevLevelSample = levelObj.getLaggedSample(2, "m"); // { value, timestamp, unit }
     const measurement = levelObj.get();
     const latestTimestamp = measurement?.getLatestTimestamp();
 
-    if (level === null || !prevLevel || latestTimestamp == null) {
-      this.logger.warn(`no flowdiff ${level}, previous level ${prevLevel}, latestTimestamp ${latestTimestamp} found escaping`);
+    if (level === null || prevLevelSample == null || latestTimestamp == null) {
+      this.logger.warn(`no flowdiff ${level}, previous level ${prevLevelSample}, latestTimestamp ${latestTimestamp} found escaping`);
       return null;
     }
 
-    const deltaSeconds = (latestTimestamp - prevLevel.timestamp) / 1000;
+    const deltaSeconds = (latestTimestamp - prevLevelSample.timestamp) / 1000;
     if (deltaSeconds <= 0) {
-      this.logger.warn(`Level fallback: invalid Δt=${deltaSeconds} , LatestTimestamp : ${latestTimestamp}, PrevTimestamp : ${prevLevel.timestamp}`);
+      this.logger.warn(`Level fallback: invalid Δt=${deltaSeconds} , LatestTimestamp : ${latestTimestamp}, PrevTimestamp : ${prevLevelSample.timestamp}`);
       return null;
     }
 
-    const lvlDiff = level - prevLevel.value;
+    const lvlDiff = level - prevLevelSample.value;
     const lvlRate = lvlDiff / deltaSeconds; // m/s
     const netFlowRate = lvlRate * surfaceArea; // m³/s inferred from level trend
 
@@ -562,6 +564,7 @@ class pumpingStation {
 
     //init predicted min volume to min vol in order to have a starting point
     this.measurements.type("volume").variant("predicted").position("atEquipment").value(minVol).unit('m3');
+    this.measurements.type("volume").variant("predicted").position("atEquipment").value(maxVol).unit('m3');
 
     this.logger.debug(`
         Basin initialized | area=${surfaceArea.toFixed(2)} m²,