physics detached from nodes and network.

lib/network/Network.js

@@ -161,7 +161,10 @@ function Network (container, data, options) {
         nodeDistance: 150,
         damping: 0.09
       },
-      model:'BarnesHut'
+      model:'BarnesHut',
+      timestep: 0.5,
+      maxVelocity:  50,
+      minVelocity:  0.1   // px/s
     },
     navigation: {
       enabled: false
@@ -189,8 +192,8 @@ function Network (container, data, options) {
       type: "continuous",
       roundness: 0.5
     },
-    maxVelocity:  50,
-    minVelocity:  0.1,   // px/s
+    maxVelocity:  50,                     // ---------------- MOVED TO PHYSICS ----------------------- //
+    minVelocity:  0.1,   // px/s          // ---------------- MOVED TO PHYSICS ----------------------- //
     stabilize: true,  // stabilize before displaying the network
     stabilizationIterations: 1000,  // maximum number of iteration to stabilize
     stabilizationStepsize: 100,
@@ -233,7 +236,8 @@ function Network (container, data, options) {
     },
     functions:{
       createNode: this._createNode.bind(this),
-      createEdge: this._createEdge.bind(this)
+      createEdge: this._createEdge.bind(this),
+      getScale: function() {return this.scale;}.bind(this)
     },
     emitter: {
       on: this.on.bind(this),
@@ -287,7 +291,6 @@ function Network (container, data, options) {
   // create a frame and canvas
   this._create();
   // load the cluster system.   (mandatory, even when not using the cluster system, there are function calls to it)
-  this._loadClusterSystem();
   // load the selection system. (mandatory, required by Network)
   this._loadSelectionSystem();
   // load the selection system. (mandatory, required by Network)
@@ -2315,68 +2318,6 @@ Network.prototype._restoreFrozenNodes = function() {
 };
 
 
-/**
- * Check if any of the nodes is still moving
- * @param {number} vmin   the minimum velocity considered as 'moving'
- * @return {boolean}      true if moving, false if non of the nodes is moving
- * @private
- */
-Network.prototype._isMoving = function(nodes, nodeIndices, vmin) {
-  for (let i = 0; i < nodeIndices.length; i++) {
-    let node = nodes[nodeIndices[i]];
-    if (node.isMoving(vmin) == true) {
-      return true;
-    }
-  }
-  return false;
-};
-
-
-/**
- * /**
- * Perform one discrete step for all nodes
- *
- * @private
- */
-Network.prototype._discreteStepNodes = function(nodes, nodeIndices) {
-  var interval = this.physicsDiscreteStepsize;
-  var nodesPresent = false;
-
-  if (this.constants.maxVelocity > 0) {
-    for (let i = 0; i < nodeIndices.length; i++) {
-      let node = nodes[nodeIndices[i]];
-      node.discreteStepLimited(interval, this.constants.maxVelocity);
-      nodesPresent = true;
-    }
-  }
-  else {
-    for (let i = 0; i < nodeIndices.length; i++) {
-      let node = nodes[nodeIndices[i]];
-      node.discreteStep(interval);
-      nodesPresent = true;
-    }
-  }
-
-
-  if (nodesPresent == true) {
-    var vminCorrected = this.constants.minVelocity / Math.max(this.scale,0.05);
-    if (vminCorrected > 0.5*this.constants.maxVelocity) {
-      return true;
-    }
-    else {
-      return this._isMoving(nodes, nodeIndices, vminCorrected);
-    }
-  }
-  return false;
-};
-
-
-Network.prototype._revertPhysicsTick = function(nodes, nodeIndices) {
-  for (let i = 0; i < nodeIndices.length; i++) {
-    nodes[nodeIndices[i]].revertPosition();
-  }
-}
-
 /**
  * A single simulation step (or "tick") in the physics simulation
  *
@@ -2385,16 +2326,14 @@ Network.prototype._revertPhysicsTick = function(nodes, nodeIndices) {
 Network.prototype._physicsTick = function() {
   if (!this.freezeSimulationEnabled) {
     if (this.moving == true) {
-      this.physics.step();
 
-      var mainMovingStatus = this._discreteStepNodes(this.body.nodes, this.body.nodeIndices);
-      var supportMovingStatus = this._discreteStepNodes(this.body.supportNodes, this.body.supportNodeIndices);
+      this.physics.calculateForces();
+
+      this.moving = this.physics.moveNodes()
 
       // determine if the network has stabilzied
-      this.moving = mainMovingStatus || supportMovingStatus;
       if (this.moving == false) {
-        this._revertPhysicsTick(this.body.nodes, this.body.nodeIndices);
-        this._revertPhysicsTick(this.body.supportNodes, this.body.supportNodeIndices);
+        this.physics.revert();
       }
       else {
         // this is here to ensure that there is no start event when the network is already stable.

lib/network/Node.js

@@ -79,17 +79,6 @@ function Node(properties, imagelist, grouplist, networkConstants) {
 }
 
 
-/**
- *  Revert the position and velocity of the previous step.
- */
-Node.prototype.revertPosition = function() {
-  this.x = this.previousState.x;
-  this.y = this.previousState.y;
-  this.vx = this.previousState.vx;
-  this.vy = this.previousState.vy;
-}
-
-
 /**
  * Attach a edge to the node
  * @param {Edge} edge
@@ -304,99 +293,6 @@ Node.prototype.distanceToBorder = function (ctx, angle) {
   // TODO: implement calculation of distance to border for all shapes
 };
 
-/**
- * Set forces acting on the node
- * @param {number} fx   Force in horizontal direction
- * @param {number} fy   Force in vertical direction
- */
-Node.prototype._setForce = function(fx, fy) {
-  this.fx = fx;
-  this.fy = fy;
-};
-
-/**
- * Add forces acting on the node
- * @param {number} fx   Force in horizontal direction
- * @param {number} fy   Force in vertical direction
- * @private
- */
-Node.prototype._addForce = function(fx, fy) {
-  this.fx += fx;
-  this.fy += fy;
-};
-
-/**
- * Store the state before the next step
- */
-Node.prototype.storeState = function() {
-  this.previousState.x = this.x;
-  this.previousState.y = this.y;
-  this.previousState.vx = this.vx;
-  this.previousState.vy = this.vy;
-}
-
-/**
- * Perform one discrete step for the node
- * @param {number} interval    Time interval in seconds
- */
-Node.prototype.discreteStep = function(interval) {
-  this.storeState();
-  if (!this.xFixed) {
-    var dx   = this.damping * this.vx;     // damping force
-    var ax   = (this.fx - dx) / this.options.mass;  // acceleration
-    this.vx += ax * interval;               // velocity
-    this.x  += this.vx * interval;          // position
-  }
-  else {
-    this.fx = 0;
-    this.vx = 0;
-  }
-
-  if (!this.yFixed) {
-    var dy   = this.damping * this.vy;     // damping force
-    var ay   = (this.fy - dy) / this.options.mass;  // acceleration
-    this.vy += ay * interval;               // velocity
-    this.y  += this.vy * interval;          // position
-  }
-  else {
-    this.fy = 0;
-    this.vy = 0;
-  }
-};
-
-
-
-/**
- * Perform one discrete step for the node
- * @param {number} interval    Time interval in seconds
- * @param {number} maxVelocity The speed limit imposed on the velocity
- */
-Node.prototype.discreteStepLimited = function(interval, maxVelocity) {
-  this.storeState();
-  if (!this.xFixed) {
-    var dx   = this.damping * this.vx;     // damping force
-    var ax   = (this.fx - dx) / this.options.mass;  // acceleration
-    this.vx += ax * interval;               // velocity
-    this.vx = (Math.abs(this.vx) > maxVelocity) ? ((this.vx > 0) ? maxVelocity : -maxVelocity) : this.vx;
-    this.x  += this.vx * interval;          // position
-  }
-  else {
-    this.fx = 0;
-    this.vx = 0;
-  }
-
-  if (!this.yFixed) {
-    var dy   = this.damping * this.vy;     // damping force
-    var ay   = (this.fy - dy) / this.options.mass;  // acceleration
-    this.vy += ay * interval;               // velocity
-    this.vy = (Math.abs(this.vy) > maxVelocity) ? ((this.vy > 0) ? maxVelocity : -maxVelocity) : this.vy;
-    this.y  += this.vy * interval;          // position
-  }
-  else {
-    this.fy = 0;
-    this.vy = 0;
-  }
-};
 
 /**
  * Check if this node has a fixed x and y position
@@ -406,17 +302,6 @@ Node.prototype.isFixed = function() {
   return (this.xFixed && this.yFixed);
 };
 
-/**
- * Check if this node is moving
- * @param {number} vmin   the minimum velocity considered as "moving"
- * @return {boolean}      true if moving, false if it has no velocity
- */
-Node.prototype.isMoving = function(vmin) {
-  var velocity = Math.sqrt(Math.pow(this.vx,2) + Math.pow(this.vy,2));
-//  this.velocity = Math.sqrt(Math.pow(this.vx,2) + Math.pow(this.vy,2))
-  return (velocity > vmin);
-};
-
 /**
  * check if this node is selecte
  * @return {boolean} selected   True if node is selected, else false

lib/network/mixins/MixinLoader.js

@@ -1,6 +1,3 @@
-var PhysicsMixin = require('./physics/PhysicsMixin');
-var ClusterMixin = require('./ClusterMixin');
-var SectorsMixin = require('./SectorsMixin');
 var SelectionMixin = require('./SelectionMixin');
 var ManipulationMixin = require('./ManipulationMixin');
 var NavigationMixin = require('./NavigationMixin');
@@ -53,16 +50,6 @@ exports._loadPhysicsSystem = function () {
 };
 
 
-/**
- * Mixin the cluster system and initialize the parameters required.
- *
- * @private
- */
-exports._loadClusterSystem = function () {
-  this.clusteredNodes = {};
-  this._loadMixin(ClusterMixin);
-};
-
 
 
 /**

lib/network/modules/PhysicsEngine.js

@@ -14,7 +14,8 @@ import {CentralGravitySolver} from "./components/physics/CentralGravitySolver";
 class PhysicsEngine {
   constructor(body, options) {
     this.body = body;
-    this.physicsBody = {calculationNodes: {}, calculationNodeIndices:[]};
+    this.physicsBody = {calculationNodes: {}, calculationNodeIndices:[], forces: {}, velocities: {}};
+    this.previousStates = {};
     this.setOptions(options);
   }
 
@@ -31,7 +32,7 @@ class PhysicsEngine {
     if (this.options.model == "repulsion") {
       options = this.options.repulsion;
       this.nodesSolver = new Repulsion(this.body, this.physicsBody, options);
-      this.edgesSolver = new SpringSolver(this.body, options);
+      this.edgesSolver = new SpringSolver(this.body, this.physicsBody, options);
     }
     else if (this.options.model == "hierarchicalRepulsion") {
       options = this.options.hierarchicalRepulsion;
@@ -41,10 +42,11 @@ class PhysicsEngine {
     else { // barnesHut
       options = this.options.barnesHut;
       this.nodesSolver = new BarnesHutSolver(this.body, this.physicsBody, options);
-      this.edgesSolver = new SpringSolver(this.body, options);
+      this.edgesSolver = new SpringSolver(this.body, this.physicsBody, options);
     }
 
     this.gravitySolver = new CentralGravitySolver(this.body, this.physicsBody, options);
+    this.modelOptions = options;
   }
 
   /**
@@ -57,6 +59,7 @@ class PhysicsEngine {
    */
   _updateCalculationNodes() {
     this.physicsBody.calculationNodes = {};
+    this.physicsBody.forces = {};
     this.physicsBody.calculationNodeIndices = [];
 
     for (let i = 0; i < this.body.nodeIndices.length; i++) {
@@ -75,10 +78,111 @@ class PhysicsEngine {
         console.error("Support node detected that does not have an edge!")
       }
     }
+
     this.physicsBody.calculationNodeIndices = Object.keys(this.physicsBody.calculationNodes);
+    for (let i = 0; i < this.physicsBody.calculationNodeIndices.length; i++) {
+      let nodeId = this.physicsBody.calculationNodeIndices[i];
+      this.physicsBody.forces[nodeId] = {x:0,y:0};
+
+      // forces can be reset because they are recalculated. Velocities have to persist.
+      if (this.physicsBody.velocities[nodeId] === undefined) {
+        this.physicsBody.velocities[nodeId] = {x:0,y:0};
+      }
+    }
+
+    // clean deleted nodes from the velocity vector
+    for (let nodeId in this.physicsBody.velocities) {
+      if (this.physicsBody.calculationNodes[nodeId] === undefined) {
+        delete this.physicsBody.velocities[nodeId];
+      }
+    }
+  }
+
+
+  revert() {
+    var nodeIds = Object.keys(this.previousStates);
+    var nodes = this.physicsBody.calculationNodes;
+    var velocities = this.physicsBody.velocities;
+
+    for (let i = 0; i < nodeIds.length; i++) {
+      let nodeId = nodeIds[i];
+      if (nodes[nodeId] !== undefined) {
+        velocities[nodeId].x = this.previousStates[nodeId].vx;
+        velocities[nodeId].y = this.previousStates[nodeId].vy;
+        nodes[nodeId].x = this.previousStates[nodeId].x;
+        nodes[nodeId].y = this.previousStates[nodeId].y;
+      }
+      else {
+        delete this.previousStates[nodeId];
+      }
+    }
+  }
+
+  moveNodes() {
+    var nodesPresent = false;
+    var nodeIndices = this.physicsBody.calculationNodeIndices;
+    var maxVelocity = this.options.maxVelocity === 0 ? 1e9 : this.options.maxVelocity;
+    var moving = false;
+    var vminCorrected = this.options.minVelocity / Math.max(this.body.functions.getScale(),0.05);
+
+    for (let i = 0; i < nodeIndices.length; i++) {
+      let nodeId = nodeIndices[i];
+      let nodeVelocity = this._performStep(nodeId, maxVelocity);
+      moving = nodeVelocity > vminCorrected;
+      nodesPresent = true;
+    }
+
+
+    if (nodesPresent == true) {
+      if (vminCorrected > 0.5*this.options.maxVelocity) {
+        return true;
+      }
+      else {
+        return moving;
+      }
+    }
+    return false;
+  }
+
+  _performStep(nodeId,maxVelocity) {
+    var node = this.physicsBody.calculationNodes[nodeId];
+    var timestep = this.options.timestep;
+    var forces = this.physicsBody.forces;
+    var velocities = this.physicsBody.velocities;
+
+    // store the state so we can revert
+    this.previousStates[nodeId] = {x:node.x, y:node.y, vx:velocities[nodeId].x, vy:velocities[nodeId].y};
+
+    if (!node.xFixed) {
+      let dx   = this.modelOptions.damping * velocities[nodeId].x;   // damping force
+      let ax   = (forces[nodeId].x - dx) / node.options.mass;        // acceleration
+      velocities[nodeId].x += ax * timestep;                         // velocity
+      velocities[nodeId].x = (Math.abs(velocities[nodeId].x) > maxVelocity) ? ((velocities[nodeId].x > 0) ? maxVelocity : -maxVelocity) : velocities[nodeId].x;
+      node.x  += velocities[nodeId].x * timestep;                    // position
+    }
+    else {
+      forces[nodeId].x = 0;
+      velocities[nodeId].x = 0;
+    }
+
+    if (!node.yFixed) {
+      let dy   = this.modelOptions.damping * velocities[nodeId].y;    // damping force
+      let ay   = (forces[nodeId].y - dy) / node.options.mass;         // acceleration
+      velocities[nodeId].y += ay * timestep;                          // velocity
+      velocities[nodeId].y = (Math.abs(velocities[nodeId].y) > maxVelocity) ? ((velocities[nodeId].y > 0) ? maxVelocity : -maxVelocity) : velocities[nodeId].y;
+      node.y  += velocities[nodeId].y * timestep;                     // position
+    }
+    else {
+      forces[nodeId].y = 0;
+      velocities[nodeId].y = 0;
+    }
+
+    var totalVelocity = Math.sqrt(Math.pow(velocities[nodeId].x,2) + Math.pow(velocities[nodeId].y,2));
+    return totalVelocity;
   }
 
-  step() {
+
+  calculateForces() {
     this.gravitySolver.solve();
     this.nodesSolver.solve();
     this.edgesSolver.solve();

lib/network/modules/components/physics/BarnesHutSolver.js

@@ -6,8 +6,12 @@ class BarnesHutSolver {
   constructor(body, physicsBody, options) {
     this.body = body;
     this.physicsBody = physicsBody;
-    this.options = options;
     this.barnesHutTree;
+    this.setOptions(options);
+  }
+
+  setOptions(options) {
+    this.options = options;
   }
 
 
@@ -75,8 +79,9 @@ class BarnesHutSolver {
         var gravityForce = this.options.gravitationalConstant * parentBranch.mass * node.options.mass / (distance * distance * distance);
         var fx = dx * gravityForce;
         var fy = dy * gravityForce;
-        node.fx += fx;
-        node.fy += fy;
+
+        this.physicsBody.forces[node.id].x += fx;
+        this.physicsBody.forces[node.id].y += fy;
       }
       else {
         // Did not pass the condition, go into children if available
@@ -96,8 +101,9 @@ class BarnesHutSolver {
             var gravityForce = this.options.gravitationalConstant * parentBranch.mass * node.options.mass / (distance * distance * distance);
             var fx = dx * gravityForce;
             var fy = dy * gravityForce;
-            node.fx += fx;
-            node.fy += fy;
+
+            this.physicsBody.forces[node.id].x += fx;
+            this.physicsBody.forces[node.id].y += fy;
           }
         }
       }

lib/network/modules/components/physics/CentralGravitySolver.js

@@ -16,20 +16,22 @@ class CentralGravitySolver {
   solve() {
     var dx, dy, distance, node, i;
     var nodes = this.physicsBody.calculationNodes;
-    var calculationNodeIndices = this.physicsBody.calculationNodeIndices;
+    var nodeIndices = this.physicsBody.calculationNodeIndices;
+    var forces = this.physicsBody.forces;
+
     var gravity = this.options.centralGravity;
     var gravityForce = 0;
 
-    for (i = 0; i < calculationNodeIndices.length; i++) {
-      node = nodes[calculationNodeIndices[i]];
-      node.damping = this.options.damping;
+    for (i = 0; i < nodeIndices.length; i++) {
+      let nodeId = nodeIndices[i];
+      node = nodes[nodeId];
       dx = -node.x;
       dy = -node.y;
       distance = Math.sqrt(dx * dx + dy * dy);
 
       gravityForce = (distance == 0) ? 0 : (gravity / distance);
-      node.fx = dx * gravityForce;
-      node.fy = dy * gravityForce;
+      forces[nodeId].x = dx * gravityForce;
+      forces[nodeId].y = dy * gravityForce;
     }
   }
 }

lib/network/modules/components/physics/HierarchicalRepulsionSolver.js

@@ -6,6 +6,10 @@ class HierarchicalRepulsionSolver {
   constructor(body, physicsBody, options) {
     this.body = body;
     this.physicsBody = physicsBody;
+    this.setOptions(options);
+  }
+
+  setOptions(options) {
     this.options = options;
   }
 
@@ -16,11 +20,11 @@ class HierarchicalRepulsionSolver {
    * @private
    */
   solve() {
-    var dx, dy, distance, fx, fy,
-      repulsingForce, node1, node2, i, j;
+    var dx, dy, distance, fx, fy, repulsingForce, node1, node2, i, j;
 
     var nodes = this.physicsBody.calculationNodes;
     var nodeIndices = this.physicsBody.calculationNodeIndices;
+    var forces = this.physicsBody.forces;
 
     // repulsing forces between nodes
     var nodeDistance = this.options.nodeDistance;
@@ -34,12 +38,10 @@ class HierarchicalRepulsionSolver {
 
         // nodes only affect nodes on their level
         if (node1.level == node2.level) {
-
           dx = node2.x - node1.x;
           dy = node2.y - node1.y;
           distance = Math.sqrt(dx * dx + dy * dy);
 
-
           var steepness = 0.05;
           if (distance < nodeDistance) {
             repulsingForce = -Math.pow(steepness * distance, 2) + Math.pow(steepness * nodeDistance, 2);
@@ -57,10 +59,10 @@ class HierarchicalRepulsionSolver {
           fx = dx * repulsingForce;
           fy = dy * repulsingForce;
 
-          node1.fx -= fx;
-          node1.fy -= fy;
-          node2.fx += fx;
-          node2.fy += fy;
+          forces[node1.id].x -= fx;
+          forces[node1.id].y -= fy;
+          forces[node2.id].x += fx;
+          forces[node2.id].y += fy;
         }
       }
     }

lib/network/modules/components/physics/HierarchicalSpringSolver.js

@@ -6,6 +6,10 @@ class HierarchicalSpringSolver {
   constructor(body, physicsBody, options) {
     this.body = body;
     this.physicsBody = physicsBody;
+    this.setOptions(options);
+  }
+
+  setOptions(options) {
     this.options = options;
   }
 
@@ -19,14 +23,14 @@ class HierarchicalSpringSolver {
     var dx, dy, fx, fy, springForce, distance;
     var edges = this.body.edges;
 
-    var nodes = this.physicsBody.calculationNodes;
     var nodeIndices = this.physicsBody.calculationNodeIndices;
+    var forces = this.physicsBody.forces;
 
     // initialize the spring force counters
     for (let i = 0; i < nodeIndices.length; i++) {
-      let node1 = nodes[nodeIndices[i]];
-      node1.springFx = 0;
-      node1.springFy = 0;
+      let nodeId = nodeIndices[i];
+      forces[nodeId].springFx = 0;
+      forces[nodeId].springFy = 0;
     }
 
 
@@ -35,34 +39,31 @@ class HierarchicalSpringSolver {
       if (edges.hasOwnProperty(edgeId)) {
         edge = edges[edgeId];
         if (edge.connected === true) {
-          // only calculate forces if nodes are in the same sector
-          if (this.body.nodes[edge.toId] !== undefined && this.body.nodes[edge.fromId] !== undefined) {
-            edgeLength = edge.properties.length === undefined ? this.options.springLength : edge.properties.length;
-
-            dx = (edge.from.x - edge.to.x);
-            dy = (edge.from.y - edge.to.y);
-            distance = Math.sqrt(dx * dx + dy * dy);
-            distance = distance == 0 ? 0.01 : distance;
-
-            // the 1/distance is so the fx and fy can be calculated without sine or cosine.
-            springForce = this.options.springConstant * (edgeLength - distance) / distance;
-
-            fx = dx * springForce;
-            fy = dy * springForce;
-
-            if (edge.to.level != edge.from.level) {
-              edge.to.springFx -= fx;
-              edge.to.springFy -= fy;
-              edge.from.springFx += fx;
-              edge.from.springFy += fy;
-            }
-            else {
-              let factor = 0.5;
-              edge.to.fx -= factor*fx;
-              edge.to.fy -= factor*fy;
-              edge.from.fx += factor*fx;
-              edge.from.fy += factor*fy;
-            }
+          edgeLength = edge.properties.length === undefined ? this.options.springLength : edge.properties.length;
+
+          dx = (edge.from.x - edge.to.x);
+          dy = (edge.from.y - edge.to.y);
+          distance = Math.sqrt(dx * dx + dy * dy);
+          distance = distance == 0 ? 0.01 : distance;
+
+          // the 1/distance is so the fx and fy can be calculated without sine or cosine.
+          springForce = this.options.springConstant * (edgeLength - distance) / distance;
+
+          fx = dx * springForce;
+          fy = dy * springForce;
+
+          if (edge.to.level != edge.from.level) {
+            forces[edge.toId].springFx -= fx;
+            forces[edge.toId].springFy -= fy;
+            forces[edge.fromId].springFx += fx;
+            forces[edge.fromId].springFy += fy;
+          }
+          else {
+            let factor = 0.5;
+            forces[edge.toId].x -= factor*fx;
+            forces[edge.toId].y -= factor*fy;
+            forces[edge.fromId].x += factor*fx;
+            forces[edge.fromId].y += factor*fy;
           }
         }
       }
@@ -72,29 +73,29 @@ class HierarchicalSpringSolver {
     var springForce = 1;
     var springFx, springFy;
     for (let i = 0; i < nodeIndices.length; i++) {
-      var node = nodes[nodeIndices[i]];
-      springFx = Math.min(springForce,Math.max(-springForce,node.springFx));
-      springFy = Math.min(springForce,Math.max(-springForce,node.springFy));
+      let nodeId = nodeIndices[i];
+      springFx = Math.min(springForce,Math.max(-springForce,forces[nodeId].springFx));
+      springFy = Math.min(springForce,Math.max(-springForce,forces[nodeId].springFy));
 
-      node.fx += springFx;
-      node.fy += springFy;
+      forces[nodeId].x += springFx;
+      forces[nodeId].y += springFy;
     }
 
     // retain energy balance
     var totalFx = 0;
     var totalFy = 0;
     for (let i = 0; i < nodeIndices.length; i++) {
-      var node = nodes[nodeIndices[i]];
-      totalFx += node.fx;
-      totalFy += node.fy;
+      let nodeId = nodeIndices[i];
+      totalFx += forces[nodeId].x;
+      totalFy += forces[nodeId].y;
     }
     var correctionFx = totalFx / nodeIndices.length;
     var correctionFy = totalFy / nodeIndices.length;
 
     for (let i = 0; i < nodeIndices.length; i++) {
-      var node = nodes[nodeIndices[i]];
-      node.fx -= correctionFx;
-      node.fy -= correctionFy;
+      let nodeId = nodeIndices[i];
+      forces[nodeId].x -= correctionFx;
+      forces[nodeId].y -= correctionFy;
     }
   }
 

lib/network/modules/components/physics/RepulsionSolver.js

@@ -6,9 +6,12 @@ class RepulsionSolver {
   constructor(body, physicsBody, options) {
     this.body = body;
     this.physicsBody = physicsBody;
-    this.options = options;
+    this.setOptions(options);
   }
 
+  setOptions(options) {
+    this.options = options;
+  }
   /**
    * Calculate the forces the nodes apply on each other based on a repulsion field.
    * This field is linearly approximated.
@@ -20,12 +23,13 @@ class RepulsionSolver {
 
     var nodes = this.physicsBody.calculationNodes;
     var nodeIndices = this.physicsBody.calculationNodeIndices;
+    var forces = this.physicsBody.forces;
 
     // repulsing forces between nodes
     var nodeDistance = this.options.nodeDistance;
 
     // approximation constants
-    var a = (-2 / 3) /nodeDistance;
+    var a = (-2 / 3) / nodeDistance;
     var b = 4 / 3;
 
     // we loop from i over all but the last entree in the array
@@ -56,10 +60,11 @@ class RepulsionSolver {
 
           fx = dx * repulsingForce;
           fy = dy * repulsingForce;
-          node1.fx -= fx;
-          node1.fy -= fy;
-          node2.fx += fx;
-          node2.fy += fy;
+
+          forces[node1.id].x -= fx;
+          forces[node1.id].y -= fy;
+          forces[node2.id].x += fx;
+          forces[node2.id].y += fy;
         }
       }
     }

lib/network/modules/components/physics/SpringSolver.js

@@ -3,8 +3,13 @@
  */
 
 class SpringSolver {
-  constructor(body, options) {
+  constructor(body, physicsBody, options) {
     this.body = body;
+    this.physicsBody = physicsBody;
+    this.setOptions(options);
+  }
+
+  setOptions(options) {
     this.options = options;
   }
 
@@ -65,10 +70,10 @@ class SpringSolver {
     fx = dx * springForce;
     fy = dy * springForce;
 
-    node1.fx += fx;
-    node1.fy += fy;
-    node2.fx -= fx;
-    node2.fy -= fy;
+    this.physicsBody.forces[node1.id].x += fx;
+    this.physicsBody.forces[node1.id].y += fy;
+    this.physicsBody.forces[node2.id].x -= fx;
+    this.physicsBody.forces[node2.id].y -= fy;
   }
 }