diff --git a/dependencies/machineGroup/machineGroup.js b/dependencies/machineGroup/machineGroup.js
index 7e8214e..31edbd4 100644
--- a/dependencies/machineGroup/machineGroup.js
+++ b/dependencies/machineGroup/machineGroup.js
@@ -33,7 +33,7 @@
  * Author:
  * - Rene De Ren
  * Email:
- * - rene@thegoldenbasket.nl
+ * - r.de.ren@brabantsedelta.nl
  */
 
 //load local dependencies
diff --git a/mgc.html b/mgc.html
index 40a5eca..0d747ca 100644
--- a/mgc.html
+++ b/mgc.html
@@ -11,96 +11,61 @@
     #4f8582
     #c4cce0
 -->
-<script type="text/javascript">
+<script src="/machineGroupControl/menu.js"></script> <!-- Load the menu script for dynamic dropdowns --> 
+<script src="/machineGroupControl/configData.js"></script> <!-- Load the config script for node information --> 
 
+<script>
     RED.nodes.registerType('machineGroupControl',{
-        
-        category: 'digital twin',
-        color: '#eaf4f1',
-        defaults: {
-            name: {value:""},
-            enableLog: { value: false },
-            logLevel: { value: "error" },
-        },
+    category: "EVOLV",
+    color: "#eaf4f1",
+    defaults: {
+      // Define default properties
+      name: { value: "" },
+
+      // Logger properties
+      enableLog: { value: false },
+      logLevel: { value: "error" },
+
+      // Physical aspect
+      positionVsParent: { value: "" },
+      positionLabel: { value: "" },
+      positionIcon: { value: "" },
+    },
         inputs:1,
-        outputs:4, 
-        inputLabels: "Usage see manual",
-        outputLabels: ["process", "dbase", "upstreamParent", "downstreamParent"],
+        outputs:3, 
+        inputLabels: ["Input"],
+        outputLabels: ["process", "dbase", "parent"],
         icon: "font-awesome/fa-tachometer",
-        //define label function
-        label: function() {
-            return this.name || "MachineGroup controller";
+
+        label: function () {
+            return this.positionIcon + " " + "machineGroup";
         },
-
         oneditprepare: function() {
-            const node = this;
-
-                console.log("Rotating Machine Node: Edit Prepare");
-
-                const elements = {
-                // Basic fields
-                name: document.getElementById("node-input-name"),
-               
-                // Logging fields
-                logCheckbox: document.getElementById("node-input-enableLog"),
-                logLevelSelect: document.getElementById("node-input-logLevel"),
-                rowLogLevel: document.getElementById("row-logLevel"),
-
-                };
-
-                const projecSettingstURL = "http://localhost:1880/generalFunctions/settings/projectSettings.json";
-
-                try{
-
-                // Fetch project settings
-                menuUtils.fetchProjectData(projecSettingstURL)
-                .then((projectSettings) => {
-
-                    //assign to node vars
-                    node.configUrls = projectSettings.configUrls;
-
-                    const { cloudConfigURL, localConfigURL } = menuUtils.getSpecificConfigUrl("machineGroupControl",node.configUrls.cloud.taggcodeAPI);
-                    node.configUrls.cloud.config = cloudConfigURL; // first call
-                    node.configUrls.local.config = localConfigURL; // backup call
-
-
-                    // Gets the ID of the active workspace (Flow)
-                    const activeFlowId = RED.workspaces.active(); //fetches active flow id
-                    node.processId = activeFlowId;
-
-                    // UI elements 
-                    menuUtils.initBasicToggles(elements);
-
-                })
-
-                }catch(e){
-                console.log("Error fetching project settings", e);
+            // Initialize the menu data for the node
+            const waitForMenuData = () => {
+                if (window.EVOLV?.nodes?.machineGroupControl?.initEditor) {
+                    window.EVOLV.nodes.machineGroupControl.initEditor(this);
+                } else {
+                    setTimeout(waitForMenuData, 50);
                 }
-
-                if(node.d){
-                //this means node is disabled
-                console.log("Current status of node is disabled");
-                }
-
+            };
+            // Wait for the menu data to be ready before initializing the editor
+            waitForMenuData();
 
         },
         oneditsave: function(){
-
             const node = this;
 
-            //save basic properties
-            ["name"].forEach(
-            (field) => {
-                const element = document.getElementById(`node-input-${field}`);
-                if (element) {
-                node[field] = element.value || "";
-                }
+            // Validate logger properties using the logger menu
+            if (window.EVOLV?.nodes?.measurement?.loggerMenu?.saveEditor) {
+                success = window.EVOLV.nodes.measurement.loggerMenu.saveEditor(node);
             }
-            );
-
-            const logLevelElement = document.getElementById("node-input-logLevel");
-            node.logLevel = logLevelElement ? logLevelElement.value || "info" : "info";
 
+            // save position field
+            if (window.EVOLV?.nodes?.rotatingMachine?.positionMenu?.saveEditor) {
+                window.EVOLV.nodes.rotatingMachine.positionMenu.saveEditor(this);
+            }
+           
         }
     });
     
@@ -108,39 +73,13 @@
 
 <script type="text/html" data-template-name="machineGroupControl">
 
- <!-------------------------------------------INPUT NAME / TYPE ----------------------------------------------->
-    <div class="form-row">
-        <label for="node-input-name"><i class="fa fa-tag"></i>Name</label>
-        <input type="text" id="node-input-name" placeholder="Name">
-    </div>
+  <!-- Logger fields injected here -->
+  <div id="logger-fields-placeholder"></div>
 
-    <hr />
-
-    <!-- loglevel checkbox -->
-    <div class="form-row">
-      <label for="node-input-enableLog"
-        ><i class="fa fa-cog"></i> Enable Log</label
-      >
-      <input
-        type="checkbox"
-        id="node-input-enableLog"
-        style="width:20px; vertical-align:baseline;"
-      />
-      <span>Enable logging</span>
-    </div>
-
-  <div class="form-row" id="row-logLevel">
-    <label for="node-input-logLevel"><i class="fa fa-cog"></i> Log Level</label>
-    <select id="node-input-logLevel" style="width:60%;">
-      <option value="info">Info</option>
-      <option value="debug">Debug</option>
-      <option value="warn">Warn</option>
-      <option value="error">Error</option>
-    </select>
-  </div>
+  <!-- Position fields injected here -->
+  <div id="position-fields-placeholder"></div>
     
-    <!-------------------------------------------INPUT TRANSLATION TO OUTPUT ----------------------------------------------->
-    <hr />
+
     <div class="form-tips"></div>
         <b>Tip:</b> Ensure that the "Name" field is unique to easily identify the node. 
         Enable logging if you need detailed information for debugging purposes. 
diff --git a/mgc.js b/mgc.js
index b260289..399f225 100644
--- a/mgc.js
+++ b/mgc.js
@@ -1,170 +1,39 @@
-module.exports = function (RED) {
-  function machineGroupControl(config) {
-    //create node
+const nameOfNode = 'machineGroupControl'; // this is the name of the node, it should match the file name and the node type in Node-RED
+const nodeClass = require('./src/nodeClass.js'); // this is the specific node class
+const { MenuManager, configManager } = require('generalFunctions');
+
+// This is the main entry point for the Node-RED node, it will register the node and setup the endpoints
+module.exports = function(RED) {
+  // Register the node type
+  RED.nodes.registerType(nameOfNode, function(config) {
+    // Initialize the Node-RED node first
     RED.nodes.createNode(this, config);
+    // Then create your custom class and attach it
+    this.nodeClass = new nodeClass(config, RED, this, nameOfNode);
+  });
 
-    //call this => node so whenver you want to call a node function type node and the function behind it
-    var node = this;
+  // Setup admin UIs
+  const menuMgr = new MenuManager(); //this will handle the menu endpoints so we can load them dynamically
+  const cfgMgr = new configManager(); // this will handle the config endpoints so we can load them dynamically
 
-    //fetch machine object from machine.js
-    const MachineGroup = require('./dependencies/machineGroup/machineGroup');
-    const OutputUtils = require("../generalFunctions/helper/outputUtils");
-
-    const mgConfig = config = { 
-      general: {
-        name: config.name,
-        id : config.id,
-        logging: {
-          enabled: config.loggingEnabled,
-          logLevel: config.logLevel,
-        }
-      },
-    };
-
-    //make new class on creation to work with.
-    const mg = new MachineGroup(mgConfig);
-
-    // put mg on node memory as source
-    node.source = mg;
-
-    //load output utils
-    const output = new OutputUtils();
-
-    //update node status
-    function updateNodeStatus(mg) {
-
-      const mode = mg.mode;
-      const scaling = mg.scaling;
-      const totalFlow = Math.round(mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() * 1) / 1;
-      const totalPower = Math.round(mg.measurements.type("power").variant("predicted").position("upstream").getCurrentValue() * 1) / 1;
-  
-      // Calculate total capacity based on available machines
-      const availableMachines = Object.values(mg.machines).filter(machine => {
-          const state = machine.state.getCurrentState();
-          const mode = machine.currentMode;
-          return !(state === "off" || state === "maintenance" || mode === "maintenance");
-      });
-  
-      const totalCapacity = Math.round(mg.dynamicTotals.flow.max * 1) / 1;
-  
-      // Determine overall status based on available machines
-      const status = availableMachines.length > 0
-          ? `${availableMachines.length} machines`
-          : "No machines";
-
-      let scalingSymbol = '';
-      switch (scaling.toLowerCase()) {
-        case 'absolute':
-          scalingSymbol = 'Ⓐ'; // Clear symbol for Absolute mode
-            break;
-          case 'normalized':
-            scalingSymbol = 'Ⓝ'; // Clear symbol for Normalized mode
-          break;
-        default:
-          scalingSymbol = mode;
-          break;
-      }
-
-  
-      // Generate status text in a single line
-      const text = ` ${mode} | ${scalingSymbol}: 💨=${totalFlow}/${totalCapacity} | ⚡=${totalPower} | ${status}`;
-  
-      return {
-          fill: availableMachines.length > 0 ? "green" : "red",
-          shape: "dot",
-          text
-      };
+  // Register the different menu's for the node
+  RED.httpAdmin.get(`/${nameOfNode}/menu.js`, (req, res) => {
+    try {
+      const script = menuMgr.createEndpoint(nameOfNode, ['logger','position']);
+      res.type('application/javascript').send(script);
+    } catch (err) {
+      res.status(500).send(`// Error generating menu: ${err.message}`);
     }
+  });
 
-    //never ending functions
-    function tick(){
-      //source.tick();
-      const status = updateNodeStatus(mg);
-      node.status(status);
-      
-      //get output
-      const classOutput = mg.getOutput();
-      const dbOutput = output.formatMsg(classOutput, mg.config, "influxdb");
-      const pOutput = output.formatMsg(classOutput, mg.config, "process");
-
-      //only send output on values that changed
-      let msgs = [];
-      msgs[0] = pOutput;
-      msgs[1] = dbOutput;
-    
-      node.send(msgs);
+  // Endpoint to get the configuration data for the specific node
+  RED.httpAdmin.get(`/${nameOfNode}/configData.js`, (req, res) => {
+    try {
+      const script = cfgMgr.createEndpoint(nameOfNode);
+      // Send the configuration data as JSON response
+      res.type('application/javascript').send(script);
+    } catch (err) {
+      res.status(500).send(`// Error generating configData: ${err.message}`);
     }
-  
-    // register child on first output this timeout is needed because of node - red stuff
-    setTimeout(
-      () => {
-        
-        /*---execute code on first start----*/
-        let msgs = [];
-
-        msgs[2] = { topic : "registerChild" , payload: node.id, positionVsParent: "upstream" };
-        msgs[3] = { topic : "registerChild" , payload: node.id, positionVsParent: "downstream" };
-        
-        //send msg
-        this.send(msgs);
-      }, 
-      100
-    );
-  
-    //declare refresh interval internal node
-    setTimeout(
-      () => {
-        /*---execute code on first start----*/
-        this.interval_id = setInterval(function(){ tick() },1000)
-      }, 
-      1000
-    );
-  
-    //-------------------------------------------------------------------->>what to do on input
-    node.on("input", async function (msg,send,done) {
-
-      if(msg.topic == 'registerChild'){ 
-        const childId = msg.payload;
-        const childObj = RED.nodes.getNode(childId);
-        mg.childRegistrationUtils.registerChild(childObj.source,msg.positionVsParent);
-      }
-
-      if(msg.topic == 'setMode'){
-        const mode = msg.payload;
-        const source = "parent";
-        mg.setMode(source,mode);
-      }
-
-      if(msg.topic == 'setScaling'){
-        const scaling = msg.payload;
-        mg.setScaling(scaling);
-      }
-
-      if(msg.topic == 'Qd'){
-        const Qd = parseFloat(msg.payload);
-        const source = "parent";
-
-        if (isNaN(Qd)) {
-          return mg.logger.error(`Invalid demand value: ${Qd}`);
-        };
-
-        try{
-          await mg.handleInput(source,Qd);
-          msg.topic = mg.config.general.name;
-          msg.payload = "done";
-          send(msg);
-        }catch(e){
-          console.log(e);
-        }
-      }
-
-      // tidy up any async code here - shutdown connections and so on.
-      node.on('close', function() {
-        clearTimeout(this.interval_id);
-      });
-
-
-    });
-  }
-  RED.nodes.registerType("machineGroupControl", machineGroupControl);
+  });
 };
\ No newline at end of file
diff --git a/mgcOLD.js b/mgcOLD.js
new file mode 100644
index 0000000..b260289
--- /dev/null
+++ b/mgcOLD.js
@@ -0,0 +1,170 @@
+module.exports = function (RED) {
+  function machineGroupControl(config) {
+    //create node
+    RED.nodes.createNode(this, config);
+
+    //call this => node so whenver you want to call a node function type node and the function behind it
+    var node = this;
+
+    //fetch machine object from machine.js
+    const MachineGroup = require('./dependencies/machineGroup/machineGroup');
+    const OutputUtils = require("../generalFunctions/helper/outputUtils");
+
+    const mgConfig = config = { 
+      general: {
+        name: config.name,
+        id : config.id,
+        logging: {
+          enabled: config.loggingEnabled,
+          logLevel: config.logLevel,
+        }
+      },
+    };
+
+    //make new class on creation to work with.
+    const mg = new MachineGroup(mgConfig);
+
+    // put mg on node memory as source
+    node.source = mg;
+
+    //load output utils
+    const output = new OutputUtils();
+
+    //update node status
+    function updateNodeStatus(mg) {
+
+      const mode = mg.mode;
+      const scaling = mg.scaling;
+      const totalFlow = Math.round(mg.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue() * 1) / 1;
+      const totalPower = Math.round(mg.measurements.type("power").variant("predicted").position("upstream").getCurrentValue() * 1) / 1;
+  
+      // Calculate total capacity based on available machines
+      const availableMachines = Object.values(mg.machines).filter(machine => {
+          const state = machine.state.getCurrentState();
+          const mode = machine.currentMode;
+          return !(state === "off" || state === "maintenance" || mode === "maintenance");
+      });
+  
+      const totalCapacity = Math.round(mg.dynamicTotals.flow.max * 1) / 1;
+  
+      // Determine overall status based on available machines
+      const status = availableMachines.length > 0
+          ? `${availableMachines.length} machines`
+          : "No machines";
+
+      let scalingSymbol = '';
+      switch (scaling.toLowerCase()) {
+        case 'absolute':
+          scalingSymbol = 'Ⓐ'; // Clear symbol for Absolute mode
+            break;
+          case 'normalized':
+            scalingSymbol = 'Ⓝ'; // Clear symbol for Normalized mode
+          break;
+        default:
+          scalingSymbol = mode;
+          break;
+      }
+
+  
+      // Generate status text in a single line
+      const text = ` ${mode} | ${scalingSymbol}: 💨=${totalFlow}/${totalCapacity} | ⚡=${totalPower} | ${status}`;
+  
+      return {
+          fill: availableMachines.length > 0 ? "green" : "red",
+          shape: "dot",
+          text
+      };
+    }
+
+    //never ending functions
+    function tick(){
+      //source.tick();
+      const status = updateNodeStatus(mg);
+      node.status(status);
+      
+      //get output
+      const classOutput = mg.getOutput();
+      const dbOutput = output.formatMsg(classOutput, mg.config, "influxdb");
+      const pOutput = output.formatMsg(classOutput, mg.config, "process");
+
+      //only send output on values that changed
+      let msgs = [];
+      msgs[0] = pOutput;
+      msgs[1] = dbOutput;
+    
+      node.send(msgs);
+    }
+  
+    // register child on first output this timeout is needed because of node - red stuff
+    setTimeout(
+      () => {
+        
+        /*---execute code on first start----*/
+        let msgs = [];
+
+        msgs[2] = { topic : "registerChild" , payload: node.id, positionVsParent: "upstream" };
+        msgs[3] = { topic : "registerChild" , payload: node.id, positionVsParent: "downstream" };
+        
+        //send msg
+        this.send(msgs);
+      }, 
+      100
+    );
+  
+    //declare refresh interval internal node
+    setTimeout(
+      () => {
+        /*---execute code on first start----*/
+        this.interval_id = setInterval(function(){ tick() },1000)
+      }, 
+      1000
+    );
+  
+    //-------------------------------------------------------------------->>what to do on input
+    node.on("input", async function (msg,send,done) {
+
+      if(msg.topic == 'registerChild'){ 
+        const childId = msg.payload;
+        const childObj = RED.nodes.getNode(childId);
+        mg.childRegistrationUtils.registerChild(childObj.source,msg.positionVsParent);
+      }
+
+      if(msg.topic == 'setMode'){
+        const mode = msg.payload;
+        const source = "parent";
+        mg.setMode(source,mode);
+      }
+
+      if(msg.topic == 'setScaling'){
+        const scaling = msg.payload;
+        mg.setScaling(scaling);
+      }
+
+      if(msg.topic == 'Qd'){
+        const Qd = parseFloat(msg.payload);
+        const source = "parent";
+
+        if (isNaN(Qd)) {
+          return mg.logger.error(`Invalid demand value: ${Qd}`);
+        };
+
+        try{
+          await mg.handleInput(source,Qd);
+          msg.topic = mg.config.general.name;
+          msg.payload = "done";
+          send(msg);
+        }catch(e){
+          console.log(e);
+        }
+      }
+
+      // tidy up any async code here - shutdown connections and so on.
+      node.on('close', function() {
+        clearTimeout(this.interval_id);
+      });
+
+
+    });
+  }
+  RED.nodes.registerType("machineGroupControl", machineGroupControl);
+};
\ No newline at end of file
diff --git a/package.json b/package.json
index ac3d423..c42540c 100644
--- a/package.json
+++ b/package.json
@@ -17,9 +17,7 @@
   "author": "Rene De Ren",
   "license": "SEE LICENSE",
   "dependencies": {
-    "generalFunctions": "git+https://gitea.centraal.wbd-rd.nl/RnD/generalFunctions.git",
-    "convert": "git+https://gitea.centraal.wbd-rd.nl/RnD/convert.git",
-    "predict": "git+https://gitea.centraal.wbd-rd.nl/RnD/predict.git"
+    "generalFunctions": "git+https://gitea.centraal.wbd-rd.nl/RnD/generalFunctions.git"
   },
   "node-red": {
     "nodes": {
diff --git a/src/nodeClass.js b/src/nodeClass.js
new file mode 100644
index 0000000..8e06ce3
--- /dev/null
+++ b/src/nodeClass.js
@@ -0,0 +1,256 @@
+const { outputUtils, configManager } = require("generalFunctions");
+const Specific = require("./specificClass");
+
+class nodeClass {
+  /**
+   * Create a MeasurementNode.
+   * @param {object} uiConfig - Node-RED node configuration.
+   * @param {object} RED    - Node-RED runtime API.
+   * @param {object} nodeInstance - The Node-RED node instance.
+   * @param {string} nameOfNode - The name of the node, used for
+   */
+  constructor(uiConfig, RED, nodeInstance, nameOfNode) {
+    // Preserve RED reference for HTTP endpoints if needed
+    this.node = nodeInstance; // This is the Node-RED node instance, we can use this to send messages and update status
+    this.RED = RED; // This is the Node-RED runtime API, we can use this to create endpoints if needed
+    this.name = nameOfNode; // This is the name of the node, it should match the file name and the node type in Node-RED
+    this.source = null; // Will hold the specific class instance
+
+    // Load default & UI config
+    this._loadConfig(uiConfig, this.node);
+
+    // Instantiate core Measurement class
+    this._setupSpecificClass();
+
+    // Wire up event and lifecycle handlers
+    this._bindEvents();
+    this._registerChild();
+    this._startTickLoop();
+    this._attachInputHandler();
+    this._attachCloseHandler();
+  }
+
+  /**
+   * Load and merge default config with user-defined settings.
+   * @param {object} uiConfig - Raw config from Node-RED UI.
+   */
+  _loadConfig(uiConfig, node) {
+    const cfgMgr = new configManager();
+    this.defaultConfig = cfgMgr.getConfig(this.name);
+
+    // 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: {
+          enabled: uiConfig.enableLog,
+          logLevel: uiConfig.logLevel,
+        },
+      },
+      functionality: {
+        positionVsParent: uiConfig.positionVsParent || "atEquipment", // Default to 'atEquipment' if not set
+      },
+    };
+    // Utility for formatting outputs
+    this._output = new outputUtils();
+  }
+
+  _updateNodeStatus() {
+    const mg = this.source;
+    const mode = mg.mode;
+    const scaling = mg.scaling;
+    const totalFlow =
+      Math.round(
+        mg.measurements
+          .type("flow")
+          .variant("predicted")
+          .position("downstream")
+          .getCurrentValue() * 1
+      ) / 1;
+    const totalPower =
+      Math.round(
+        mg.measurements
+          .type("power")
+          .variant("predicted")
+          .position("upstream")
+          .getCurrentValue() * 1
+      ) / 1;
+
+    // Calculate total capacity based on available machines
+    const availableMachines = Object.values(mg.machines).filter((machine) => {
+      const state = machine.state.getCurrentState();
+      const mode = machine.currentMode;
+      return !(
+        state === "off" ||
+        state === "maintenance" ||
+        mode === "maintenance"
+      );
+    });
+
+    const totalCapacity = Math.round(mg.dynamicTotals.flow.max * 1) / 1;
+
+    // Determine overall status based on available machines
+    const status =
+      availableMachines.length > 0
+        ? `${availableMachines.length} machines`
+        : "No machines";
+
+    let scalingSymbol = "";
+    switch (scaling.toLowerCase()) {
+      case "absolute":
+        scalingSymbol = "Ⓐ"; // Clear symbol for Absolute mode
+        break;
+      case "normalized":
+        scalingSymbol = "Ⓝ"; // Clear symbol for Normalized mode
+        break;
+      default:
+        scalingSymbol = mode;
+        break;
+    }
+
+    // Generate status text in a single line
+    const text = ` ${mode} | ${scalingSymbol}: 💨=${totalFlow}/${totalCapacity} | ⚡=${totalPower} | ${status}`;
+
+    return {
+      fill: availableMachines.length > 0 ? "green" : "red",
+      shape: "dot",
+      text,
+    };
+  }
+
+  /**
+   * Instantiate the core logic and store as source.
+   */
+  _setupSpecificClass() {
+    this.source = new Specific(this.config);
+    this.node.source = this.source; // Store the source in the node instance for easy access
+  }
+
+  /**
+   * Bind events to Node-RED status updates. Using internal emitter. --> REMOVE LATER WE NEED ONLY COMPLETE CHILDS AND THEN CHECK FOR UPDATES
+   */
+  _bindEvents() {
+    this.source.emitter.on("mAbs", (val) => {
+      this.node.status({
+        fill: "green",
+        shape: "dot",
+        text: `${val} ${this.config.general.unit}`,
+      });
+    });
+  }
+
+  /**
+   * Register this node as a child upstream and downstream.
+   * Delayed to avoid Node-RED startup race conditions.
+   */
+  _registerChild() {
+    setTimeout(() => {
+      this.node.send([
+        null,
+        null,
+        {
+          topic: "registerChild",
+          payload: this.node.id,
+          positionVsParent:
+            this.config?.functionality?.positionVsParent || "atEquipment",
+        },
+      ]);
+    }, 100);
+  }
+
+  /**
+   * Start the periodic tick loop to drive the Measurement class.
+   */
+  _startTickLoop() {
+    setTimeout(() => {
+      this._tickInterval = setInterval(() => this._tick(), 1000);
+       // Update node status on nodered screen every second ( this is not the best way to do this, but it works for now)
+      this._statusInterval = setInterval(() => {
+        const status = this._updateNodeStatus();
+        this.node.status(status);
+      }, 1000);
+    }, 1000);
+  }
+
+  /**
+   * Execute a single tick: update measurement, format and send outputs.
+   */
+  _tick() {
+    const raw = this.source.getOutput();
+    const processMsg = this._output.formatMsg(raw, this.config, "process");
+    const influxMsg = this._output.formatMsg(raw, this.config, "influxdb");
+
+    // Send only updated outputs on ports 0 & 1
+    this.node.send([processMsg, influxMsg]);
+  }
+
+  /**
+   * Attach the node's input handler, routing control messages to the class.
+   */
+  _attachInputHandler() {
+    this.node.on(
+      "input",
+      (msg, send, done) =>
+        async function () {
+          switch (msg.topic) {
+            case "registerChild":
+              const childId = msg.payload;
+              const childObj = RED.nodes.getNode(childId);
+              mg.childRegistrationUtils.registerChild(
+                childObj.source,
+                msg.positionVsParent
+              );
+              break;
+
+            case "setMode":
+              const mode = msg.payload;
+              const source = "parent";
+              mg.setMode(source, mode);
+              break;
+
+            case "setScaling":
+              const scaling = msg.payload;
+              mg.setScaling(scaling);
+              break;
+
+            case "Qd":
+              const Qd = parseFloat(msg.payload);
+              const sourceQd = "parent";
+
+              if (isNaN(Qd)) {
+                return mg.logger.error(`Invalid demand value: ${Qd}`);
+              }
+
+              try {
+                await mg.handleInput(sourceQd, Qd);
+                msg.topic = mg.config.general.name;
+                msg.payload = "done";
+                send(msg);
+              } catch (e) {
+                console.log(e);
+              }
+              break;
+
+            default:
+              // Handle unknown topics if needed
+              break;
+          }
+          done();
+        }
+    );
+  }
+
+  /**
+   * Clean up timers and intervals when Node-RED stops the node.
+   */
+  _attachCloseHandler() {
+    this.node.on("close", (done) => {
+      clearInterval(this._tickInterval);
+      done();
+    });
+  }
+}
+
+module.exports = nodeClass; // Export the class for Node-RED to use
diff --git a/src/specificClass.js b/src/specificClass.js
new file mode 100644
index 0000000..e501a8b
--- /dev/null
+++ b/src/specificClass.js
@@ -0,0 +1,1048 @@
+/**
+ * @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 machineGroup
+ * @exports machineGroup
+ * @version 0.1.0
+ * @since 0.1.0
+ * 
+ * Author:
+ * - Rene De Ren
+ * Email:
+ * - r.de.ren@brabantsedelta.nl
+ */
+
+//load local dependencies
+const EventEmitter = require("events");
+const {logger,configUtils,configManager, MeasurementContainer, interpolation , childRegistrationUtils} = require('generalFunctions');
+
+class MachineGroup {
+    constructor(machineGroupConfig = {}) {
+
+        this.emitter = new EventEmitter();  // Own EventEmitter
+        this.configManager = new configManager();  // Config manager to handle dynamic config loading
+        this.defaultConfig = this.configManager.getConfig('machineGroupControl'); // Load default config for rotating machine ( use software type name ? )
+        this.configUtils = new configUtils(this.defaultConfig);// this will handle the config endpoints so we can load them dynamically
+        this.config = this.configUtils.initConfig(machineGroupConfig); // verify and set the config for the machine group
+
+        // Init after config is set
+        this.logger = new logger(this.config.general.logging.enabled,this.config.general.logging.logLevel, this.config.general.name);
+        
+        // Initialize measurements
+        this.measurements = new MeasurementContainer();
+        this.interpolation = new interpolation();
+
+        // Machines and children data
+        this.machines = {};
+        this.child = {};
+        this.scaling = this.config.scaling.current;
+        this.mode = this.config.mode.current;
+        this.absDistFromPeak = 0 ;
+        this.relDistFromPeak = 0;
+
+        // Combination curve data
+        this.dynamicTotals = { flow: { min: Infinity, max: 0 }, power: { min: Infinity, max: 0 } , NCog : 0};
+        this.absoluteTotals = { flow: { min: Infinity, max: 0 }, power: { min: Infinity, max: 0 }};
+        //this always last in the constructor
+        this.childRegistrationUtils = new childRegistrationUtils(this);
+
+        this.logger.info("MachineGroup initialized.");
+
+    }
+
+    // when a child gets updated do something
+    handleChildChange() {
+        this.absoluteTotals = this.calcAbsoluteTotals();
+        //for reference and not to recalc these values continiously
+        this.dynamicTotals = this.calcDynamicTotals();
+    }
+
+    calcAbsoluteTotals() {
+
+        const absoluteTotals = { flow: { min: Infinity, max: 0 }, power: { min: Infinity, max: 0 } };
+        
+        Object.values(this.machines).forEach(machine => {
+            const totals = { flow: { min: Infinity, max: 0 }, power: { min: Infinity, max: 0 } };
+            //fetch min flow ever seen over all machines
+            Object.entries(machine.predictFlow.inputCurve).forEach(([pressure, xyCurve], index) => {
+                const minFlow = Math.min(...xyCurve.y);
+                const maxFlow = Math.max(...xyCurve.y);
+
+                const minPower = Math.min(...machine.predictPower.inputCurve[pressure].y);
+                const maxPower = Math.max(...machine.predictPower.inputCurve[pressure].y);
+
+                // min ever seen for 1 machine
+                if (minFlow < totals.flow.min) { totals.flow.min = minFlow; }
+                if (minPower < totals.power.min) { totals.power.min = minPower; }
+                if( maxFlow > totals.flow.max ){ totals.flow.max = maxFlow; }
+                if( maxPower > totals.power.max ){ totals.power.max = maxPower; }
+
+            });
+            //surplus machines for max flow and power
+            if( totals.flow.min < absoluteTotals.flow.min ){ absoluteTotals.flow.min = totals.flow.min; }
+            if( totals.power.min < absoluteTotals.power.min ){ absoluteTotals.power.min = totals.power.min; }
+            absoluteTotals.flow.max += totals.flow.max;
+            absoluteTotals.power.max += totals.power.max;
+            
+        });
+
+        return absoluteTotals;
+
+    }
+
+    //max and min current flow and power based on their actual pressure curve 
+    calcDynamicTotals() {
+
+        const dynamicTotals = { flow: { min: Infinity, max: 0 }, power: { min: Infinity, max: 0 }, NCog : 0 };
+
+        Object.values(this.machines).forEach(machine => {
+            //fetch min flow ever seen over all machines
+            const minFlow = machine.predictFlow.currentFxyYMin; 
+            const maxFlow = machine.predictFlow.currentFxyYMax;
+            const minPower = machine.predictPower.currentFxyYMin;
+            const maxPower = machine.predictPower.currentFxyYMax;
+
+            if( minFlow < dynamicTotals.flow.min ){ dynamicTotals.flow.min = minFlow; }
+            if( minPower < dynamicTotals.power.min ){ dynamicTotals.power.min = minPower; }
+
+            dynamicTotals.flow.max += maxFlow;
+            dynamicTotals.power.max += maxPower;
+
+            //fetch total Normalized Cog over all machines
+            dynamicTotals.NCog += machine.NCog;
+            
+        });
+
+        return dynamicTotals;
+    }
+
+    activeTotals() {
+        const totals = { flow: { min: 0, max: 0 }, power: { min: 0, max: 0 }, countActiveMachines: 0 };
+
+        Object.entries(this.machines).forEach(([id, machine]) => {
+            this.logger.debug(`Processing machine with id: ${id}`);
+            if(this.isMachineActive(id)){
+                //fetch min flow ever seen over all machines
+                const minFlow = machine.predictFlow.currentFxyYMin; 
+                const maxFlow = machine.predictFlow.currentFxyYMax;
+                const minPower = machine.predictPower.currentFxyYMin;
+                const maxPower = machine.predictPower.currentFxyYMax;
+
+            
+                totals.flow.min += minFlow;
+                totals.flow.max += maxFlow;
+                totals.power.min += minPower;
+                totals.power.max += maxPower;
+                totals.countActiveMachines++;
+            }
+            
+        });
+
+        return totals;
+    }
+
+    handlePressureChange() {
+        this.logger.info("Pressure change detected.");
+        this.calcDynamicTotals();
+        const { maxEfficiency, lowestEfficiency } = this.calcGroupEfficiency(this.machines);
+        const efficiency = this.measurements.type("efficiency").variant("predicted").position("downstream").getCurrentValue();
+        this.calcDistanceBEP(efficiency,maxEfficiency,lowestEfficiency);
+    }
+
+    calcDistanceFromPeak(currentEfficiency,peakEfficiency){
+        return Math.abs(currentEfficiency - peakEfficiency);
+    }
+
+    calcRelativeDistanceFromPeak(currentEfficiency,maxEfficiency,minEfficiency){
+        let distance = 1;
+        if(currentEfficiency != null){
+          distance = this.interpolation.interpolate_lin_single_point(currentEfficiency,maxEfficiency, minEfficiency, 0, 1);
+        }
+        return distance;
+      }
+
+    calcDistanceBEP(efficiency,maxEfficiency,minEfficiency){
+        const absDistFromPeak = this.calcDistanceFromPeak(efficiency,maxEfficiency);
+        const relDistFromPeak = this.calcRelativeDistanceFromPeak(efficiency,maxEfficiency,minEfficiency);
+    
+        //store internally
+        this.absDistFromPeak = absDistFromPeak ;
+        this.relDistFromPeak = relDistFromPeak;
+    
+        return { absDistFromPeak: absDistFromPeak, relDistFromPeak: relDistFromPeak };
+    }
+
+    checkSpecialCases(machines, Qd) {
+        Object.values(machines).forEach(machine => {
+            const state = machine.state.getCurrentState();
+            const mode = machine.currentMode;
+            
+            //add special cases 
+            if( state === "operational" && ( mode == "virtualControl" || mode === "fysicalControl") ){
+                let flow = 0;
+                if(machine.measurements.type("flow").variant("measured").position("downstream").getCurrentValue()){
+                    flow = machine.measurements.type("flow").variant("measured").position("downstream").getCurrentValue();
+                } 
+                else if(machine.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue()){
+                    flow = machine.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue();
+                }
+                else{
+                    this.logger.error("Dont perform calculation at all seeing that there is a machine working but we dont know the flow its producing");
+                    //abort the calculation
+                    return false;
+                }
+            
+                //Qd is less because we allready have machines delivering flow on manual control
+                Qd = Qd - flow;
+            }
+        });
+        return Qd ;
+    }
+
+    validPumpCombinations(machines, Qd, PowerCap = Infinity) {
+        let subsets = [[]];
+
+        // adjust demand flow when there are machines being controlled by a manual source
+        Qd = this.checkSpecialCases(machines, Qd);
+        
+        // Generate all possible subsets of machines (power set)
+        Object.keys(machines).forEach(machineId => {
+            machineId = parseInt(machineId);
+            
+            const state = machines[machineId].state.getCurrentState();
+            
+            const validSourceForMode = machines[machineId].isValidSourceForMode("parent", "auto");
+            const validActionForMode = machines[machineId].isValidActionForMode("execSequence", "auto");
+            
+
+            // Reasons why a machine is not valid for the combination
+            if( state === "off" || state === "coolingdown" || state === "stopping" || state === "emergencystop" || !validSourceForMode || !validActionForMode){
+                return;
+            }
+            
+            // go through each machine and add it to the subsets
+            let newSubsets = subsets.map(set => [...set, machineId]);
+            subsets = subsets.concat(newSubsets);
+        });
+            
+        // Filter for non-empty subsets that can meet or exceed demand flow
+        const combinations = subsets.filter(subset => {
+            if (subset.length === 0) return false;
+            
+            // Calculate total and minimum flow for the subset in one pass
+            const { maxFlow, minFlow, maxPower } = subset.reduce(
+                (acc, machineId) => {
+                    const machine = machines[machineId];
+                    const minFlow = machine.predictFlow.currentFxyYMin;
+                    const maxFlow = machine.predictFlow.currentFxyYMax;
+                    const maxPower = machine.predictPower.currentFxyYMax;
+
+                    return {
+                        maxFlow: acc.maxFlow + maxFlow,
+                        minFlow: acc.minFlow + minFlow,
+                        maxPower: acc.maxPower + maxPower
+
+                    };
+                }, 
+            { maxFlow: 0, minFlow: 0 , maxPower: 0 }
+        );
+
+            // If total flow can deliver the demand
+            if(maxFlow >= Qd && minFlow <= Qd && maxPower <= PowerCap){
+                return true;
+            }
+            else{
+                return false;
+            }
+        });
+        
+        return combinations;
+    }
+
+    calcBestCombination(combinations, Qd) {
+        let bestCombination = null;
+
+        //keep track of totals
+        let bestPower = Infinity;
+        let bestFlow = 0;
+        let bestCog = 0;
+        
+        combinations.forEach(combination => {
+
+            let flowDistribution = []; // Stores the flow distribution for the best combination
+            let totalCoG = 0;
+            let totalPower = 0;
+            let totalFlow = 0;
+
+            // Calculate the total CoG for the current combination
+            combination.forEach(machineId => { totalCoG += ( Math.round(this.machines[machineId].NCog * 100 ) /100 ) ; });
+
+            // Calculate the total power for the current combination
+            combination.forEach(machineId => {
+                let flow = 0;
+                
+                // Prevent division by zero
+                if (totalCoG === 0) {
+                    // Distribute flow equally among all pumps
+                    flow = Qd / combination.length;
+
+                } else {
+                    // Normal CoG-based distribution
+                    flow = (this.machines[machineId].NCog / totalCoG) * Qd ;
+                    this.logger.debug(`Machine Normalized CoG-based distribution ${machineId} flow: ${flow}`);
+                }
+                totalFlow += flow;
+                totalPower += this.machines[machineId].inputFlowCalcPower(flow);
+                flowDistribution.push({ machineId: machineId,flow: flow });
+            });
+
+            // Update the best combination if the current one is better
+            if (totalPower < bestPower) {
+                this.logger.debug(`New best combination found: ${totalPower} < ${bestPower}`);
+                this.logger.debug(`combination ${JSON.stringify(flowDistribution)}`);
+                bestPower = totalPower;
+                bestFlow = totalFlow;
+                bestCog = totalCoG;
+                bestCombination = flowDistribution;
+            }
+        });
+
+        return { bestCombination, bestPower, bestFlow, bestCog };
+    }
+
+    // -------- Mode and Input Management -------- //
+    isValidSourceForMode(source, mode) {
+        const allowedSourcesSet = this.config.mode.allowedSources[mode] || [];
+        return allowedSourcesSet.has(source);
+    }
+
+    isValidActionForMode(action, mode) {
+        const allowedActionsSet = this.config.mode.allowedActions[mode] || [];
+        return allowedActionsSet.has(action);
+    }
+
+    setScaling(scaling) {
+        const scalingSet = new Set(defaultConfig.scaling.current.rules.values.map( (value) => value.value));
+        scalingSet.has(scaling)? this.scaling = scaling : this.logger.warn(`${scaling} is not a valid scaling option.`);
+    }
+
+    //handle input from parent / user / UI
+    async optimalControl(Qd, powerCap = Infinity) {
+        try{
+            //we need to force the pressures of all machines to be equal to the highest pressure measured in the group
+            // this is to ensure a correct evaluation of the flow and power consumption
+            const pressures = Object.entries(this.machines).map(([machineId, machine]) => {
+                return { 
+                    downstream: machine.measurements.type("pressure").variant("measured").position("downstream").getCurrentValue(),
+                    upstream: machine.measurements.type("pressure").variant("measured").position("upstream").getCurrentValue()
+                };
+            });
+
+            const maxDownstream = Math.max(...pressures.map(p => p.downstream));
+            const minUpstream = Math.min(...pressures.map(p => p.upstream));
+
+            //set the pressures
+            Object.entries(this.machines).forEach(([machineId, machine]) => {
+                if(machine.state.getCurrentState() !== "operational" && machine.state.getCurrentState() !== "accelerating" && machine.state.getCurrentState() !== "decelerating"){
+                    machine.measurements.type("pressure").variant("measured").position("downstream").value(maxDownstream);
+                    machine.measurements.type("pressure").variant("measured").position("upstream").value(minUpstream);
+                    // after updating the measurement directly we need to force the update of the value OLIFANT this is not so clear now in the code
+                    // we need to find a better way to do this but for now it works
+                    machine.getMeasuredPressure();
+                }
+            });
+            
+
+            //update dynamic totals
+            const dynamicTotals = this.calcDynamicTotals();
+            const machineStates = Object.entries(this.machines).reduce((acc, [machineId, machine]) => {
+                acc[machineId] = machine.state.getCurrentState();
+                return acc;
+            }, {});
+
+            if( Qd <= 0 ) {
+                //if Qd is 0 turn all machines off and exit early
+            }
+
+            if( Qd < dynamicTotals.flow.min && Qd > 0 ){
+                //Capping Qd to lowest possible value
+                this.logger.warn(`Flow demand ${Qd} is below minimum possible flow ${dynamicTotals.flow.min}. Capping to minimum flow.`);
+                Qd = dynamicTotals.flow.min;
+            }
+            else if( Qd > dynamicTotals.flow.max ){
+                //Capping Qd to highest possible value
+                this.logger.warn(`Flow demand ${Qd} is above maximum possible flow ${dynamicTotals.flow.max}. Capping to maximum flow.`);
+                Qd = dynamicTotals.flow.max;
+            }
+
+            // fetch all valid combinations that meet expectations
+            const combinations = this.validPumpCombinations(this.machines, Qd, powerCap);
+            // 
+            const bestResult = this.calcBestCombination(combinations, Qd);
+
+            if(bestResult.bestCombination === null){
+                this.logger.warn(`Demand: ${Qd.toFixed(2)} -> No valid combination found => not updating control `);
+                return;
+            }
+            
+            const debugInfo = bestResult.bestCombination.map(({ machineId, flow }) => `${machineId}: ${flow.toFixed(2)} units`).join(" | ");
+            this.logger.debug(`Moving to demand: ${Qd.toFixed(2)} -> Pumps: [${debugInfo}] => Total Power: ${bestResult.bestPower.toFixed(2)}`);
+            
+            //store the total delivered power
+            this.measurements.type("power").variant("predicted").position("upstream").value(bestResult.bestPower);
+            this.measurements.type("flow").variant("predicted").position("downstream").value(bestResult.bestFlow);
+            this.measurements.type("efficiency").variant("predicted").position("downstream").value(bestResult.bestFlow / bestResult.bestPower);
+            this.measurements.type("Ncog").variant("predicted").position("downstream").value(bestResult.bestCog);
+
+            await Promise.all(Object.entries(this.machines).map(async ([machineId, machine]) => {
+
+                    const pumpInfo = bestResult.bestCombination.find(item => item.machineId == machineId);
+                    let flow;
+                    if(pumpInfo !== undefined){
+                        flow = pumpInfo.flow;
+                    } else {
+                        this.logger.debug(`Machine ${machineId} not in best combination, setting flow to 0`);
+                        flow = 0;
+                    }
+ 
+
+                    if( (flow <= 0 ) && ( machineStates[machineId] === "operational" || machineStates[machineId] === "accelerating" || machineStates[machineId] === "decelerating" ) ){
+                        await machine.handleInput("parent", "execSequence", "shutdown");
+                    }
+                    else if(machineStates[machineId] === "idle" && flow > 0){
+                        await machine.handleInput("parent", "execSequence", "startup");
+                    }
+                    else if(machineStates[machineId] === "operational" && flow > 0 ){
+                        await machine.handleInput("parent", "flowMovement", flow);
+                    }
+                    
+            }));
+            
+        }
+        catch(err){
+            this.logger.error(err);
+        }
+    }
+
+    // Equalize pressure across all machines for machines that are not running. This is needed to ensure accurate flow and power predictions.
+    equalizePressure(){
+        // Get current pressures from all machines
+        const pressures = Object.entries(this.machines).map(([machineId, machine]) => {
+            return { 
+                downstream: machine.measurements.type("pressure").variant("measured").position("downstream").getCurrentValue(),
+                upstream: machine.measurements.type("pressure").variant("measured").position("upstream").getCurrentValue()
+            };
+        });
+    
+        // Find the highest downstream and lowest upstream pressure
+        const maxDownstream = Math.max(...pressures.map(p => p.downstream));
+        const minUpstream = Math.min(...pressures.map(p => p.upstream));
+    
+        // Set consistent pressures across machines
+        Object.entries(this.machines).forEach(([machineId, machine]) => {
+            if(!this.isMachineActive(machineId)){
+                machine.measurements.type("pressure").variant("measured").position("downstream").value(maxDownstream);
+                machine.measurements.type("pressure").variant("measured").position("upstream").value(minUpstream);
+                // Update the measured pressure value
+                const pressure = machine.getMeasuredPressure();
+                this.logger.debug(`Setting pressure for machine ${machineId} to ${pressure}`);
+            }
+        });
+    }
+
+    isMachineActive(machineId){
+        if(this.machines[machineId].state.getCurrentState() === "operational" || this.machines[machineId].state.getCurrentState() === "accelerating" || this.machines[machineId].state.getCurrentState() === "decelerating"){
+            return true;
+        }
+        return false;
+    }
+
+    capFlowDemand(Qd,dynamicTotals){
+
+        if (Qd < dynamicTotals.flow.min && Qd > 0) {
+            this.logger.warn(`Flow demand ${Qd} is below minimum possible flow ${dynamicTotals.flow.min}. Capping to minimum flow.`);
+            Qd = dynamicTotals.flow.min;
+        } else if (Qd > dynamicTotals.flow.max) {
+            this.logger.warn(`Flow demand ${Qd} is above maximum possible flow ${dynamicTotals.flow.max}. Capping to maximum flow.`);
+            Qd = dynamicTotals.flow.max;
+        }
+
+        return Qd;
+    }
+
+    sortMachinesByPriority(priorityList) {
+        let machinesInPriorityOrder;
+
+        if (priorityList && Array.isArray(priorityList)) {
+            machinesInPriorityOrder = priorityList
+                .filter(id => this.machines[id])
+                .map(id => ({ id, machine: this.machines[id] }));
+        } else {
+            machinesInPriorityOrder = Object.entries(this.machines)
+                .map(([id, machine]) => ({ id: parseInt(id), machine }))
+                .sort((a, b) => a.id - b.id);
+        }
+        return machinesInPriorityOrder;
+    }
+
+    filterOutUnavailableMachines(list) {
+        const newList = list.filter(({ id, machine }) => {
+            const state = machine.state.getCurrentState();
+            const validSourceForMode = machine.isValidSourceForMode("parent", "auto");
+            const validActionForMode = machine.isValidActionForMode("execSequence", "auto");
+            
+            return !(state === "off" || state === "coolingdown" || state === "stopping" || state === "emergencystop" || !validSourceForMode || !validActionForMode); 
+        });
+        return newList;
+    }
+
+    calcGroupEfficiency(machines){
+        let cumEfficiency = 0;
+        let machineCount = 0;
+        let lowestEfficiency = Infinity;
+
+        // Calculate the average efficiency of all machines -> peak is the average of them all
+        Object.entries(machines).forEach(([machineId, machine]) => {
+            cumEfficiency += machine.cog;
+            if(machine.cog < lowestEfficiency){
+                lowestEfficiency = machine.cog;
+            }
+            machineCount++;
+        });
+
+        const maxEfficiency = cumEfficiency / machineCount;
+
+        return { maxEfficiency, lowestEfficiency };
+
+    }
+    
+    //move machines assuming equal control in flow and a priority list
+    async equalFlowControl(Qd, powerCap = Infinity, priorityList = null) {
+        try {
+
+            // equalize pressure across all machines
+            this.equalizePressure();
+
+            // Update dynamic totals
+            const dynamicTotals = this.calcDynamicTotals();
+
+            // Handle zero demand by shutting down all machines early exit
+            if (Qd <= 0) {
+                await Promise.all(Object.entries(this.machines).map(async ([machineId, machine]) => {
+                    if (this.isMachineActive(machineId)) { await machine.handleInput("parent", "execSequence", "shutdown"); }
+                }));
+                return;
+            }
+
+            // Cap flow demand to min/max possible values
+            Qd = this.capFlowDemand(Qd,dynamicTotals);
+
+            // Get machines sorted by priority
+            let machinesInPriorityOrder = this.sortMachinesByPriority(priorityList);
+
+            // Filter out machines that are unavailable for control
+            machinesInPriorityOrder = this.filterOutUnavailableMachines(machinesInPriorityOrder);
+
+            // Initialize flow distribution
+            let flowDistribution = [];
+            let totalFlow = 0;
+            let totalPower = 0;
+            let totalCog = 0;
+
+            const activeTotals = this.activeTotals();
+
+            // Distribute flow equally among all available machines
+            switch (true) {
+                case (Qd < activeTotals.flow.min && activeTotals.flow.min !== 0):{
+                    let availableFlow = activeTotals.flow.min;
+                    for (let i = machinesInPriorityOrder.length - 1; i >= 0 && availableFlow > Qd; i--) {
+                        const machine = machinesInPriorityOrder[i];
+                        if (this.isMachineActive(machine.id)) {
+                            flowDistribution.push({ machineId: machine.id, flow: 0 });
+                            availableFlow -= machine.machine.predictFlow.currentFxyYMin;
+                        }
+                    }
+    
+                    // Determine remaining active machines (not shut down).
+                    const remainingMachines = machinesInPriorityOrder.filter(
+                        ({ id }) =>
+                            this.isMachineActive(id) &&
+                            !flowDistribution.some(item => item.machineId === id)
+                    );
+    
+                    // Evenly distribute Qd among the remaining machines.
+                    const distributedFlow = Qd / remainingMachines.length;
+                    for (let machine of remainingMachines) {
+                        flowDistribution.push({ machineId: machine.id, flow: distributedFlow });
+                        totalFlow += distributedFlow;
+                        totalPower += machine.machine.inputFlowCalcPower(distributedFlow);
+                    }
+                    break;
+                }
+                
+                case (Qd > activeTotals.flow.max): 
+                    // Case 2: Demand is above the maximum available flow.
+                    // Start the non-active machine with the highest priority and distribute Qd over all available machines.
+                    let i = 1;
+                    while (totalFlow < Qd && i <= machinesInPriorityOrder.length) {
+                        Qd = Qd / i;
+                        
+                        if(machinesInPriorityOrder[i-1].machine.predictFlow.currentFxyYMax >= Qd){
+                            for ( let i2 = 0; i2 < i ; i2++){
+                                if(! this.isMachineActive(machinesInPriorityOrder[i2].id)){
+                                    flowDistribution.push({ machineId: machinesInPriorityOrder[i2].id, flow: Qd });
+                                    totalFlow += Qd;
+                                    totalPower += machinesInPriorityOrder[i2].machine.inputFlowCalcPower(Qd);
+                                }
+                            }
+                        }
+                        i++;
+                    }
+                    
+                    break;
+
+                
+                default: 
+                // Default case: Demand is within the active range.
+                const countActiveMachines = machinesInPriorityOrder.filter(({ id }) => this.isMachineActive(id)).length;
+
+                Qd /= countActiveMachines;
+                // Simply distribute the demand equally among all available machines.
+                for ( let i = 0 ; i < countActiveMachines ; i++){
+                    
+                    flowDistribution.push({ machineId: machinesInPriorityOrder[i].id, flow: Qd});
+                    totalFlow += Qd ;
+                    totalPower += machinesInPriorityOrder[i].machine.inputFlowCalcPower(Qd);
+
+                }
+                break;
+            }
+  
+            // Log information about flow distribution
+            const debugInfo = flowDistribution
+                .filter(({ flow }) => flow > 0)
+                .map(({ machineId, flow }) => `${machineId}: ${flow.toFixed(2)} units`)
+                .join(" | ");
+            
+            this.logger.debug(`Priority control for demand: ${totalFlow.toFixed(2)} -> Active pumps: [${debugInfo}] => Total Power: ${totalPower.toFixed(2)}`);
+            
+            // Store measurements
+            this.measurements.type("power").variant("predicted").position("upstream").value(totalPower);
+            this.measurements.type("flow").variant("predicted").position("downstream").value(totalFlow);
+            this.measurements.type("efficiency").variant("predicted").position("downstream").value(totalFlow / totalPower);
+            this.measurements.type("Ncog").variant("predicted").position("downstream").value(totalCog);
+
+            // Apply the flow distribution to machines
+            await Promise.all(flowDistribution.map(async ({ machineId, flow }) => {
+                const machine = this.machines[machineId];
+                const currentState = this.machines[machineId].state.getCurrentState();
+
+                if (flow <= 0 && (currentState === "operational" || currentState === "accelerating" || currentState === "decelerating")) {
+                    await machine.handleInput("parent", "execSequence", "shutdown");
+                }
+                else if (currentState === "idle" && flow > 0) {
+                    await machine.handleInput("parent", "execSequence", "startup");
+                }
+                else if (currentState === "operational" && flow > 0) {
+                    await machine.handleInput("parent", "flowMovement", flow);
+                }
+            }));
+        }
+        catch (err) {
+            this.logger.error(err);
+        }
+    }
+
+    //only valid with equal machines
+    async prioPercentageControl(input, priorityList = null) {
+        try{
+            // stop all machines if input is negative
+            if(input < 0 ){
+                //turn all machines off
+                await Promise.all(Object.entries(this.machines).map(async ([machineId, machine]) => {
+                    if (this.isMachineActive(machineId)) { await machine.handleInput("parent", "execSequence", "shutdown"); }
+                }));
+                return;
+            }
+
+            //capp input to 100
+            input > 100 ? input = 100 : input = input;
+
+            const numOfMachines = Object.keys(this.machines).length;
+            const procentTotal = numOfMachines * input;
+            const machinesNeeded = Math.ceil(procentTotal/100);
+            const activeTotals = this.activeTotals();
+            const machinesActive = activeTotals.countActiveMachines;
+            // Get machines sorted by priority
+            let machinesInPriorityOrder = this.sortMachinesByPriority(priorityList);
+            const ctrlDistribution = []; //{machineId : 0, flow : 0} push for each machine
+
+            if(machinesNeeded > machinesActive){
+    
+                //start extra machine and put all active machines at min control
+                machinesInPriorityOrder.forEach(({ id, machine }, index) => {
+                    if(index < machinesNeeded){
+                            ctrlDistribution.push({machineId : id, ctrl : 0});
+                    }
+                });
+            }
+
+            if(machinesNeeded < machinesActive){
+    
+                machinesInPriorityOrder.forEach(({ id, machine }, index) => {
+                    if(this.isMachineActive(id)){
+                        if(index < machinesNeeded){
+                            ctrlDistribution.push({machineId : id, ctrl : 100});
+                        }
+                        else{
+                            //turn machine off
+                            ctrlDistribution.push({machineId : id, ctrl : -1});
+                        }
+                    }
+                });
+            }
+
+            if (machinesNeeded === machinesActive) {
+                // distribute input equally among active machines (0 - 100%)
+                const ctrlPerMachine = procentTotal / machinesActive;
+            
+                machinesInPriorityOrder.forEach(({ id, machine }) => {
+                    if (this.isMachineActive(id)) {
+                        // ensure ctrl is capped between 0 and 100%
+                        const ctrlValue = Math.max(0, Math.min(ctrlPerMachine, 100));  
+                        ctrlDistribution.push({ machineId: id, ctrl: ctrlValue });
+                    }
+                });
+            }
+
+            const debugInfo = ctrlDistribution.map(({ machineId, ctrl }) => `${machineId}: ${ctrl.toFixed(2)}%`).join(" | ");
+            this.logger.debug(`Priority control for input: ${input.toFixed(2)} -> Active pumps: [${debugInfo}]`);
+
+             // Apply the ctrl distribution to machines
+             await Promise.all(ctrlDistribution.map(async ({ machineId, ctrl }) => {
+                const machine = this.machines[machineId];
+                const currentState = this.machines[machineId].state.getCurrentState();
+
+                if (ctrl < 0 && (currentState === "operational" || currentState === "accelerating" || currentState === "decelerating")) {
+                    await machine.handleInput("parent", "execSequence", "shutdown");
+                }
+                else if (currentState === "idle" && ctrl >= 0) {
+                    await machine.handleInput("parent", "execSequence", "startup");
+                }
+                else if (currentState === "operational" && ctrl > 0) {
+                    await machine.handleInput("parent", "execMovement", ctrl);
+                }
+            }));
+
+            const totalPower = [];
+            const totalFlow = [];
+
+            // fetch and store measurements
+            Object.entries(this.machines).forEach(([machineId, machine]) => {
+                const powerValue = machine.measurements.type("power").variant("predicted").position("upstream").getCurrentValue();
+                const flowValue = machine.measurements.type("flow").variant("predicted").position("downstream").getCurrentValue();
+                if (powerValue !== null) {
+                    totalPower.push(powerValue);
+                }
+                if (flowValue !== null) {
+                    totalFlow.push(flowValue);
+                }
+            });
+
+            this.measurements.type("power").variant("predicted").position("upstream").value(totalPower.reduce((a, b) => a + b, 0));
+            this.measurements.type("flow").variant("predicted").position("downstream").value(totalFlow.reduce((a, b) => a + b, 0));
+            if(totalPower.reduce((a, b) => a + b, 0) > 0){
+                this.measurements.type("efficiency").variant("predicted").position("downstream").value(totalFlow.reduce((a, b) => a + b, 0) / totalPower.reduce((a, b) => a + b, 0));
+            }
+
+        }
+        catch(err){
+            this.logger.error(err);
+        }
+    }
+    
+    async handleInput(source, Qd, powerCap = Infinity, priorityList = null) {
+
+        
+        if (!this.isValidSourceForMode(source, this.mode)) {
+            this.logger.warn(`Invalid source ${source} for mode ${this.mode}`);
+            return;
+        }
+
+        const scaling = this.scaling;
+        const mode = this.mode;
+        let rawInput = Qd;
+
+        switch (scaling) {
+            case "absolute":
+                // No scaling needed but cap range
+                if (Qd < this.absoluteTotals.flow.min) {
+                    this.logger.warn(`Flow demand ${Qd} is below minimum possible flow ${this.absoluteTotals.flow.min}. Capping to minimum flow.`);
+                    Qd = this.absoluteTotals.flow.min;
+                } else if (Qd > this.absoluteTotals.flow.max) {
+                    this.logger.warn(`Flow demand ${Qd} is above maximum possible flow ${this.absoluteTotals.flow.max}. Capping to maximum flow.`);
+                    Qd = this.absoluteTotals.flow.max;
+                }
+                break;
+
+            case "normalized":
+                // Scale demand to 0-100% linear between min and max flow this is auto capped
+                Qd = this.interpolation.interpolate_lin_single_point(Qd, 0, 100, this.dynamicTotals.flow.min, this.dynamicTotals.flow.max);
+                break;
+        }
+
+        switch(mode) {
+            case "prioritycontrol":
+                await this.equalFlowControl(Qd,powerCap,priorityList);
+                break;
+            case "prioritypercentagecontrol":
+                if(scaling !== "normalized"){
+                    this.logger.warn("Priority percentage control is only valid with normalized scaling.");
+                    return;
+                }
+                await this.prioPercentageControl(rawInput,priorityList);     
+                break;
+            case "optimalcontrol":
+                await this.optimalControl(Qd,powerCap);
+                break;
+        }
+
+        //recalc distance from BEP
+        const { maxEfficiency, lowestEfficiency } = this.calcGroupEfficiency(this.machines);
+        const efficiency = this.measurements.type("efficiency").variant("predicted").position("downstream").getCurrentValue();
+        this.calcDistanceBEP(efficiency,maxEfficiency,lowestEfficiency);
+
+    }
+
+    setMode(source,mode) {
+        this.isValidSourceForMode(source, mode) ? this.mode = mode : this.logger.warn(`Invalid source ${source} for mode ${mode}`);
+    }
+
+    getOutput() {
+
+        // Improved output object generation
+        const output = {};
+
+        //build the output object
+        this.measurements.getTypes().forEach(type => {
+          this.measurements.getVariants(type).forEach(variant => {
+    
+            const downstreamVal = this.measurements.type(type).variant(variant).position("downstream").getCurrentValue();
+            const upstreamVal = this.measurements.type(type).variant(variant).position("upstream").getCurrentValue();
+    
+            if (downstreamVal != null) {
+              output[`downstream_${variant}_${type}`] = downstreamVal;
+            }
+            if (upstreamVal != null) {
+              output[`upstream_${variant}_${type}`] = upstreamVal;
+            }
+            if (downstreamVal != null && upstreamVal != null) {
+              const diffVal = this.measurements.type(type).variant(variant).difference().value;
+              output[`differential_${variant}_${type}`] = diffVal;
+            }
+          });
+        });
+    
+        //fill in the rest of the output object
+        output["mode"] = this.mode;
+        output["scaling"] = this.scaling;
+        output["flow"] = this.flow;
+        output["power"] = this.power;
+        output["NCog"] = this.NCog; // normalized cog
+        output["absDistFromPeak"] = this.absDistFromPeak;
+        output["relDistFromPeak"] = this.relDistFromPeak;
+        //this.logger.debug(`Output: ${JSON.stringify(output)}`);
+    
+        return output;
+    }
+                                        
+}
+
+module.exports = MachineGroup;
+
+/*
+const Machine = require('../../../rotatingMachine/dependencies/machine/machine');
+const Measurement = require('../../../measurement/dependencies/measurement/measurement');
+const specs = require('../../../generalFunctions/datasets/assetData/pumps/hydrostal/centrifugal pumps/models.json');
+const power = require("../../../convert/dependencies/definitions/power");
+const { machine } = require("os");
+
+function createBaseMachineConfig(name,specs) {
+    return {
+        general: { 
+            logging: { enabled: true, logLevel: "warn" }, 
+            name: name,
+            unit: "m3/h"
+        },
+        functionality: {
+            softwareType: "machine",
+            role: "RotationalDeviceController"
+        },
+        asset: {
+            type: "pump",
+            subType: "Centrifugal",
+            model: "TestModel",
+            supplier: "Hydrostal",
+            machineCurve: specs[0].machineCurve
+        },
+        mode: {
+            current: "auto",
+            allowedActions: {
+                auto: ["execSequence", "execMovement", "statusCheck"],
+                virtualControl: ["execMovement", "statusCheck"],
+                fysicalControl: ["statusCheck"]
+            },
+            allowedSources: {
+                auto: ["parent", "GUI"],
+                virtualControl: ["GUI"],
+                fysicalControl: ["fysical"]
+            }
+        },
+        sequences: {
+            startup: ["starting", "warmingup", "operational"],
+            shutdown: ["stopping", "coolingdown", "idle"],
+            emergencystop: ["emergencystop", "off"],
+            boot: ["idle", "starting", "warmingup", "operational"]
+        }
+    };
+}
+
+function createBaseMachineGroupConfig(name) {
+    return {
+        general: { 
+            logging: { enabled: true, logLevel: "debug" }, 
+            name: name
+        },
+        functionality: {
+            softwareType: "machineGroup",
+            role: "GroupController"
+        },
+        scaling: {
+            current: "normalized"
+        },
+        mode: {
+            current: "optimalControl"
+        }
+    };
+}
+
+const machineGroupConfig = createBaseMachineGroupConfig("TestMachineGroup");
+const machineConfig = createBaseMachineConfig("TestMachine",specs);
+const ptConfig = {
+    general: {
+        logging: { enabled: true, logLevel: "debug" },
+        name: "TestPT",
+        unit: "mbar",
+    },
+    functionality: {
+        softwareType: "measurement",
+        role: "Sensor"
+    },
+    asset: {
+        type: "sensor",
+        subType: "pressure",
+        model: "TestModel",
+        supplier: "vega"
+    },
+    scaling:{
+        absMin:0,
+        absMax: 4000,
+    }
+}
+
+async function makeMachines(){
+    const mg = new MachineGroup(machineGroupConfig);
+    const pt1 = new Measurement(ptConfig);
+    const numofMachines = 2;
+        for(let i = 0; i < numofMachines; i++){
+            const machine = new Machine(machineConfig);
+            //mg.machines[i] = machine;
+            mg.childRegistrationUtils.registerChild(machine, "downstream");
+        }
+        mg.machines[1].childRegistrationUtils.registerChild(pt1, "downstream");
+        mg.machines[2].childRegistrationUtils.registerChild(pt1, "downstream");
+
+        mg.setMode("parent","prioritycontrol");
+        mg.setScaling("normalized");
+
+        const absMax = mg.dynamicTotals.flow.max;
+        const absMin = mg.dynamicTotals.flow.min;
+        const percMin = 0;
+        const percMax = 100;
+
+        try{
+            /*
+            for(let demand = mg.dynamicTotals.flow.min ; demand <= mg.dynamicTotals.flow.max ; demand += 2){
+                //set pressure
+                
+                console.log("------------------------------------");
+                await mg.handleInput("parent",demand);
+                pt1.calculateInput(1400);
+                console.log("Waiting for 0.2 sec ");
+                //await new Promise(resolve => setTimeout(resolve, 200));
+                console.log("------------------------------------");
+                
+            }
+            
+            for(let demand = 240  ; demand >= mg.dynamicTotals.flow.min ; demand -= 40){
+                //set pressure
+                
+                console.log("------------------------------------");
+
+                await mg.handleInput("parent",demand);
+                pt1.calculateInput(1400);
+                console.log("Waiting for 0.2 sec ");
+                //await new Promise(resolve => setTimeout(resolve, 200));
+                console.log("------------------------------------");
+                
+            }
+                
+*//*
+            for(let demand = 0  ; demand <= 100 ; demand += 1){
+                //set pressure
+                
+                console.log("------------------------------------");
+
+                await mg.handleInput("parent",demand);
+                pt1.calculateInput(1400);
+                console.log("Waiting for 0.2 sec ");
+                //await new Promise(resolve => setTimeout(resolve, 200));
+                console.log("------------------------------------");
+                
+            }
+        }
+        catch(err){
+            console.log(err);
+        }
+
+
+    
+}
+
+
+makeMachines();
+//*/