Bugfixes

examples/scripts/EvenNumberGen/EvenNumberGen.py

@@ -17,11 +17,11 @@ class Counter(CBD):
         self.addBlock(AdderBlock("sum"))
 
         # Create the Connections
-        self.addConnection("zero", "delay", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("delay", "sum", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("zero", "delay", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("delay", "sum", input_port_name='IN1', output_port_name='OUT1')
         self.addConnection("delay", "OutCount", output_port_name='OUT1')
-        self.addConnection("one", "sum", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("sum", "delay", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("one", "sum", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("sum", "delay", input_port_name='IN1', output_port_name='OUT1')
 
 
 class Double(CBD):
@@ -34,7 +34,7 @@ class Double(CBD):
 
         # Create the Connections
         self.addConnection("InNumber", "mult", input_port_name='IN1')
-        self.addConnection("two", "mult", output_port_name='OUT1', input_port_name='IN2')
+        self.addConnection("two", "mult", input_port_name='IN2', output_port_name='OUT1')
         self.addConnection("mult", "OutDouble", output_port_name='OUT1')
 
 
@@ -47,7 +47,7 @@ class EvenNumberGen(CBD):
         self.addBlock(Double("double"))
 
         # Create the Connections
-        self.addConnection("counter", "double", output_port_name='OutCount', input_port_name='InNumber')
-        self.addConnection("double", "OUT1", output_port_name='OutDouble', input_port_name='IN1')
+        self.addConnection("counter", "double", input_port_name='InNumber', output_port_name='OutCount')
+        self.addConnection("double", "OUT1", input_port_name='IN1', output_port_name='OutDouble')
 
 

examples/scripts/Fibonacci/Fibonacci.py

@@ -18,12 +18,12 @@ class FibonacciGen(CBD):
         self.addBlock(ConstantBlock("one", value=(1)))
 
         # Create the Connections
-        self.addConnection("delay1", "delay2", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("delay1", "sum", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("delay2", "sum", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("sum", "delay1", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("delay1", "delay2", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("delay1", "sum", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("delay2", "sum", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("sum", "delay1", input_port_name='IN1', output_port_name='OUT1')
         self.addConnection("sum", "OUT1", output_port_name='OUT1')
-        self.addConnection("zero", "delay1", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("one", "delay2", output_port_name='OUT1', input_port_name='IC')
+        self.addConnection("zero", "delay1", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("one", "delay2", input_port_name='IC', output_port_name='OUT1')
 
 

examples/scripts/LCG/LCG.py

@@ -21,14 +21,14 @@ class LCG(CBD):
         self.addBlock(ModuloBlock("mod"))
 
         # Create the Connections
-        self.addConnection("x0", "delay", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("a", "mult", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("delay", "mult", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("mult", "sum", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("c", "sum", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("sum", "mod", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("m", "mod", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("mod", "delay", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("mod", "OUT1", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("x0", "delay", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("a", "mult", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("delay", "mult", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("mult", "sum", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("c", "sum", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("sum", "mod", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("m", "mod", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("mod", "delay", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("mod", "OUT1", input_port_name='IN1', output_port_name='OUT1')
 
 

examples/scripts/LCG2/LCG.py

@@ -23,14 +23,14 @@ class LCG(CBD):
         self.addBlock(SignalCollectorBlock("collector"))
 
         # Create the Connections
-        self.addConnection("x0", "delay", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("a", "mult", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("delay", "mult", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("mult", "sum", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("c", "sum", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("m", "mod", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("sum", "mod", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("mod", "delay", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("mod", "collector", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("x0", "delay", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("a", "mult", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("delay", "mult", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("mult", "sum", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("c", "sum", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("m", "mod", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("sum", "mod", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("mod", "delay", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("mod", "collector", input_port_name='IN1', output_port_name='OUT1')
 
 

examples/scripts/SinGen/SinGen.py

@@ -20,8 +20,7 @@ class SinGen(CBD):
         self.addBlock(GenericBlock("sin", block_operator="sin"))
 
         # Connect them together
-        self.addConnection("time", "sin", output_port_name='OUT1',
-                           input_port_name='IN1')
+        self.addConnection("time", "sin", input_port_name='IN1', output_port_name='OUT1')
 
         # Connect the output port
         self.addConnection("sin", "OUT1", output_port_name='OUT1')

experiments/AGV/AGV.py

@@ -95,20 +95,20 @@ class OdometryBase(CBD):
         # Create the Connections
         self.addConnection("phiLdot", "B-OUZVyqj9DiQNmVnVL9-16", input_port_name='IN1')
         self.addConnection("phiRdot", "B-OUZVyqj9DiQNmVnVL9-16", input_port_name='IN2')
-        self.addConnection("half", "div2", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("B-OUZVyqj9DiQNmVnVL9-16", "div2", output_port_name='OUT1', input_port_name='IN2')
+        self.addConnection("half", "div2", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("B-OUZVyqj9DiQNmVnVL9-16", "div2", input_port_name='IN2', output_port_name='OUT1')
         self.addConnection("mulX", "ydot", output_port_name='OUT1')
-        self.addConnection("div2", "mulX", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("div2", "mulY", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("div2", "mulX", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("div2", "mulY", input_port_name='IN1', output_port_name='OUT1')
         self.addConnection("mulY", "xdot", output_port_name='OUT1')
         self.addConnection("heading", "sin", input_port_name='IN1')
         self.addConnection("heading", "cos", input_port_name='IN1')
-        self.addConnection("mulSin", "mulX", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("sin", "mulSin", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("r", "mulSin", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("r", "mulCos", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("mulCos", "mulY", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("cos", "mulCos", output_port_name='OUT1', input_port_name='IN2')
+        self.addConnection("mulSin", "mulX", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("sin", "mulSin", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("r", "mulSin", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("r", "mulCos", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("mulCos", "mulY", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("cos", "mulCos", input_port_name='IN2', output_port_name='OUT1')
 
 
 class Odometry(CBD):
@@ -127,23 +127,23 @@ class Odometry(CBD):
         self.addBlock(ConstantBlock("init_w", value=(initial[2])))
 
         # Create the Connections
-        self.addConnection("delta", "int_w", output_port_name='OUT1', input_port_name='delta_t')
-        self.addConnection("delta", "int_y", output_port_name='OUT1', input_port_name='delta_t')
-        self.addConnection("delta", "int_x", output_port_name='OUT1', input_port_name='delta_t')
+        self.addConnection("delta", "int_w", input_port_name='delta_t', output_port_name='OUT1')
+        self.addConnection("delta", "int_y", input_port_name='delta_t', output_port_name='OUT1')
+        self.addConnection("delta", "int_x", input_port_name='delta_t', output_port_name='OUT1')
         self.addConnection("int_w", "heading", output_port_name='OUT1')
-        self.addConnection("int_w", "base", output_port_name='OUT1', input_port_name='heading')
+        self.addConnection("int_w", "base", input_port_name='heading', output_port_name='OUT1')
         self.addConnection("phiLdot", "base", input_port_name='phiLdot')
         self.addConnection("phiLdot", "OCegTr4naEkMIVMNTQIZ-73", input_port_name='phiLdot')
         self.addConnection("phiRdot", "base", input_port_name='phiRdot')
         self.addConnection("phiRdot", "OCegTr4naEkMIVMNTQIZ-73", input_port_name='phiRdot')
-        self.addConnection("base", "int_x", output_port_name='xdot', input_port_name='IN1')
-        self.addConnection("base", "int_y", output_port_name='ydot', input_port_name='IN1')
+        self.addConnection("base", "int_x", input_port_name='IN1', output_port_name='xdot')
+        self.addConnection("base", "int_y", input_port_name='IN1', output_port_name='ydot')
         self.addConnection("int_x", "x", output_port_name='OUT1')
         self.addConnection("int_y", "y", output_port_name='OUT1')
-        self.addConnection("OCegTr4naEkMIVMNTQIZ-73", "int_w", output_port_name='wdot', input_port_name='IN1')
-        self.addConnection("init_w", "int_w", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("init_y", "int_y", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("init_x", "int_x", output_port_name='OUT1', input_port_name='IC')
+        self.addConnection("OCegTr4naEkMIVMNTQIZ-73", "int_w", input_port_name='IN1', output_port_name='wdot')
+        self.addConnection("init_w", "int_w", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("init_y", "int_y", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("init_x", "int_x", input_port_name='IC', output_port_name='OUT1')
 
 
 class OdometryW(CBD):
@@ -161,11 +161,12 @@ class OdometryW(CBD):
         # Create the Connections
         self.addConnection("phiRdot", "OCegTr4naEkMIVMNTQIZ-39", input_port_name='IN1')
         self.addConnection("phiLdot", "OCegTr4naEkMIVMNTQIZ-43", input_port_name='IN1')
-        self.addConnection("OCegTr4naEkMIVMNTQIZ-39", "OCegTr4naEkMIVMNTQIZ-43", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("OCegTr4naEkMIVMNTQIZ-43", "multr", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("rneg", "multr", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("invd", "multd", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("multr", "multd", output_port_name='OUT1', input_port_name='IN2')
+        self.addConnection("OCegTr4naEkMIVMNTQIZ-39", "OCegTr4naEkMIVMNTQIZ-43", input_port_name='IN2',
+                           output_port_name='OUT1')
+        self.addConnection("OCegTr4naEkMIVMNTQIZ-43", "multr", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("rneg", "multr", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("invd", "multd", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("multr", "multd", input_port_name='IN2', output_port_name='OUT1')
         self.addConnection("multd", "wdot", output_port_name='OUT1')
 
 
@@ -183,8 +184,8 @@ class ControllerPID(CBD):
 
         # Create the Connections
         self.addConnection("color", "sum", input_port_name='IN1')
-        self.addConnection("threshold", "sum", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("sum", "PID", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("threshold", "sum", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("sum", "PID", input_port_name='IN1', output_port_name='OUT1')
         self.addConnection("PID", "mult", input_port_name='IN1', output_port_name='OUT1')
         self.addConnection("friction", "mult", input_port_name='IN2', output_port_name='OUT1')
         self.addConnection("mult", "heading", output_port_name='OUT1')
@@ -205,9 +206,9 @@ class Controller(CBD):
         # Create the Connections
         self.addConnection("v", "velocity", output_port_name='OUT1')
         self.addConnection("color", "sum", input_port_name='IN1')
-        self.addConnection("threshold", "sum", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("sum", "w1qmmAkClArfh_rfX7cO-38", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("gamma", "w1qmmAkClArfh_rfX7cO-38", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("threshold", "sum", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("sum", "w1qmmAkClArfh_rfX7cO-38", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("gamma", "w1qmmAkClArfh_rfX7cO-38", input_port_name='IN1', output_port_name='OUT1')
         self.addConnection("w1qmmAkClArfh_rfX7cO-38", "heading", output_port_name='OUT1')
 
 
@@ -230,22 +231,22 @@ class PID(CBD):
         self.addBlock(AdderBlock("sum2"))
 
         # Create the Connections
-        self.addConnection("Kp", "prod", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("Kp", "prod", input_port_name='IN1', output_port_name='OUT1')
         self.addConnection("IN1", "prod", input_port_name='IN2')
         self.addConnection("IN1", "int", input_port_name='IN1')
         self.addConnection("IN1", "deriv", input_port_name='IN1')
-        self.addConnection("delta_t", "deriv", output_port_name='OUT1', input_port_name='delta_t')
-        self.addConnection("delta_t", "int", output_port_name='OUT1', input_port_name='delta_t')
-        self.addConnection("int", "imult", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("Ki", "imult", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("deriv", "dmult", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("Kd", "dmult", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("zero", "int", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("zero", "deriv", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("prod", "sum1", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("imult", "sum1", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("sum1", "sum2", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("dmult", "sum2", output_port_name='OUT1', input_port_name='IN2')
+        self.addConnection("delta_t", "deriv", input_port_name='delta_t', output_port_name='OUT1')
+        self.addConnection("delta_t", "int", input_port_name='delta_t', output_port_name='OUT1')
+        self.addConnection("int", "imult", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("Ki", "imult", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("deriv", "dmult", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("Kd", "dmult", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("zero", "int", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("zero", "deriv", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("prod", "sum1", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("imult", "sum1", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("sum1", "sum2", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("dmult", "sum2", input_port_name='IN2', output_port_name='OUT1')
         self.addConnection("sum2", "OUT1", output_port_name='OUT1')
 
 
@@ -269,20 +270,20 @@ class DifferentialDrive(CBD):
 
         # Create the Connections
         self.addConnection("steering", "steeringMult", input_port_name='IN1')
-        self.addConnection("WheelAxis", "steeringMult", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("steeringMult", "halfSteeringMult", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("half", "halfSteeringMult", output_port_name='OUT1', input_port_name='IN2')
+        self.addConnection("WheelAxis", "steeringMult", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("steeringMult", "halfSteeringMult", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("half", "halfSteeringMult", input_port_name='IN2', output_port_name='OUT1')
         self.addConnection("velocity", "leftSum", input_port_name='IN1')
         self.addConnection("velocity", "rightSum", input_port_name='IN2')
-        self.addConnection("halfSteeringMult", "rightSum", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("halfSteeringMult", "neg", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("neg", "leftSum", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("rightSum", "rightMult", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("leftSum", "leftMult", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("WheelRadius", "leftMult", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("WheelRadius", "rightMult", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("leftMult", "leftClamp", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("rightMult", "rightClamp", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("halfSteeringMult", "rightSum", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("halfSteeringMult", "neg", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("neg", "leftSum", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("rightSum", "rightMult", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("leftSum", "leftMult", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("WheelRadius", "leftMult", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("WheelRadius", "rightMult", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("leftMult", "leftClamp", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("rightMult", "rightClamp", input_port_name='IN1', output_port_name='OUT1')
         self.addConnection("rightClamp", "phiRdot", output_port_name='OUT1')
         self.addConnection("leftClamp", "phiLdot", output_port_name='OUT1')
 
@@ -300,12 +301,12 @@ class AGV(CBD):
         self.addBlock(TCPClientSender("TCP", '192.168.1.10', 8080))
 
         # Create the Connections
-        self.addConnection("Controller", "StaticPlant", output_port_name='heading', input_port_name='steering')
-        self.addConnection("Controller", "StaticPlant", output_port_name='velocity', input_port_name='velocity')
-        self.addConnection("colorSensor", "Controller", output_port_name='OUT1', input_port_name='color')
-        self.addConnection("colorSensor", "TCP", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("StaticPlant", "RightMotor", output_port_name='phiRdot', input_port_name='IN1')
-        self.addConnection("StaticPlant", "LeftMotor", output_port_name='phiLdot', input_port_name='IN1')
+        self.addConnection("Controller", "StaticPlant", input_port_name='steering', output_port_name='heading')
+        self.addConnection("Controller", "StaticPlant", input_port_name='velocity', output_port_name='velocity')
+        self.addConnection("colorSensor", "Controller", input_port_name='color', output_port_name='OUT1')
+        self.addConnection("colorSensor", "TCP", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("StaticPlant", "RightMotor", input_port_name='IN1', output_port_name='phiRdot')
+        self.addConnection("StaticPlant", "LeftMotor", input_port_name='IN1', output_port_name='phiLdot')
 
 
 from CBD.lib.io import WriteCSV, ReadCSV, Interpolation
@@ -337,25 +338,25 @@ class AGVVirtual(CBD):
         # self.addBlock(SignalCollectorBlock("tcp_dur"))
 
         # Create the Connections
-        self.addConnection("Controller", "StaticPlant", output_port_name='heading', input_port_name='steering')
-        self.addConnection("Controller", "StaticPlant", output_port_name='velocity', input_port_name='velocity')
-        self.addConnection("environment", "Controller", output_port_name='color', input_port_name='color')
-        self.addConnection("StaticPlant", "odo", output_port_name='phiLdot', input_port_name='phiLdot')
-        self.addConnection("StaticPlant", "odo", output_port_name='phiRdot', input_port_name='phiRdot')
-        self.addConnection("odo", "plot", output_port_name='x', input_port_name='X')
-        self.addConnection("odo", "environment", output_port_name='x', input_port_name='x')
-        self.addConnection("odo", "plot", output_port_name='y', input_port_name='Y')
-        self.addConnection("odo", "environment", output_port_name='y', input_port_name='y')
-        self.addConnection("environment", "int", output_port_name='offset', input_port_name='IN1')
-        self.addConnection("zero", "int", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("zero", "intH", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("delta", "int", output_port_name='OUT1', input_port_name='delta_t')
-        self.addConnection("delta", "intH", output_port_name='OUT1', input_port_name='delta_t')
-        self.addConnection("odo", "intH", output_port_name='heading', input_port_name='IN1')
-        self.addConnection("odo", "headingPlot", output_port_name='heading', input_port_name='IN1')
-        self.addConnection("intH", "mult", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("int", "mult", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("mult", "errorPlot", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("Controller", "StaticPlant", input_port_name='steering', output_port_name='heading')
+        self.addConnection("Controller", "StaticPlant", input_port_name='velocity', output_port_name='velocity')
+        self.addConnection("environment", "Controller", input_port_name='color', output_port_name='color')
+        self.addConnection("StaticPlant", "odo", input_port_name='phiLdot', output_port_name='phiLdot')
+        self.addConnection("StaticPlant", "odo", input_port_name='phiRdot', output_port_name='phiRdot')
+        self.addConnection("odo", "plot", input_port_name='X', output_port_name='x')
+        self.addConnection("odo", "environment", input_port_name='x', output_port_name='x')
+        self.addConnection("odo", "plot", input_port_name='Y', output_port_name='y')
+        self.addConnection("odo", "environment", input_port_name='y', output_port_name='y')
+        self.addConnection("environment", "int", input_port_name='IN1', output_port_name='offset')
+        self.addConnection("zero", "int", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("zero", "intH", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("delta", "int", input_port_name='delta_t', output_port_name='OUT1')
+        self.addConnection("delta", "intH", input_port_name='delta_t', output_port_name='OUT1')
+        self.addConnection("odo", "intH", input_port_name='IN1', output_port_name='heading')
+        self.addConnection("odo", "headingPlot", input_port_name='IN1', output_port_name='heading')
+        self.addConnection("intH", "mult", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("int", "mult", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("mult", "errorPlot", input_port_name='IN1', output_port_name='OUT1')
 
         # self.addConnection("odo", "writer", output_port_name="heading", input_port_name="heading")
         # self.addConnection("odo", "writer", output_port_name="x", input_port_name="x")

experiments/HarmonicOscilator/CBDB.py

@@ -1,203 +0,0 @@
-#!/usr/bin/python3
-# This file was automatically generated from drawio2cbd with the command:
-#   ../../drawio2cbd.py Harmonic.xml CBDB.py -e ErrorB -t 1000 -T 0.01
-
-from CBD.Core import CBD
-from CBD.simulator import Simulator
-from CBD.lib.std import *
-DELTA_T = 0.01
-
-
-class IntegratorBlock(CBD):
-	def __init__(self, block_name):
-		super().__init__(block_name, input_ports=["IC", "IN1", "delta_t"], output_ports=["OUT1"])
-		self.addBlock(ProductBlock("mul"))
-		self.addBlock(AdderBlock("sum"))
-		self.addBlock(AdderBlock("sum_ic"))
-		self.addBlock(DelayBlock("delay"))
-		self.addBlock(NegatorBlock("neg"))
-
-		self.addConnection("IN1", "mul")
-		self.addConnection("delta_t", "mul")
-		self.addConnection("mul", "sum")
-		self.addConnection("delay", "sum")
-		self.addConnection("sum", "delay")
-		self.addConnection("IC", "sum_ic")
-		self.addConnection("neg", "sum_ic")
-		self.addConnection("sum_ic", "delay", input_port_name="IC")
-		self.addConnection("mul", "neg")
-		self.addConnection("sum", "OUT1")
-
-
-
-import matplotlib.pyplot as plt
-
-
-def plot_signals(block, signals, title):
-	times = []
-	outputs = []
-
-	for signal in signals:
-		tvpl = block.getSignalHistory(signal)
-		times = [t for t, _ in tvpl]
-		outputs.append([v for _, v in tvpl])
-
-	# Plot
-	plt.figure()
-	plt.title(title)
-	plt.xlabel('time')
-	plt.ylabel('N')
-	for i in range(len(signals)):
-		plt.plot(times, outputs[i], label=signals[i])
-	plt.legend()
-	plt.show()
-
-
-
-
-class HarmonicB(CBD):
-	def __init__(self, block_name):
-		CBD.__init__(self, block_name, input_ports=['dt'], output_ports=['x'])
-		
-		# Create the blocks
-		self.addBlock(DerivatorBlock(block_name='deriv1'))
-		self.addBlock(DerivatorBlock(block_name='deriv2'))
-		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
-		self.addBlock(ConstantBlock(block_name='one', value=(1)))
-		self.addBlock(NegatorBlock(block_name='neg'))
-		
-		# Connect the blocks
-		self.addConnection('dt', 'deriv1', input_port_name='delta_t')
-		self.addConnection('dt', 'deriv2', input_port_name='delta_t')
-		self.addConnection('deriv1', 'deriv2')
-		self.addConnection('one', 'deriv1', input_port_name='IC')
-		self.addConnection('zero', 'deriv2', input_port_name='IC')
-		self.addConnection('deriv2', 'neg')
-		self.addConnection('neg', 'deriv1')
-		self.addConnection('neg', 'x')
-
-
-class HarmonicA(CBD):
-	def __init__(self, block_name):
-		CBD.__init__(self, block_name, input_ports=['dt'], output_ports=['x'])
-		
-		# Create the blocks
-		self.addBlock(IntegratorBlock(block_name='int2'))
-		self.addBlock(IntegratorBlock(block_name='int1'))
-		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
-		self.addBlock(ConstantBlock(block_name='one', value=(1)))
-		self.addBlock(NegatorBlock(block_name='neg'))
-		
-		# Connect the blocks
-		self.addConnection('dt', 'int2', input_port_name='delta_t')
-		self.addConnection('dt', 'int1', input_port_name='delta_t')
-		self.addConnection('zero', 'int2', input_port_name='IC')
-		self.addConnection('one', 'int1', input_port_name='IC')
-		self.addConnection('int2', 'x')
-		self.addConnection('int2', 'neg')
-		self.addConnection('neg', 'int1')
-		self.addConnection('int1', 'int2')
-
-
-class ErrorA(CBD):
-	def __init__(self, block_name, dt=(DELTA_T)):
-		CBD.__init__(self, block_name, input_ports=[], output_ports=['e', 'real', 'A'])
-		
-		# Create the blocks
-		self.addBlock(SinBlock(block_name='sin'))
-		self.addBlock(NegatorBlock(block_name='neg'))
-		self.addBlock(AdderBlock(block_name='sum'))
-		self.addBlock(AbsBlock(block_name='abs'))
-		self.addBlock(IntegratorBlock(block_name='int'))
-		self.addBlock(ConstantBlock(block_name='dt', value=(dt)))
-		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
-		self.addBlock(HarmonicA(block_name='harmonic'))
-		
-		# Connect the blocks
-		self.addConnection('sin', 'sum')
-		self.addConnection('neg', 'sum')
-		self.addConnection('sum', 'abs')
-		self.addConnection('zero', 'int', input_port_name='IC')
-		self.addConnection('dt', 'int', input_port_name='delta_t')
-		self.addConnection('abs', 'int')
-		self.addConnection('int', 'e')
-		self.addConnection('harmonic', 'neg', output_port_name='x')
-		self.addConnection('dt', 'harmonic', input_port_name='dt')
-		self.addConnection('sin', 'real')
-		self.addConnection('harmonic', 'A', output_port_name='x')
-
-
-class SinBlock(CBD):
-	def __init__(self, block_name):
-		CBD.__init__(self, block_name, input_ports=[], output_ports=['OUT1'])
-		
-		# Create the blocks
-		self.addBlock(TimeBlock(block_name='time'))
-		self.addBlock(GenericBlock(block_name='sin', block_operator=("sin")))
-		
-		# Connect the blocks
-		self.addConnection('time', 'sin')
-		self.addConnection('sin', 'OUT1')
-
-
-class ErrorB(CBD):
-	def __init__(self, block_name, dt=(DELTA_T)):
-		CBD.__init__(self, block_name, input_ports=[], output_ports=['e', 'B', 'real'])
-		
-		# Create the blocks
-		self.addBlock(SinBlock(block_name='sin'))
-		self.addBlock(NegatorBlock(block_name='neg'))
-		self.addBlock(AdderBlock(block_name='sum'))
-		self.addBlock(AbsBlock(block_name='abs'))
-		self.addBlock(IntegratorBlock(block_name='int'))
-		self.addBlock(ConstantBlock(block_name='dt', value=(dt)))
-		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
-		self.addBlock(HarmonicB(block_name='harmonic'))
-		
-		# Connect the blocks
-		self.addConnection('sin', 'sum')
-		self.addConnection('neg', 'sum')
-		self.addConnection('sum', 'abs')
-		self.addConnection('zero', 'int', input_port_name='IC')
-		self.addConnection('dt', 'int', input_port_name='delta_t')
-		self.addConnection('abs', 'int')
-		self.addConnection('int', 'e')
-		self.addConnection('harmonic', 'neg', output_port_name='x')
-		self.addConnection('dt', 'harmonic', input_port_name='dt')
-		self.addConnection('harmonic', 'B', output_port_name='x')
-		self.addConnection('sin', 'real')
-
-
-if __name__ == '__main__':
-	outputs = []
-	signals = []
-	for dt in [0.1, 0.01, 0.001]:
-		# cbdB = ErrorB("ErrorB", dt=dt)
-		# # Run the simulation
-		# cbdB.run(int(10/dt), delta_t=dt)
-		# tvpl = cbdB.getSignalHistory("e")
-		# outputs.append(tvpl)
-		# signals.append("B " + str(dt))
-		# plot_signals(cbdB, ['real', 'B'], f'Value B ({dt})')
-
-		cbdA = ErrorA("ErrorA", dt=dt)
-		# Run the simulation
-		sim = Simulator(cbdA)
-		sim.setDeltaT(dt)
-		sim.run(int(10/dt))
-		tvpl = cbdA.getSignalHistory("e")
-		outputs.append(tvpl)
-		signals.append("A " + str(dt))
-		plot_signals(cbdA, ['real', 'A'], f'Value A ({dt})')
-
-	plt.figure()
-	plt.title("Error")
-	plt.xlabel('time')
-	plt.ylabel('N')
-	for i in range(3):
-		time = [x for x, _ in outputs[i]]
-		value = [x for _, x in outputs[i]]
-		plt.plot(time, value, label=signals[i])
-	plt.legend()
-	plt.show()
-

experiments/HarmonicOscilator/HA.py

@@ -1,162 +0,0 @@
-#!/usr/bin/python3
-# This file was automatically generated from drawio2cbd with the command:
-#   ../../drawio2cbd.py Harmonic.xml HA.py -e HarmonicA -T 0.1 -t 1000
-
-from CBD.Core import CBD
-from CBD.simulator import Simulator
-from CBD.lib.std import *
-DELTA_T = 0.1
-
-
-
-import matplotlib.pyplot as plt
-
-
-def plot_signals(block, signals, title):
-	times = []
-	outputs = []
-
-	for signal in signals:
-		tvpl = block.getSignalHistory(signal)
-		times = [t for t, _ in tvpl]
-		outputs.append([v for _, v in tvpl])
-
-	# Plot
-	plt.figure()
-	plt.title(title)
-	plt.xlabel('time')
-	plt.ylabel('N')
-	for i in range(len(signals)):
-		plt.plot(times, outputs[i], label=signals[i])
-	plt.legend()
-	plt.show()
-
-
-
-
-class HarmonicB(CBD):
-	def __init__(self, block_name):
-		CBD.__init__(self, block_name, input_ports=['dt'], output_ports=['x'])
-		
-		# Create the blocks
-		self.addBlock(DerivatorBlock(block_name='deriv1'))
-		self.addBlock(DerivatorBlock(block_name='deriv2'))
-		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
-		self.addBlock(ConstantBlock(block_name='one', value=(1)))
-		self.addBlock(NegatorBlock(block_name='neg'))
-		
-		# Connect the blocks
-		self.addConnection('dt', 'deriv1', input_port_name='delta_t')
-		self.addConnection('dt', 'deriv2', input_port_name='delta_t')
-		self.addConnection('deriv1', 'deriv2')
-		self.addConnection('zero', 'deriv1', input_port_name='IC')
-		self.addConnection('one', 'deriv2', input_port_name='IC')
-		self.addConnection('deriv2', 'neg')
-		self.addConnection('neg', 'deriv1')
-		self.addConnection('deriv1', 'x')
-
-
-class HarmonicA(CBD):
-	def __init__(self, block_name):
-		CBD.__init__(self, block_name, input_ports=[], output_ports=['x'])
-		
-		# Create the blocks
-		self.addBlock(IntegratorBlock(block_name='int2'))
-		self.addBlock(IntegratorBlock(block_name='int1'))
-		self.addBlock(ConstantBlock(block_name='dt', value=(DELTA_T)))
-		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
-		self.addBlock(ConstantBlock(block_name='one', value=(1)))
-		self.addBlock(NegatorBlock(block_name='guTbTpoFw5JaFCAvi6fC-146'))
-		
-		# Connect the blocks
-		self.addConnection('dt', 'int2', input_port_name='delta_t')
-		self.addConnection('dt', 'int1', input_port_name='delta_t')
-		self.addConnection('zero', 'int2', input_port_name='IC')
-		self.addConnection('one', 'int1', input_port_name='IC')
-		self.addConnection('int2', 'x')
-		self.addConnection('int2', 'guTbTpoFw5JaFCAvi6fC-146')
-		self.addConnection('guTbTpoFw5JaFCAvi6fC-146', 'int1')
-		self.addConnection('int1', 'int2')
-
-
-class ErrorA(CBD):
-	def __init__(self, block_name, dt=(DELTA_T)):
-		CBD.__init__(self, block_name, input_ports=[], output_ports=['e', 'real', 'A'])
-		
-		# Create the blocks
-		self.addBlock(SinBlock(block_name='sin'))
-		self.addBlock(NegatorBlock(block_name='neg'))
-		self.addBlock(AdderBlock(block_name='sum'))
-		self.addBlock(AbsBlock(block_name='abs'))
-		self.addBlock(IntegratorBlock(block_name='int'))
-		self.addBlock(ConstantBlock(block_name='dt', value=(dt)))
-		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
-		self.addBlock(HarmonicA(block_name='harmonic'))
-		
-		# Connect the blocks
-		self.addConnection('sin', 'sum')
-		self.addConnection('neg', 'sum')
-		self.addConnection('sum', 'abs')
-		self.addConnection('zero', 'int', input_port_name='IC')
-		self.addConnection('dt', 'int', input_port_name='delta_t')
-		self.addConnection('abs', 'int')
-		self.addConnection('int', 'e')
-		self.addConnection('harmonic', 'neg', output_port_name='x')
-		self.addConnection('dt', 'harmonic', input_port_name='dt')
-		self.addConnection('sin', 'real')
-		self.addConnection('harmonic', 'A', output_port_name='x')
-
-
-class SinBlock(CBD):
-	def __init__(self, block_name):
-		CBD.__init__(self, block_name, input_ports=[], output_ports=['OUT1'])
-		
-		# Create the blocks
-		self.addBlock(TimeBlock(block_name='time'))
-		self.addBlock(GenericBlock(block_name='sin', block_operator=("sin")))
-		
-		# Connect the blocks
-		self.addConnection('time', 'sin')
-		self.addConnection('sin', 'OUT1')
-
-
-class ErrorB(CBD):
-	def __init__(self, block_name, dt=(DELTA_T)):
-		CBD.__init__(self, block_name, input_ports=[], output_ports=['e', 'B', 'real'])
-		
-		# Create the blocks
-		self.addBlock(SinBlock(block_name='sin'))
-		self.addBlock(NegatorBlock(block_name='neg'))
-		self.addBlock(AdderBlock(block_name='sum'))
-		self.addBlock(AbsBlock(block_name='abs'))
-		self.addBlock(IntegratorBlock(block_name='int'))
-		self.addBlock(ConstantBlock(block_name='dt', value=(dt)))
-		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
-		self.addBlock(HarmonicB(block_name='harmonic'))
-		
-		# Connect the blocks
-		self.addConnection('sin', 'sum')
-		self.addConnection('neg', 'sum')
-		self.addConnection('sum', 'abs')
-		self.addConnection('zero', 'int', input_port_name='IC')
-		self.addConnection('dt', 'int', input_port_name='delta_t')
-		self.addConnection('abs', 'int')
-		self.addConnection('int', 'e')
-		self.addConnection('harmonic', 'neg', output_port_name='x')
-		self.addConnection('dt', 'harmonic', input_port_name='dt')
-		self.addConnection('harmonic', 'B', output_port_name='x')
-		self.addConnection('sin', 'real')
-
-
-if __name__ == '__main__':
-	cbd = HarmonicA("HarmonicA")
-
-
-	# Run the simulation
-	sim = Simulator(cbd)
-	sim.setDeltaT(DELTA_T)
-	sim.run(1000)
-
-	# process simulation results
-	plot_signals(cbd, ['x'], 'A')
-

experiments/HarmonicOscilator/CBDA.py

@@ -5,10 +5,6 @@
 from CBD.Core import CBD
 from CBD.simulator import Simulator
 from CBD.lib.std import *
-DELTA_T = 0.01
-
-
-
 import matplotlib.pyplot as plt
 
 
@@ -32,41 +28,30 @@ def plot_signals(block, signals, title):
 	plt.show()
 
 
-
-
-class HarmonicB(CBD):
+class SinBlock(CBD):
 	def __init__(self, block_name):
-		CBD.__init__(self, block_name, input_ports=['dt'], output_ports=['x'])
-		
+		CBD.__init__(self, block_name, input_ports=[], output_ports=['OUT1'])
+
 		# Create the blocks
-		self.addBlock(DerivatorBlock(block_name='deriv1'))
-		self.addBlock(DerivatorBlock(block_name='deriv2'))
-		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
-		self.addBlock(ConstantBlock(block_name='one', value=(1)))
-		self.addBlock(NegatorBlock(block_name='neg'))
-		
+		self.addBlock(TimeBlock(block_name='time'))
+		self.addBlock(GenericBlock(block_name='sin', block_operator=("sin")))
+
 		# Connect the blocks
-		self.addConnection('dt', 'deriv1', input_port_name='delta_t')
-		self.addConnection('dt', 'deriv2', input_port_name='delta_t')
-		self.addConnection('zero', 'deriv1', input_port_name='IC')
-		self.addConnection('one', 'deriv2', input_port_name='IC')
-		self.addConnection('deriv1', 'x')
-		self.addConnection('deriv1', 'neg')
-		self.addConnection('neg', 'deriv2')
-		self.addConnection('deriv2', 'deriv1')
+		self.addConnection('time', 'sin')
+		self.addConnection('sin', 'OUT1')
 
 
 class HarmonicA(CBD):
 	def __init__(self, block_name):
 		CBD.__init__(self, block_name, output_ports=['x'])
-		
+
 		# Create the blocks
 		self.addBlock(IntegratorBlock(block_name='int2'))
 		self.addBlock(IntegratorBlock(block_name='int1'))
 		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
 		self.addBlock(ConstantBlock(block_name='one', value=(1)))
 		self.addBlock(NegatorBlock(block_name='neg'))
-		
+
 		# Connect the blocks
 		self.addConnection('zero', 'int2', input_port_name='IC')
 		self.addConnection('one', 'int1', input_port_name='IC')
@@ -78,8 +63,8 @@ class HarmonicA(CBD):
 
 class ErrorA(CBD):
 	def __init__(self, block_name):
-		CBD.__init__(self, block_name, input_ports=[], output_ports=['e', 'real', 'A'])
-		
+		CBD.__init__(self, block_name, input_ports=[], output_ports=['e', 'real', 'out'])
+
 		# Create the blocks
 		self.addBlock(SinBlock(block_name='sin'))
 		self.addBlock(NegatorBlock(block_name='neg'))
@@ -88,7 +73,7 @@ class ErrorA(CBD):
 		self.addBlock(IntegratorBlock(block_name='int'))
 		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
 		self.addBlock(HarmonicA(block_name='harmonic'))
-		
+
 		# Connect the blocks
 		self.addConnection('sin', 'sum')
 		self.addConnection('neg', 'sum')
@@ -98,25 +83,32 @@ class ErrorA(CBD):
 		self.addConnection('int', 'e')
 		self.addConnection('harmonic', 'neg', output_port_name='x')
 		self.addConnection('sin', 'real')
-		self.addConnection('harmonic', 'A', output_port_name='x')
+		self.addConnection('harmonic', 'out', output_port_name='x')
 
 
-class SinBlock(CBD):
+class HarmonicB(CBD):
 	def __init__(self, block_name):
-		CBD.__init__(self, block_name, input_ports=[], output_ports=['OUT1'])
+		CBD.__init__(self, block_name, input_ports=[], output_ports=['x'])
 		
 		# Create the blocks
-		self.addBlock(TimeBlock(block_name='time'))
-		self.addBlock(GenericBlock(block_name='sin', block_operator=("sin")))
+		self.addBlock(DerivatorBlock(block_name='deriv1'))
+		self.addBlock(DerivatorBlock(block_name='deriv2'))
+		self.addBlock(ConstantBlock(block_name='one', value=(1)))
+		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
+		self.addBlock(NegatorBlock(block_name='neg'))
 		
 		# Connect the blocks
-		self.addConnection('time', 'sin')
-		self.addConnection('sin', 'OUT1')
+		self.addConnection('one', 'deriv1', input_port_name='IC')
+		self.addConnection('zero', 'deriv2', input_port_name='IC')
+		self.addConnection('deriv1', 'deriv2')
+		self.addConnection('deriv2', 'neg')
+		self.addConnection('neg', 'deriv1')
+		self.addConnection('neg', 'x')
 
 
 class ErrorB(CBD):
-	def __init__(self, block_name, dt=(DELTA_T)):
-		CBD.__init__(self, block_name, input_ports=[], output_ports=['e', 'B', 'real'])
+	def __init__(self, block_name):
+		CBD.__init__(self, block_name, input_ports=[], output_ports=['e', 'out', 'real'])
 		
 		# Create the blocks
 		self.addBlock(SinBlock(block_name='sin'))
@@ -124,7 +116,6 @@ class ErrorB(CBD):
 		self.addBlock(AdderBlock(block_name='sum'))
 		self.addBlock(AbsBlock(block_name='abs'))
 		self.addBlock(IntegratorBlock(block_name='int'))
-		self.addBlock(ConstantBlock(block_name='dt', value=(dt)))
 		self.addBlock(ConstantBlock(block_name='zero', value=(0)))
 		self.addBlock(HarmonicB(block_name='harmonic'))
 		
@@ -133,42 +124,51 @@ class ErrorB(CBD):
 		self.addConnection('neg', 'sum')
 		self.addConnection('sum', 'abs')
 		self.addConnection('zero', 'int', input_port_name='IC')
-		self.addConnection('dt', 'int', input_port_name='delta_t')
 		self.addConnection('abs', 'int')
 		self.addConnection('int', 'e')
 		self.addConnection('harmonic', 'neg', output_port_name='x')
-		self.addConnection('dt', 'harmonic', input_port_name='dt')
-		self.addConnection('harmonic', 'B', output_port_name='x')
+		self.addConnection('harmonic', 'out', output_port_name='x')
 		self.addConnection('sin', 'real')
 
 
-from CBD.depGraph import gvDepGraph
 if __name__ == '__main__':
-	outputs = []
+	errors = []
 	signals = []
-	for dt in [0.1, 0.01]:
+	for dt in [0.1, 0.01, 0.001]:
 		print("DT:", dt)
-		cbd = ErrorA("ErrorA")
-		with open("test.gv", "w") as file:
-			file.write(gvDepGraph(cbd, 0))
-		# Run the simulation
-		sim = Simulator(cbd)
-		sim.setDeltaT(dt)
-		sim.run(int(50/dt))
-		tvpl = cbd.getSignalHistory("e")
-		outputs.append(tvpl)
 		signals.append(str(dt))
+
+		outputs = []
+		for cbd in [ErrorA("ErrorA"), ErrorB("ErrorB")]:
+			# Run the simulation
+			sim = Simulator(cbd)
+			sim.setDeltaT(dt)
+			sim.run(100.0)
+			errors.append(cbd.getSignalHistory("e"))
+			outputs.append(cbd.getSignalHistory("out"))
+			real = cbd.getSignalHistory('real')
+
 		print(" starting plotter")
-		plot_signals(cbd, ['real', 'A'], f'Value A ({dt})')
-
-	# plt.figure()
-	# plt.title("Error A")
-	# plt.xlabel('time')
-	# plt.ylabel('N')
-	# for i in range(3):
-	# 	time = [x for x, _ in outputs[i]]
-	# 	value = [x for _, x in outputs[i]]
-	# 	plt.plot(time, value, label=signals[i])
-	# plt.legend()
-	# plt.show()
+		plt.figure()
+		plt.title(f"Integrator vs Derivator (delta = {dt})")
+		plt.xlabel('time')
+		A, B = outputs
+		plt.plot([t for t, _ in real], [x for _, x in real], label="actual")
+		plt.plot([t for t, _ in A], [x for _, x in A], label="integrators")
+		plt.plot([t for t, _ in B], [x for _, x in B], label="derivators")
+		plt.legend()
+		plt.show()
+
+	plt.figure()
+	plt.title("Errors")
+	plt.xlabel('time')
+	plt.ylabel('N')
+	for i in range(3):
+		for j in range(2):
+			time = [x for x, _ in errors[(i*2)+j]]
+			value = [x for _, x in errors[(i*2)+j]]
+			plt.plot(time, value, label=("delta = " + signals[i] + "; " + "AB"[j]))
+	plt.yscale("log")
+	plt.legend()
+	plt.show()
 

experiments/LotkeVolterra/diagram.py

@@ -31,26 +31,26 @@ class LotkeVolterra(CBD):
         # self.addBlock(SignalCollectorBlock("foxes"))
 
         # Create the Connections
-        self.addConnection("x", "ax", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("x", "xy", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("y", "xy", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("y", "gy", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("gamma", "gy", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("xy", "bxy", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("xy", "dxy", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("beta", "bxy", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("alpha", "ax", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("ax", "sum1", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("bxy", "sum1", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("sum1", "x", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("sum1", "rabbits", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("delta", "dxy", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("dxy", "sum2", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("gy", "sum2", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("sum2", "y", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("sum2", "foxes", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("IC", "y", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("IC", "x", output_port_name='OUT1', input_port_name='IC')
+        self.addConnection("x", "ax", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("x", "xy", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("y", "xy", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("y", "gy", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("gamma", "gy", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("xy", "bxy", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("xy", "dxy", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("beta", "bxy", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("alpha", "ax", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("ax", "sum1", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("bxy", "sum1", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("sum1", "x", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("sum1", "rabbits", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("delta", "dxy", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("dxy", "sum2", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("gy", "sum2", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("sum2", "y", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("sum2", "foxes", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("IC", "y", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("IC", "x", input_port_name='IC', output_port_name='OUT1')
 
 
 class SinGen(CBD):
@@ -63,7 +63,7 @@ class SinGen(CBD):
         self.addBlock(SignalCollectorBlock("mySin"))
 
         # Create the Connections
-        self.addConnection("time", "sin", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("sin", "mySin", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("time", "sin", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("sin", "mySin", input_port_name='IN1', output_port_name='OUT1')
 
 

experiments/LotkeVolterra/diagram_experiment.py

@@ -14,8 +14,8 @@ END = 10.0
 cbd = LotkeVolterra("LotkeVolterra")
 
 cbd.addFixedRateClock("clock", DELTA_T)
-cbd.addConnection("clock-clock", "x", output_port_name="delta", input_port_name='delta_t')
-cbd.addConnection("clock-clock", "y", output_port_name="delta", input_port_name='delta_t')
+cbd.addConnection("clock-clock", "x", input_port_name='delta_t', output_port_name="delta")
+cbd.addConnection("clock-clock", "y", input_port_name='delta_t', output_port_name="delta")
 
 cbd.flatten()
 gvDraw(cbd, "lv.gv")

experiments/Oscilator/Oscilator.py

@@ -22,16 +22,16 @@ class Oscilator(CBD):
         self.addBlock(AdderBlock("sum"))
 
         # Create the Connections
-        self.addConnection("time", "cos1", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("time", "prod1", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("time", "sin1", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("time", "prod2", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("cos1", "prod1", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("prod1", "sin2", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("sin1", "prod2", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("prod2", "cos2", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("sin2", "sum", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("cos2", "sum", output_port_name='OUT1', input_port_name='IN2')
+        self.addConnection("time", "cos1", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("time", "prod1", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("time", "sin1", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("time", "prod2", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("cos1", "prod1", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("prod1", "sin2", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("sin1", "prod2", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("prod2", "cos2", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("sin2", "sum", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("cos2", "sum", input_port_name='IN2', output_port_name='OUT1')
         self.addConnection("sum", "y", output_port_name='OUT1')
 
 

experiments/RungeKutta/Test.py

@@ -17,16 +17,14 @@ class Test(CBD):
         self.addBlock(ProductBlock("mult"))
         self.addBlock(AdderBlock("sum"))
         self.addBlock(ConstantBlock("one", value=(1)))
-        self.addBlock(ConstantBlock("time", value=(DELTA_T)))
 
         # Create the Connections
-        self.addConnection("IC", "int", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("int", "mult", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("int", "mult", output_port_name='OUT1', input_port_name='IN2')
+        self.addConnection("IC", "int", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("int", "mult", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("int", "mult", input_port_name='IN2', output_port_name='OUT1')
         self.addConnection("int", "y", output_port_name='OUT1')
-        self.addConnection("mult", "sum", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("one", "sum", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("sum", "int", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("time", "int", output_port_name='OUT1', input_port_name='delta_t')
+        self.addConnection("mult", "sum", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("one", "sum", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("sum", "int", input_port_name='IN1', output_port_name='OUT1')
 
 

experiments/RungeKutta/Test_experiment.py

@@ -10,14 +10,34 @@ DELTA_T = 0.1
 
 cbd = Test("Test")
 
-# Run the Simulation
-sim = Simulator(cbd)
-sim.setDeltaT(DELTA_T)
+from CBD.preprocessing.butcher import ButcherTableau as BT
+from CBD.preprocessing.rungekutta import RKPreprocessor
+cbd.addFixedRateClock("clock", DELTA_T)
+tableau = BT.RKF45()
+RKP = RKPreprocessor(tableau, atol=2e-5, hmin=0.01, safety=.84)
+transformed = RKP.preprocess(cbd)
+sim = Simulator(transformed)
 sim.run(1.4)
 
-s = cbd.getSignalHistory("y")
+# Run the Simulation
+# sim = Simulator(cbd)
+# sim.setDeltaT(DELTA_T)
+# sim.run(1.4)
+
+s = transformed.getSignalHistory("y")
 L = len(s)
 
+import matplotlib.pyplot as plt
+
+plt.plot([t for t, _ in s], np.tan([t for t, _ in s]), color="green")
+plt.plot([t for t, _ in s], [x for _, x in s], color="blue")
+plt.plot([t for t, _ in s], [x for _, x in s], 'o', fillstyle='none', color="red")
+plt.show()
+
+T = [t for t, _ in s]
+DT = [T[i + 1] - T[i] for i in range(len(T) - 1)]
+print(min(DT), max(DT))
+
 print("+------------+------------+------------+------------+")
 print("|    TIME    |    VALUE   |    TAN T   |    ERROR   |")
 print("+------------+------------+------------+------------+")

experiments/dummy/myCBD.py

@@ -23,15 +23,15 @@ class myCBD_old(CBD):
         self.addBlock(SignalCollectorBlock("Op894edZgy93wgFImXR6-50"))
 
         # Create the Connections
-        self.addConnection("time", "prod1", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("time", "prod2", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("two", "prod1", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("halve", "prod2", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("prod1", "cos", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("cos", "prod3", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("prod2", "prod3", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("prod3", "sin", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("sin", "Op894edZgy93wgFImXR6-50", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("time", "prod1", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("time", "prod2", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("two", "prod1", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("halve", "prod2", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("prod1", "cos", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("cos", "prod3", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("prod2", "prod3", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("prod3", "sin", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("sin", "Op894edZgy93wgFImXR6-50", input_port_name='IN1', output_port_name='OUT1')
         self.addConnection("sin", "OUT1", output_port_name='OUT1')
 
 
@@ -51,15 +51,15 @@ class myCBD(CBD):
         self.addBlock(GenericBlock("cos", block_operator=("cos")))
 
         # Create the Connections
-        self.addConnection("zero", "int2", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("one", "int1", output_port_name='OUT1', input_port_name='IC')
-        self.addConnection("UJFjKf67PxYEY0ecBBqN-19", "int1", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("int1", "int2", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("zero", "int2", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("one", "int1", input_port_name='IC', output_port_name='OUT1')
+        self.addConnection("UJFjKf67PxYEY0ecBBqN-19", "int1", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("int1", "int2", input_port_name='IN1', output_port_name='OUT1')
         self.addConnection("int2", "x", output_port_name='OUT1')
-        self.addConnection("int2", "UJFjKf67PxYEY0ecBBqN-24", output_port_name='OUT1', input_port_name='IN2')
-        self.addConnection("int2", "UJFjKf67PxYEY0ecBBqN-19", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("four", "UJFjKf67PxYEY0ecBBqN-24", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("UJFjKf67PxYEY0ecBBqN-24", "cos", output_port_name='OUT1', input_port_name='IN1')
-        self.addConnection("cos", "signal", output_port_name='OUT1', input_port_name='IN1')
+        self.addConnection("int2", "UJFjKf67PxYEY0ecBBqN-24", input_port_name='IN2', output_port_name='OUT1')
+        self.addConnection("int2", "UJFjKf67PxYEY0ecBBqN-19", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("four", "UJFjKf67PxYEY0ecBBqN-24", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("UJFjKf67PxYEY0ecBBqN-24", "cos", input_port_name='IN1', output_port_name='OUT1')
+        self.addConnection("cos", "signal", input_port_name='IN1', output_port_name='OUT1')
 
 

src/CBD/Core.py

@@ -189,8 +189,9 @@ class BaseBlock:
 
     Args:
         name (str):             The name of the block. When empty, a :func:`CBD.util.hash64`
-                                encoded name of the instance :func:`id` will be used. When
-                                using non-alphanumeric characters, a warning will be shown.
+                                encoded name of the instance :func:`id` will be used, however
+                                this is a bad practice and will result in a warning. When
+                                using non-alphanumeric characters, a warning will also be shown.
         input_ports (iter):     List of input port names (strings).
         output_ports (iter):    List of output port names (strings).
     """
@@ -198,6 +199,10 @@ class BaseBlock:
         self.__block_name = hash64(id(self))
         if name != "":
             self.setBlockName(name)
+        else:
+            logger = logging.getLogger("CBD")
+            logger.warning("No block name given, using hashed object id. This is a bad practice and should be avoided.",
+                           extra={"block": self})
         if re.match(r"[^a-zA-Z0-9_]", self.__block_name):
             logger = logging.getLogger("CBD")
             logger.warning("Block names should only contain alphanumeric characters or underscores.", extra={"block": self})
@@ -392,7 +397,7 @@ class BaseBlock:
         # TODO: what with multiple sequential connectors
         return [p.getIncoming().source for p in self.getInputPorts() if p.getIncoming() is not None]
 
-    def getBlockConnectedToInput(self, input_port):
+    def getPortConnectedToInput(self, input_port):
         """
         Get the block that is connected to a specific input.
 
@@ -446,19 +451,19 @@ class BaseBlock:
         """
         raise NotImplementedError("BaseBlock has nothing to compute")
 
-    def linkToInput(self, in_block, name_input=None, name_output=None):
+    def linkToInput(self, in_block, *, name_input=None, name_output="OUT1"):
         """
         Links the output of the :code:`in_block` to the input of this block.
 
         Args:
             in_block (BaseBlock):   The block that must be linked before the current block.
+
+        Keyword Args:
             name_input (str):       The name of the input port. When :code:`None` or omitted,
                                     the next input port is used. E.g. if the last port was
                                     :code:`IN1`, the input is assumed to be :code:`IN2`.
             name_output (str):      The name of the output port. Defaults to :code:`OUT1`.
         """
-        if name_output is None:
-            name_output = "OUT1"
         if name_input is None:
             i = 1
             while True:
@@ -468,7 +473,7 @@ class BaseBlock:
                         name_input = nextIn
                         break
                 else:
-                    exit("There are no open IN inputs left in block %s" % self.getPath())
+                    raise ValueError("There are no open IN inputs left in block %s" % self.getPath())
                 i += 1
         if in_block.hasOutputPortWithName(name_output):
             source = in_block.getOutputPortByName(name_output)
@@ -550,7 +555,7 @@ class CBD(BaseBlock):
 
     def clone(self):
         # Clone all fields
-        other = BaseBlock.clone(self)
+        other: CBD = BaseBlock.clone(self)
         # other.setClock(deepcopy(self.getClock()))
 
         # Re-add all blocks to ensure deep cloning
@@ -567,9 +572,13 @@ class CBD(BaseBlock):
         for inp in self.getInputPorts():
             for target in inp.getOutgoing():
                 nxt = target.target
-                other.addConnection(other, nxt.block.getBlockName(), output_port_name=inp.name, input_port_name=nxt.name)
+                if other.getBlockName() == nxt.block.getBlockName():
+                    other.addConnection(inp.name, nxt.name)
+                else:
+                    other.addConnection(other, nxt.block.getBlockName(), output_port_name=inp.name, input_port_name=nxt.name)
         for out in self.getOutputPorts():
             prev = out.getIncoming().source
+            if other.getBlockName() == prev.block.getBlockName(): continue
             other.addConnection(prev.block.getBlockName(), other, output_port_name=prev.name, input_port_name=out.name)
         return other
 
@@ -611,7 +620,8 @@ class CBD(BaseBlock):
                     for conn in outgoing:
                         target = conn.target
                         Port.disconnect(port, target)
-                        self.addConnection(source.block, target.block, target.name, source.name)
+                        self.addConnection(source.block, target.block, input_port_name=target.name,
+                                           output_port_name=source.name)
                 self.removeBlock(block)
 
     def getBlocks(self):
@@ -695,6 +705,12 @@ class CBD(BaseBlock):
     def addBlock(self, block):
         """
         Add a block to the CBD model
+
+        Args:
+            block (BaseBlock):  The block to add.
+
+        Returns:
+            The block that was passed as an argument.
         """
         assert isinstance(block, BaseBlock), "Can only add BaseBlock (subclass) instances to a CBD"
         block.setParent(self)
@@ -709,6 +725,8 @@ class CBD(BaseBlock):
             logger = logging.getLogger("CBD")
             logger.warning("Did not add this block as it has the same name '%s' as an already existing block/port." % block.getBlockName(), extra={ "block":self})
 
+        return block
+
     def removeBlock(self, block):
         """
         Removes a block from the :class:`CBD`.
@@ -724,7 +742,7 @@ class CBD(BaseBlock):
         else:
             exit("Warning: did not remove this block %s as it was not found" % block.getBlockName())
 
-    def addConnection(self, from_block, to_block, input_port_name=None, output_port_name=None):
+    def addConnection(self, from_block, to_block, *, input_port_name=None, output_port_name="OUT1"):
         """
         Adds a connection between :code:`from_block` with :code:`input_port_name` to
         :code:`to_block` with :code:`outport_port_name`.
@@ -732,11 +750,16 @@ class CBD(BaseBlock):
         Args:
             from_block (str):       The block to start the connection from.
             to_block (str):         The target block of the connection.
+
+        Keyword Args:
             input_port_name (str):  The name of the input port. When :code:`None` or unset,
                                     the next port is used. E.g. when called after :code:`IN1`
                                     is already set, :code:`IN2` will be used.
-            output_port_name (str): The name of the output port. When not set or :code:`None`,
-                                    :code:`OUT1` will be used.
+            output_port_name (str): The name of the output port. Defaults to :code:`OUT1`.
+
+        Note:
+            Connecting from and to ports is possible by setting the :attr:`from_block` and/or
+            :attr:`to_block` arguments to the port names.
 
         See Also:
             :func:`BaseBlock.linkToInput`
@@ -753,7 +776,7 @@ class CBD(BaseBlock):
                 to_block = self
             else:
                 to_block = self.getBlockByName(to_block)
-        to_block.linkToInput(from_block, input_port_name, output_port_name)
+        to_block.linkToInput(from_block, name_input=input_port_name, name_output=output_port_name)
 
     def getDependencies(self, curIteration):
         deps = []

src/CBD/converters/eq2CBD/__init__.py

@@ -168,7 +168,7 @@ class EqFunctions:
 		block = RootBlock("")
 		self.model.addBlock(two)
 		self.model.addBlock(block)
-		self.model.addConnection(two, block, "IN2")
+		self.model.addConnection(two, block, input_port_name="IN2")
 		return block, 1
 
 	def clamp(self):
@@ -221,7 +221,7 @@ class EqTransformer(Transformer):
 		if isinstance(what, Token) and what.type == "VNAME":
 			self.linkVar(what.value, (to, ipn))
 		else:
-			self.model.addConnection(what, to, ipn, opn)
+			self.model.addConnection(what, to, input_port_name=ipn, output_port_name=opn)
 
 	def linkVar(self, name, to):
 		self.vars[name].append(to)
@@ -236,7 +236,7 @@ class EqTransformer(Transformer):
 		for var, cons in self.vars.items():
 			from_ = self.var_results[var]
 			for con, ipn in cons:
-				self.model.addConnection(from_, con, ipn, None)
+				self.model.addConnection(from_, con, input_port_name=ipn, output_port_name=None)
 		return self.model
 
 	def eqn(self, items):

src/CBD/converters/hybrid.py

@@ -487,7 +487,7 @@ def prepare_cbd(model, initials):
 	cbd.addBlock(MinBlock(Mname))
 	clock = cbd.getClock()
 	cbd.addConnection(Hname, Mname)
-	cbd.addConnection(clock.getBlockConnectedToInput('h').block, Mname)
+	cbd.addConnection(clock.getPortConnectedToInput('h').block, Mname)
 	cbd.addConnection(Mname, clock, input_port_name='h')
 	return cbd, Hname
 

src/CBD/converters/latexify/CBD2Latex.py

@@ -32,7 +32,7 @@ class CBD2Latex:
 								be appended to values that have been computed for a delay
 								block. This is only to be used when the time does not
 								identify the iteration, but the actual simulation time.
-								Defaults to the empty string.
+								Defaults to :code:`'i'`.
 		replace_par (bool):     When :code:`True`, the parentheses will be replaced by the
 								much cleaner :code:`\\left(` and :code:`\\right)`, if rendered
 								in LaTeX-format. Defaults to :code:`True`.
@@ -55,7 +55,7 @@ class CBD2Latex:
 		"time_variable": 'i',
 		"render_latex": True,
 		"time_format": "({time})",
-		"delta_t": "",
+		"delta_t": "i",
 		"replace_par": True,
 		"type_formats": {},
 		"path_sep": '.',
@@ -176,7 +176,7 @@ class CBD2Latex:
 			eqs = eq.at(time)
 			for e in eqs:
 				eq_time_fmt, time_fmt = self._get_time_formats(e)
-				res += e.eq().format(T=time_fmt, E=eq_time_fmt, dt=self.config["time_variable"]) + '\n'
+				res += e.eq().format(T=time_fmt, E=eq_time_fmt, dt=self.config["delta_t"]) + '\n'
 		return res
 
 	def latex(self):
@@ -188,7 +188,7 @@ class CBD2Latex:
 			eqs = eq.at(Time.now())
 			for e in eqs:
 				eq_time_fmt, time_fmt = self._get_time_formats(e)
-				res += e.latex().format(T=time_fmt, E=eq_time_fmt, dt=self.config["time_variable"]) + '\\\\\n'
+				res += e.latex().format(T=time_fmt, E=eq_time_fmt, dt=self.config["delta_t"]) + '\\\\\n'
 		return res
 
 	def _get_time_formats(self, e):

src/CBD/converters/latexify/functions.py

@@ -273,7 +273,7 @@ class MultiFnc(Fnc):
 		const = ConstantFnc("C", unary, self.time, self.eq_time)
 		counts = {}
 		for arg in self.args:
-			if isinstance(arg, ConstantFnc):
+			if isinstance(arg, ConstantFnc) and isinstance(arg.val, (int, float)):
 				if self.name == '+':
 					const.val += arg.val
 				elif self.name == '*':

src/CBD/lib/std.py

@@ -4,11 +4,18 @@ This file contains the standard library for CBD building blocks.
 from CBD.Core import BaseBlock, CBD
 import math
 
-__all__ = ['ConstantBlock', 'NegatorBlock', 'InverterBlock', 'AdderBlock', 'ProductBlock', 'ModuloBlock',
-           'RootBlock', 'AbsBlock', 'IntBlock', 'ClampBlock', 'GenericBlock', 'MultiplexerBlock', 'LessThanBlock',
-           'EqualsBlock', 'LessThanOrEqualsBlock', 'NotBlock', 'OrBlock', 'AndBlock', 'DelayBlock', 'LoggingBlock',
-           'AddOneBlock', 'DerivatorBlock', 'IntegratorBlock', 'SplitBlock', 'Clock', 'TimeBlock', 'PowerBlock',
-           'MaxBlock', 'MinBlock', 'DummyClock', 'SequenceBlock', 'DeltaTBlock']
+__all__ = ['ConstantBlock', 'NegatorBlock', 'InverterBlock',
+           'AdderBlock', 'ProductBlock',
+           'ModuloBlock', 'RootBlock', 'PowerBlock',
+           'AbsBlock', 'IntBlock', 'ClampBlock',
+           'GenericBlock',
+           'MinBlock', 'MaxBlock',
+           'LessThanBlock', 'EqualsBlock', 'LessThanOrEqualsBlock',
+           'NotBlock', 'OrBlock', 'AndBlock',
+           'MultiplexerBlock', 'SplitBlock',
+           'DelayBlock', 'DeltaTBlock', 'TimeBlock', 'LoggingBlock',
+           'AddOneBlock', 'DerivatorBlock', 'IntegratorBlock',
+           'Clock', 'DummyClock', 'SequenceBlock']
 
 class ConstantBlock(BaseBlock):
 	"""
@@ -38,7 +45,6 @@ class ConstantBlock(BaseBlock):
 		self.__value = value
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		self.appendToSignal(self.getValue())
 
 	def __repr__(self):  # pragma: no cover
@@ -62,7 +68,6 @@ class NegatorBlock(BaseBlock):
 		BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		self.appendToSignal(-self.getInputSignal(curIteration, "IN1").value)
 
 
@@ -90,7 +95,6 @@ class InverterBlock(BaseBlock):
 		self._tolerance = tolerance
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		input = self.getInputSignal(curIteration, "IN1").value
 		if abs(input) < self._tolerance:
 			raise ZeroDivisionError("InverterBlock '{}' received input less than {}.".format(self.getPath(), self._tolerance))
@@ -118,7 +122,6 @@ class AdderBlock(BaseBlock):
 		self.__numberOfInputs = numberOfInputs
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		result = 0
 		for i in range(1, self.__numberOfInputs+1):
 			result += self.getInputSignal(curIteration, "IN%d"%i).value
@@ -152,7 +155,6 @@ class ProductBlock(BaseBlock):
 		self.__numberOfInputs = numberOfInputs
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		result = 1
 		for i in range(1, self.__numberOfInputs+1):
 			result *= self.getInputSignal(curIteration, "IN%d"%i).value
@@ -186,7 +188,6 @@ class ModuloBlock(BaseBlock):
 		BaseBlock.__init__(self, block_name, ["IN1", "IN2"], ["OUT1"])
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		# Use 'math.fmod' for validity with C w.r.t. negative values AND floats
 		self.appendToSignal(math.fmod(self.getInputSignal(curIteration, "IN1").value, self.getInputSignal(curIteration, "IN2").value))
 
@@ -220,7 +221,6 @@ class RootBlock(BaseBlock):
 		self._tolerance = tolerance
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		input = self.getInputSignal(curIteration, "IN2").value
 		if abs(input) < self._tolerance:
 			raise ZeroDivisionError("RootBlock '{}' received input less than {}.".format(self.getPath(), self._tolerance))
@@ -249,7 +249,6 @@ class PowerBlock(BaseBlock):
 		BaseBlock.__init__(self, block_name, ["IN1", "IN2"], ["OUT1"])
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		self.appendToSignal(self.getInputSignal(curIteration, "IN1").value ** self.getInputSignal(curIteration, "IN2").value)
 
 
@@ -270,7 +269,6 @@ class AbsBlock(BaseBlock):
 		BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		self.appendToSignal(abs(self.getInputSignal(curIteration).value))
 
 
@@ -376,7 +374,6 @@ class GenericBlock(BaseBlock):
 		return self.__block_operator
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		a = self.getInputSignal(curIteration, "IN1").value
 		self.appendToSignal(getattr(math, self.getBlockOperator())(a))
 
@@ -440,9 +437,9 @@ class MultiplexerBlock(BaseBlock):
 		return self.__numberOfInputs
 
 
-class MaxBlock(BaseBlock):
+class MinBlock(BaseBlock):
 	"""
-	The max block will output the maximal value of all its inputs.
+	The min block will output the minimal value of all its inputs.
 
 	Args:
 		block_name (str):       The name of the block.
@@ -454,18 +451,17 @@ class MaxBlock(BaseBlock):
 		- ...
 
 	:Output Ports:
-		**OUT1** -- The maximal value of all inputs.
+		**OUT1** -- The minimal value of all inputs.
 	"""
 	def __init__(self, block_name, numberOfInputs=2):
 		BaseBlock.__init__(self, block_name, ["IN%d" % (x+1) for x in range(numberOfInputs)], ["OUT1"])
 		self.__numberOfInputs = numberOfInputs
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		result = []
 		for i in range(1, self.__numberOfInputs+1):
 			result.append(self.getInputSignal(curIteration, "IN%d"%i).value)
-		self.appendToSignal(max(result))
+		self.appendToSignal(min(result))
 
 	def getNumberOfInputs(self):
 		"""
@@ -474,9 +470,9 @@ class MaxBlock(BaseBlock):
 		return self.__numberOfInputs
 
 
-class MinBlock(BaseBlock):
+class MaxBlock(BaseBlock):
 	"""
-	The min block will output the minimal value of all its inputs.
+	The max block will output the maximal value of all its inputs.
 
 	Args:
 		block_name (str):       The name of the block.
@@ -488,18 +484,17 @@ class MinBlock(BaseBlock):
 		- ...
 
 	:Output Ports:
-		**OUT1** -- The minimal value of all inputs.
+		**OUT1** -- The maximal value of all inputs.
 	"""
 	def __init__(self, block_name, numberOfInputs=2):
 		BaseBlock.__init__(self, block_name, ["IN%d" % (x+1) for x in range(numberOfInputs)], ["OUT1"])
 		self.__numberOfInputs = numberOfInputs
 
 	def compute(self, curIteration):
-		# TO IMPLEMENT
 		result = []
 		for i in range(1, self.__numberOfInputs+1):
 			result.append(self.getInputSignal(curIteration, "IN%d"%i).value)
-		self.appendToSignal(min(result))
+		self.appendToSignal(max(result))
 
 	def getNumberOfInputs(self):
 		"""
@@ -789,38 +784,46 @@ class DelayBlock(BaseBlock):
 			self.appendToSignal(self.getInputSignal(curIteration - 1).value)
 
 
-import logging
-class LoggingBlock(BaseBlock):
+class DeltaTBlock(BaseBlock):
 	"""
-	A simple logging block that logs a string if the input is *truthy*.
+	Helperblock that will always output the current time delta, even when using
+	adaptive step-size simulation.
 
 	Args:
 		block_name (str):   The name of the block.
-		string (str):       The string to log.
-		lev (int):          The level at which to log. Defaults to :data:`logging.WARNING`.
-		logger (str):       The name of the logger. Defaults to :code:`CBDLogger`.
+		min (numeric):      The minimal value of the allowed delta T. Note that
+							setting this argument will result in possibly invalid
+							results. Defaults to 0.
 
-	:Input Ports:
-		**IN1** -- The input.
+	:Output Ports:
+		**OUT1** -- The current time-delta.
+
+	Note:
+		Technically, this block is extraneous, as it re-uses information from
+		the :class:`Clock`. However, it is meant to simplify the usage of time
+		in CBD models. In general, this block is therefore preferred over the
+		:code:`Clock` (unless you really know what you're doing).
+
+	Warning:
+		For fixed step-size iterations, you may need to use this block for
+		*frame-independent logic* (as it is called in the videogame-world)
+		to ensure correct behaviour.
 
 	See Also:
-		`Truthy and Falsy values in Python <https://docs.python.org/3/library/stdtypes.html#truth-value-testing>`_
+		- :class:`TimeBlock`
+		- :class:`Clock`
+		- `<https://drewcampbell92.medium.com/understanding-delta-time-b53bf4781a03>`_
 	"""
-	def __init__(self, block_name, string, lev=logging.WARNING, logger="CBD"):
-		BaseBlock.__init__(self, block_name, ["IN1"], [])
-		self.__string = string
-		self.__logger = logging.getLogger(logger)
-		self.__lev = lev
+	def __init__(self, block_name, min=0.0):
+		BaseBlock.__init__(self, block_name, [], ["OUT1"])
+		self.min = min
+
+	def getValue(self):
+		"""Obtains the current time delta."""
+		return self.getClock().getDeltaT()
 
 	def compute(self, curIteration):
-		if self.getInputSignal(curIteration, "IN1").value:
-			simtime = str(self.getClock().getTime(-1))
-			if self.__lev == logging.WARNING:
-				self.__logger.warning("[" + simtime + "]  " + self.__string, extra={"block": self})
-			elif self.__lev == logging.ERROR:
-				self.__logger.error("[" + simtime + "]  " + self.__string, extra={"block": self})
-			elif self.__lev == logging.CRITICAL:
-				self.__logger.critical("[" + simtime + "]  " + self.__string, extra={"block": self})
+		self.appendToSignal(max(self.getValue(), self.min))
 
 
 class TimeBlock(BaseBlock):
@@ -856,6 +859,40 @@ class TimeBlock(BaseBlock):
 		self.appendToSignal(rel_time, "relative")
 
 
+import logging
+class LoggingBlock(BaseBlock):
+	"""
+	A simple logging block that logs a string if the input is *truthy*.
+
+	Args:
+		block_name (str):   The name of the block.
+		string (str):       The string to log.
+		lev (int):          The level at which to log. Defaults to :data:`logging.WARNING`.
+		logger (str):       The name of the logger. Defaults to :code:`CBDLogger`.
+
+	:Input Ports:
+		**IN1** -- The input.
+
+	See Also:
+		`Truthy and Falsy values in Python <https://docs.python.org/3/library/stdtypes.html#truth-value-testing>`_
+	"""
+	def __init__(self, block_name, string, lev=logging.WARNING, logger="CBD"):
+		BaseBlock.__init__(self, block_name, ["IN1"], [])
+		self.__string = string
+		self.__logger = logging.getLogger(logger)
+		self.__lev = lev
+
+	def compute(self, curIteration):
+		if self.getInputSignal(curIteration, "IN1").value:
+			simtime = str(self.getClock().getTime(-1))
+			if self.__lev == logging.WARNING:
+				self.__logger.warning("[" + simtime + "]  " + self.__string, extra={"block": self})
+			elif self.__lev == logging.ERROR:
+				self.__logger.error("[" + simtime + "]  " + self.__string, extra={"block": self})
+			elif self.__lev == logging.CRITICAL:
+				self.__logger.critical("[" + simtime + "]  " + self.__string, extra={"block": self})
+
+
 class AddOneBlock(CBD):
 	"""
 	Helperblock that adds 1 to the input. It is included as an example on how to
@@ -900,8 +937,7 @@ class DerivatorBlock(CBD):
 	"""
 	def __init__(self, block_name):
 		CBD.__init__(self, block_name, ["IN1", "IC"], ["OUT1"])
-		# TO IMPLEMENT
-		self.addBlock(DeltaTBlock(block_name="delta_t"))
+		self.addBlock(DeltaTBlock(block_name="delta_t", min=1e-6))
 		self.addBlock(ProductBlock(block_name="multIc"))
 		self.addBlock(NegatorBlock(block_name="neg1"))
 		self.addBlock(AdderBlock(block_name="sum1"))
@@ -966,44 +1002,6 @@ class IntegratorBlock(CBD):
 		self.addConnection("sumState", "OUT1")
 
 
-class DeltaTBlock(BaseBlock):
-	"""
-	Helperblock that will always output the current time delta, even when using
-	adaptive step-size simulation.
-
-	Args:
-		block_name (str):   The name of the block.
-
-	:Output Ports:
-		**OUT1** -- The current time-delta.
-
-	Note:
-		Technically, this block is extraneous, as it re-uses information from
-		the :class:`Clock`. However, it is meant to simplify the usage of time
-		in CBD models. In general, this block is therefore preferred over the
-		:code:`Clock` (unless you really know what you're doing).
-
-	Warning:
-		For fixed step-size iterations, you may need to use this block for
-		*frame-independent logic* (as it is called in the videogame-world)
-		to ensure correct behaviour.
-
-	See Also:
-		- :class:`TimeBlock`
-		- :class:`Clock`
-		- `<https://drewcampbell92.medium.com/understanding-delta-time-b53bf4781a03>`_
-	"""
-	def __init__(self, block_name):
-		BaseBlock.__init__(self, block_name, [], ["OUT1"])
-
-	def getValue(self):
-		"""Obtains the current time delta."""
-		return self.getClock().getDeltaT()
-
-	def compute(self, curIteration):
-		self.appendToSignal(self.getValue())
-
-
 class Clock(CBD):
 	"""
 	System clock. **Must be present in a simulation model.**

src/CBD/loopsolvers/linearsolver.py

@@ -96,7 +96,7 @@ class LinearSolver(Solver):
 		for block in strongComponent:
 			for inp in block.getInputPorts():
 				fblock = inp.getPreviousPortClosure().block
-				# fblock = block.getBlockConnectedToInput(inp.name).block
+				# fblock = block.getPortConnectedToInput(inp.name).block
 				if fblock not in strongComponent:
 					val = inp.getHistory()[curIteration].value
 					known[block.getPath(sep) + sep + inp.name] = val
@@ -133,7 +133,7 @@ class LinearSolver(Solver):
 						M2[i] -= known[external.getPath(sep)]
 					else:
 						for inp in block.getInputPortNames():
-							if block.getBlockConnectedToInput(inp).block == external:
+							if block.getPortConnectedToInput(inp).block == external:
 								path = block.getPath(sep) + sep + inp
 								M2[i] = _StrVar(str(M2[i]) + " - " + known.get(path, path))
 								break
@@ -150,7 +150,7 @@ class LinearSolver(Solver):
 						fact *= known[external.getPath(sep)]
 					else:
 						for inp in block.getInputPortNames():
-							if block.getBlockConnectedToInput(inp).block == external:
+							if block.getPortConnectedToInput(inp).block == external:
 								path = block.getPath(sep) + sep + inp
 								fact = _StrVar(str(fact) + " * " + known.get(path, path))
 								break
@@ -166,7 +166,7 @@ class LinearSolver(Solver):
 				# And so the dependency is the IC
 				# M2 can stay 0 because we have an equation of the type -x = -ic <=> -x + ic = 0
 				M1[i, i] = -1
-				possibleDep = block.getBlockConnectedToInput("IC")
+				possibleDep = block.getPortConnectedToInput("IC")
 				dependency = possibleDep.block
 				assert dependency in strongComponent
 				M1[i, indexdict[dependency]] = 1

src/CBD/loopsolvers/sympysolver.py

@@ -91,9 +91,9 @@ class SympySolver(Solver):
 	def __dependencies(block):
 		blocks = []
 		for s in block.getInputPortNames():
-			b, op = block.getBlockConnectedToInput(s)
+			b, op = block.getPortConnectedToInput(s)
 			while isinstance(b, CBD):
-				b, op = b.getBlockByName(op).getBlockConnectedToInput("IN1")
+				b, op = b.getBlockByName(op).getPortConnectedToInput("IN1")
 			blocks.append((b, op))
 		return blocks
 

src/CBD/preprocessing/rungekutta.py

@@ -79,11 +79,11 @@ class RKPreprocessor:
 		new_model.addBlock(RK)
 		for inp in inputs:
 			if RK.hasBlock(inp):
-				new_model.addConnection(inp, RK, inp)
+				new_model.addConnection(inp, RK, input_port_name=inp)
 		old_clock = original.getClock()
 		new_model.addBlock(Clock("clock", old_clock.getTime(0) - old_clock.getRelativeTime(0)))
-		new_model.addConnection("clock", RK, 'time', 'time')
-		new_model.addConnection("clock", RK, 'rel_time', 'rel_time')
+		new_model.addConnection("clock", RK, input_port_name='time', output_port_name='time')
+		new_model.addConnection("clock", RK, input_port_name='rel_time', output_port_name='rel_time')
 		if RK.hasBlock("h_new"):
 			# TODO: take delta from original
 			new_model.addBlock(ConstantBlock("HIC", self._h_range[1]))
@@ -95,12 +95,13 @@ class RKPreprocessor:
 		else:
 			# TODO: take delta from original
 			new_model.addBlock(ConstantBlock("clock-delta", self._h_range[0]))
-			new_model.addConnection("clock-delta", "clock", "h")
-			new_model.addConnection("clock-delta", RK, "h")
+			new_model.addConnection("clock-delta", "clock", input_port_name="h")
+			new_model.addConnection("clock-delta", RK, input_port_name="h")
 		for itg_name, p in plinks.items():
 			itg = original.find(itg_name)[0]
-			if "IC" in itg.getLinksIn():
-				ic, icop = itg.getBlockConnectedToInput("IC")
+			if "IC" in itg.getInputPortNames():
+				icop = itg.getPortConnectedToInput("IC")
+				ic = icop.block
 				collection = self.collect(ic, finish=[IntegratorBlock, Clock, TimeBlock])
 				if not new_model.hasBlock(ic.getBlockName()):
 					new_model.addBlock(ic.clone())
@@ -110,27 +111,33 @@ class RKPreprocessor:
 				for block in collection:
 					cs = block.getInputPortNames()
 					for c in cs:
-						cb, op = block.getBlockConnectedToInput(c)
+						cb, op = block.getPortConnectedToInput(c)
 						if cb.getBlockName() in plinks:
 							raise ValueError("Too complex Initial Condition for integrator %s" % cb.getBlockName())
 						elif cb.getBlockType() == "TimeBlock":
-							new_model.addConnection("clock", block.getBlockName(), c, "time")
+							new_model.addConnection("clock", block.getBlockName(), input_port_name=c,
+							                        output_port_name="time")
 						elif cb.getBlockType() == "Clock":
-							new_model.addConnection("clock", block.getBlockName(), c, op)
+							new_model.addConnection("clock", block.getBlockName(), input_port_name=c,
+							                        output_port_name=op)
 						else:
-							new_model.addConnection(cb.getBlockName(), block.getBlockName(), c, op)
-						new_model.addConnection(cb.getBlockName(), block.getBlockName(), c, op)
-				new_model.addConnection(ic.getBlockName(), RK, "IC%d" % p, icop)
+							new_model.addConnection(cb.getBlockName(), block.getBlockName(), input_port_name=c,
+							                        output_port_name=op)
+						new_model.addConnection(cb.getBlockName(), block.getBlockName(), input_port_name=c,
+						                        output_port_name=op)
+				new_model.addConnection(ic.getBlockName(), RK, input_port_name="IC%d" % p, output_port_name=icop.name)
 			else:
 				new_model.addBlock(ConstantBlock("RK-IC%d" % p))
-				new_model.addConnection("RK-IC%d" % p, RK, "IC%d" % p)
+				new_model.addConnection("RK-IC%d" % p, RK, input_port_name="IC%d" % p)
 
 		for y in outputs:
-			itg, mop = original.getBlockByName(y).getBlockConnectedToInput("IN1")
+			mop = original.getOutputPortByName(y).getIncoming().source
+			itg = mop.block
 			prefix = ""
 			while isinstance(itg, CBD) and itg.getBlockType() != "IntegratorBlock":
 				prefix = prefix + itg.getBlockName() + "."
-				itg, mop = itg.getBlockByName(mop).getBlockConnectedToInput("IN1")
+				mop = itg.getOutputPortByName(y).getIncoming().source
+				itg = mop.block
 			assert itg.getBlockType() == "IntegratorBlock"
 			p = plinks[prefix + itg.getBlockName()]
 			new_model.addConnection(RK, y, output_port_name="OUT%d" % p)
@@ -160,10 +167,11 @@ class RKPreprocessor:
 			finish = []
 		if visited is None:
 			visited = []
-		collection = [x[1].block for x in start.getLinksIn().items() if \
-		              ((sport is not None and x[0] in sport) or (sport is None)) \
-			            and not x[1].block in visited \
-		                and not isinstance(x[1].block, tuple(finish))]
+		collection = []
+		for x in (sport if sport is not None else start.getInputPortNames()):
+			block = start.getPortConnectedToInput(x).block
+			if not block in visited and not isinstance(block, tuple(finish)):
+				collection.append(block)
 		n_collection = [x.getBlockName() for x in collection]
 		for block in collection:
 			ccoll = self.collect(block, None, finish, list(visited) + [block])
@@ -226,9 +234,10 @@ class RKPreprocessor:
 
 			# Next, link the blocks
 			for child in collection:
-				for name_input, link in child.getLinksIn().items():
+				for name_input in child.getInputPortNames():
+					link = child.getPortConnectedToInput(name_input)
 					lbn = link.block.getBlockName()
-					lop = link.output_port
+					lop = link.name
 					if not IVP.hasBlock(lbn):
 						# Both the TimeBlock and the Clock's time output will be explicitly inputted,
 						# hence, it is the predefined port
@@ -245,14 +254,14 @@ class RKPreprocessor:
 							lbn = name_input + "-" + child.getBlockName()
 							IVP.addInputPort(lbn)
 						lop = None
-					IVP.addConnection(lbn, child.getBlockName(), name_input, lop)
+					IVP.addConnection(lbn, child.getBlockName(), input_port_name=name_input, output_port_name=lop)
 			# Link the output
 			p = plinks[block.getBlockName()]
-			fin = block.getBlockConnectedToInput("IN1")
+			fin = block.getPortConnectedToInput("IN1")
 			fname = fin.block.getBlockName()
 			if fname in plinks:
 				fname = "IN%d" % plinks[fname]
-			IVP.addConnection(fname, "OUT%d" % p, None, fin.output_port)
+			IVP.addConnection(fname, "OUT%d" % p, input_port_name=None, output_port_name=fin.name)
 		return IVP, plinks
 
 	def create_RK(self, f):
@@ -294,7 +303,7 @@ class RKPreprocessor:
 			j = i + 1
 			RK.addBlock(self.create_K(j, f.clone()))
 			for inp in inpnames:
-				RK.addConnection(inp, "RK-K_%d" % j, inp)
+				RK.addConnection(inp, "RK-K_%d" % j, input_port_name=inp)
 			for y in fy:
 				RK.addConnection("delay_%d" % y, "RK-K_%d" % j, input_port_name='IN%d' % y)
 			for p in range(len(weights)):
@@ -305,20 +314,20 @@ class RKPreprocessor:
 					RK.addConnection("B%d_%d" % (q, j), "Mult%d_%d_%d" % (q, y, j))
 					RK.addConnection("RK-K_%d" % j, "Mult%d_%d_%d" % (q, y, j), output_port_name="OUT%d" % y)
 					RK.addConnection("Mult%d_%d_%d" % (q, y, j), "RKSum_%d_%d" % (q, y))
-			RK.addConnection("h", "RK-K_%d" % j, "h")
-			RK.addConnection("time", "RK-K_%d" % j, "time")
-			RK.addConnection("rel_time", "RK-K_%d" % j, "rel_time")
+			RK.addConnection("h", "RK-K_%d" % j, input_port_name="h")
+			RK.addConnection("time", "RK-K_%d" % j, input_port_name="time")
+			RK.addConnection("rel_time", "RK-K_%d" % j, input_port_name="rel_time")
 			for s in range(i):
-				RK.addConnection("RK-K_%d" % (s+1), "RK-K_%d" % j, "k_%d" % (s+1))
+				RK.addConnection("RK-K_%d" % (s + 1), "RK-K_%d" % j, input_port_name="k_%d" % (s + 1))
 
 		# Error Computation
 		if len(weights) == 2:
 			RK.addOutputPort("h_new")
 			RK.addBlock(self.create_Error(len(fy)))
 			for y in fy:
-				for q in range(len(weights)):
-					RK.addConnection("YSum_1_%d" % y, "error", "y_%d" % y)
-					RK.addConnection("YSum_2_%d" % y, "error", "z_%d" % y)
+				# for q in range(len(weights)):
+				RK.addConnection("YSum_1_%d" % y, "error", input_port_name="y_%d" % (y))
+				RK.addConnection("YSum_2_%d" % y, "error", input_port_name="z_%d" % (y))
 			RK.addConnection("h", "error", input_port_name="h")
 			RK.addConnection("error", "h_new", output_port_name='h_new')
 
@@ -351,8 +360,8 @@ class RKPreprocessor:
 		K.addConnection("C", "CMult")
 		K.addConnection("time", "CSum")
 		K.addConnection("CMult", "CSum")
-		K.addConnection("CSum", f.getBlockName(), "time")
-		K.addConnection("rel_time", f.getBlockName(), "rel_time")
+		K.addConnection("CSum", f.getBlockName(), input_port_name="time")
+		K.addConnection("rel_time", f.getBlockName(), input_port_name="rel_time")
 
 		# Y parameters
 		if s - 1 > 0:
@@ -369,12 +378,12 @@ class RKPreprocessor:
 					K.addBlock(AdderBlock("YSum-%s" % y))
 					K.addConnection(y, "YSum-%s" % y)
 					K.addConnection("KSum", "YSum-%s" % y)
-					K.addConnection("YSum-%s" % y, f.getBlockName(), y)
+					K.addConnection("YSum-%s" % y, f.getBlockName(), input_port_name=y)
 				else:
-					K.addConnection(y, f.getBlockName(), y)
+					K.addConnection(y, f.getBlockName(), input_port_name=y)
 		else:
 			for y in fy:
-				K.addConnection(y, f.getBlockName(), y)
+				K.addConnection(y, f.getBlockName(), input_port_name=y)
 
 		# Finishing Up
 		outputs = f.getSignals().keys()

src/CBD/realtime/threadingBackend.py

@@ -140,3 +140,14 @@ class ThreadingBackend:
             self._subsystem.step(time)
         else:
             self._subsystem.step()
+
+    def run_on_new_thread(self, func, args=()):
+        """
+        Runs a function on a new thread.
+        Args:
+            func (callable):    The function to execute.
+            args (iter):        The arguments for the function.
+        """
+        p = threading.Thread(target=func, args=args)
+        p.daemon = True
+        p.start()

src/CBD/realtime/threadingPython.py

@@ -22,7 +22,7 @@ class ThreadingPython(object):
     """
     def wait(self, time, func):
         """
-        Wait for the specified time.
+        Wait for the specified time before executing :attr:`func`.
 
         Args:
             time (float):       Time to wait.

src/CBD/realtime/threadingTkInter.py

@@ -25,7 +25,7 @@ class ThreadingTkInter:
 
     def wait(self, time, func):
         """
-        Wait for the specified time.
+        Wait for the specified time to execute :attr:`func`.
 
         Args:
             time (float):       Time to wait.

src/CBD/simulator.py

@@ -153,8 +153,8 @@ class Simulator:
 			self.__realtime_start_time = time.time()
 			self.__lasttime = 0.0
 
-		self.__threading_backend.wait(0.0, self.__tracer.thread_loop)
-		self.__threading_backend.wait(0.0, self.__event_thread_loop)
+		self.__threading_backend.run_on_new_thread(self.__tracer.thread_loop)
+		self.__threading_backend.run_on_new_thread(self.__event_thread_loop)
 		self.signal("started")
 		if self.__realtime:
 			# Force execute the first iteration now. This way iteration n (n > 0) is

src/CBD/state_events/locators.py

@@ -122,7 +122,7 @@ class StateEventLocator:
 		"""
 		# TODO: make this work for non-fixed rate clocks?
 		clock = self.sim.model.getClock()
-		clock.getBlockConnectedToInput("h").block.setValue(dt)
+		clock.getPortConnectedToInput("h").block.setValue(dt)
 
 	def run(self, output_name, level=0.0, direction=Direction.ANY):
 		"""

src/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 setup(name="CBD",
-      version="1.4",
+      version="1.5",
       description="Python CBD simulator",
       author=", ".join([
 	      "Marc Provost <Marc.Provost@mail.mcgill.ca>",

src/test/flattenCBDTest.py

@@ -46,7 +46,7 @@ class FlattenCBDTest(unittest.TestCase):
 		
 		self.CBD.addBlock(CBDLittle1)
 		self.CBD.addBlock(CBDLittle2)
-		self.CBD.addConnection("first_child", "second_child", input_port_name = "inCBD2", output_port_name = "outCBD1") 
+		self.CBD.addConnection("first_child", "second_child", input_port_name="inCBD2", output_port_name="outCBD1")
 
 		CBDLittle1.addBlock(ConstantBlock(block_name="c1", value=2.0))
 		CBDLittle1.addConnection("c1", "outCBD1")
@@ -81,10 +81,10 @@ class FlattenCBDTest(unittest.TestCase):
 		self.CBD.addBlock(CBDConstant2)
 		self.CBD.addBlock(CBDAdder)
 		self.CBD.addBlock(CBDProduct)
-		self.CBD.addConnection("constantCBD1", "adderCBD", input_port_name="in1Add", output_port_name = "outConstant1")
-		self.CBD.addConnection("productCBD", "adderCBD", input_port_name="in2Add", output_port_name = "outProd")
-		self.CBD.addConnection("adderCBD", "productCBD", input_port_name="in1Prod", output_port_name = "outAdd")
-		self.CBD.addConnection("constantCBD2", "productCBD", input_port_name="in2Prod", output_port_name = "outConstant2")
+		self.CBD.addConnection("constantCBD1", "adderCBD", input_port_name="in1Add", output_port_name="outConstant1")
+		self.CBD.addConnection("productCBD", "adderCBD", input_port_name="in2Add", output_port_name="outProd")
+		self.CBD.addConnection("adderCBD", "productCBD", input_port_name="in1Prod", output_port_name="outAdd")
+		self.CBD.addConnection("constantCBD2", "productCBD", input_port_name="in2Prod", output_port_name="outConstant2")
 			
 		self.CBD.flatten()
 		self._run(5)
@@ -122,11 +122,11 @@ class FlattenCBDTest(unittest.TestCase):
 		self.CBD.addBlock(CBDAdder1)
 		self.CBD.addBlock(CBDAdder2)
 		self.CBD.addBlock(CBDNegator)
-		self.CBD.addConnection("constantCBD1", "adder1CBD", input_port_name="in1Add1", output_port_name = "outConstant1")
-		self.CBD.addConnection("adder2CBD", "adder1CBD", input_port_name="in2Add1", output_port_name = "outAdd2")
-		self.CBD.addConnection("constantCBD2", "adder2CBD", input_port_name="in1Add2", output_port_name = "outConstant2")
-		self.CBD.addConnection("negatorCBD", "adder2CBD", input_port_name="in2Add2", output_port_name = "outNeg")
-		self.CBD.addConnection("adder1CBD", "negatorCBD", input_port_name="inNeg", output_port_name = "outAdd1")
+		self.CBD.addConnection("constantCBD1", "adder1CBD", input_port_name="in1Add1", output_port_name="outConstant1")
+		self.CBD.addConnection("adder2CBD", "adder1CBD", input_port_name="in2Add1", output_port_name="outAdd2")
+		self.CBD.addConnection("constantCBD2", "adder2CBD", input_port_name="in1Add2", output_port_name="outConstant2")
+		self.CBD.addConnection("negatorCBD", "adder2CBD", input_port_name="in2Add2", output_port_name="outNeg")
+		self.CBD.addConnection("adder1CBD", "negatorCBD", input_port_name="inNeg", output_port_name="outAdd1")
 		
 		self.CBD.flatten()
 		self._run(5)
@@ -168,10 +168,10 @@ class FlattenCBDTest(unittest.TestCase):
 		self.CBD.addBlock(CBDLittle1)
 		self.CBD.addConnection("c3", "a")
 		self.CBD.addConnection("c2", "a")
-		self.CBD.addConnection("c1", "first_child", input_port_name = "in1CBD1")
-		self.CBD.addConnection("a", "first_child", input_port_name = "in2CBD1")
-		self.CBD.addConnection("first_child", "a2", output_port_name = "out1CBD1")
-		self.CBD.addConnection("first_child", "a2", output_port_name = "out2CBD1")
+		self.CBD.addConnection("c1", "first_child", input_port_name="in1CBD1")
+		self.CBD.addConnection("a", "first_child", input_port_name="in2CBD1")
+		self.CBD.addConnection("first_child", "a2", output_port_name="out1CBD1")
+		self.CBD.addConnection("first_child", "a2", output_port_name="out2CBD1")
 				
 		CBDLittle1.addBlock(ProductBlock(block_name="p"))
 		CBDLittle1.addBlock(AdderBlock(block_name="a"))
@@ -180,8 +180,8 @@ class FlattenCBDTest(unittest.TestCase):
 		CBDLittle1.addConnection("in1CBD1", "p")
 		CBDLittle1.addConnection("in2CBD1", "p")
 		CBDLittle1.addConnection("in1CBD1", "a")
-		CBDLittle1.addConnection("first_child_of_first_child", "a", output_port_name = "outCBD2")
-		CBDLittle1.addConnection("p", "first_child_of_first_child", input_port_name = "inCBD2")
+		CBDLittle1.addConnection("first_child_of_first_child", "a", output_port_name="outCBD2")
+		CBDLittle1.addConnection("p", "first_child_of_first_child", input_port_name="inCBD2")
 		CBDLittle1.addConnection("c", "out1CBD1")
 		CBDLittle1.addConnection("a", "out2CBD1")
 		

src/test/hierarchyCBDTest.py

@@ -36,8 +36,8 @@ class HierarchyCBDTest(unittest.TestCase):
 		self.CBD.addBlock(CBDLittle2)
 		neg = NegatorBlock(block_name="n")
 		self.CBD.addBlock(neg)
-		self.CBD.addConnection("first_child", "second_child", input_port_name = "inCBD2", output_port_name = "outCBD1") 
-		self.CBD.addConnection("second_child", "n", output_port_name = "outCBD2") 
+		self.CBD.addConnection("first_child", "second_child", input_port_name="inCBD2", output_port_name="outCBD1")
+		self.CBD.addConnection("second_child", "n", output_port_name="outCBD2")
 
 		self._run(5)
 		self.assertEqual(self._getSignal("n"), [2.0]*5)
@@ -68,10 +68,10 @@ class HierarchyCBDTest(unittest.TestCase):
 		self.CBD.addBlock(CBDConstant2)
 		self.CBD.addBlock(CBDAdder)
 		self.CBD.addBlock(CBDProduct)
-		self.CBD.addConnection("constantCBD1", "adderCBD", input_port_name="in1Add", output_port_name = "outConstant1")
-		self.CBD.addConnection("productCBD", "adderCBD", input_port_name="in2Add", output_port_name = "outProd")
-		self.CBD.addConnection("adderCBD", "productCBD", input_port_name="in1Prod", output_port_name = "outAdd")
-		self.CBD.addConnection("constantCBD2", "productCBD", input_port_name="in2Prod", output_port_name = "outConstant2")
+		self.CBD.addConnection("constantCBD1", "adderCBD", input_port_name="in1Add", output_port_name="outConstant1")
+		self.CBD.addConnection("productCBD", "adderCBD", input_port_name="in2Add", output_port_name="outProd")
+		self.CBD.addConnection("adderCBD", "productCBD", input_port_name="in1Prod", output_port_name="outAdd")
+		self.CBD.addConnection("constantCBD2", "productCBD", input_port_name="in2Prod", output_port_name="outConstant2")
 
 		self._run(5)
 		self.assertEqual(self._getSignal("adderCBD", output_port = "outAdd"), [-0.75]*5)
@@ -108,11 +108,11 @@ class HierarchyCBDTest(unittest.TestCase):
 		self.CBD.addBlock(CBDAdder1)
 		self.CBD.addBlock(CBDAdder2)
 		self.CBD.addBlock(CBDNegator)
-		self.CBD.addConnection("constantCBD1", "adder1CBD", input_port_name="in1Add1", output_port_name = "outConstant1")
-		self.CBD.addConnection("adder2CBD", "adder1CBD", input_port_name="in2Add1", output_port_name = "outAdd2")
-		self.CBD.addConnection("constantCBD2", "adder2CBD", input_port_name="in1Add2", output_port_name = "outConstant2")
-		self.CBD.addConnection("negatorCBD", "adder2CBD", input_port_name="in2Add2", output_port_name = "outNeg")
-		self.CBD.addConnection("adder1CBD", "negatorCBD", input_port_name="inNeg", output_port_name = "outAdd1")
+		self.CBD.addConnection("constantCBD1", "adder1CBD", input_port_name="in1Add1", output_port_name="outConstant1")
+		self.CBD.addConnection("adder2CBD", "adder1CBD", input_port_name="in2Add1", output_port_name="outAdd2")
+		self.CBD.addConnection("constantCBD2", "adder2CBD", input_port_name="in1Add2", output_port_name="outConstant2")
+		self.CBD.addConnection("negatorCBD", "adder2CBD", input_port_name="in2Add2", output_port_name="outNeg")
+		self.CBD.addConnection("adder1CBD", "negatorCBD", input_port_name="inNeg", output_port_name="outAdd1")
 
 		self._run(5)
 		self.assertEqual(self._getSignal("adder1CBD", output_port = "outAdd1"), [6.5]*5)
@@ -153,10 +153,10 @@ class HierarchyCBDTest(unittest.TestCase):
 		self.CBD.addBlock(CBDLittle1)
 		self.CBD.addConnection("c3", "a")
 		self.CBD.addConnection("c2", "a")
-		self.CBD.addConnection("c1", "first_child", input_port_name = "in1CBD1")
-		self.CBD.addConnection("a", "first_child", input_port_name = "in2CBD1")
-		self.CBD.addConnection("first_child", "a2", output_port_name = "out1CBD1")
-		self.CBD.addConnection("first_child", "a2", output_port_name = "out2CBD1")
+		self.CBD.addConnection("c1", "first_child", input_port_name="in1CBD1")
+		self.CBD.addConnection("a", "first_child", input_port_name="in2CBD1")
+		self.CBD.addConnection("first_child", "a2", output_port_name="out1CBD1")
+		self.CBD.addConnection("first_child", "a2", output_port_name="out2CBD1")
 				
 		CBDLittle1.addBlock(ProductBlock(block_name="p"))
 		CBDLittle1.addBlock(AdderBlock(block_name="a"))
@@ -165,8 +165,8 @@ class HierarchyCBDTest(unittest.TestCase):
 		CBDLittle1.addConnection("in1CBD1", "p")
 		CBDLittle1.addConnection("in2CBD1", "p")
 		CBDLittle1.addConnection("in1CBD1", "a")
-		CBDLittle1.addConnection("first_child_of_first_child", "a", output_port_name = "outCBD2")
-		CBDLittle1.addConnection("p", "first_child_of_first_child", input_port_name = "inCBD2")
+		CBDLittle1.addConnection("first_child_of_first_child", "a", output_port_name="outCBD2")
+		CBDLittle1.addConnection("p", "first_child_of_first_child", input_port_name="inCBD2")
 		CBDLittle1.addConnection("c", "out1CBD1")
 		CBDLittle1.addConnection("a", "out2CBD1")
 		

src/test/sortedGraphCBDTest.py

@@ -19,16 +19,16 @@ class SortedGraphCBDTest(unittest.TestCase):
 		CBDNegator = CBD("negatorCBD", input_ports = ["inNegator"], output_ports = ["outNegator"])
 		negCbd = NegatorBlock(block_name="nC")
 		CBDNegator.addBlock(negCbd)
-		CBDNegator.addConnection("inNegator", "nC")	
-		CBDNegator.addConnection("nC", "outNegator")	
-		
+		CBDNegator.addConnection("inNegator", "nC")
+		CBDNegator.addConnection("nC", "outNegator")
+
 		const = ConstantBlock(block_name="c", value=5.5)
 		self.CBD.addBlock(const)
 		neg = NegatorBlock(block_name="n")
 		self.CBD.addBlock(neg)
 		self.CBD.addBlock(CBDNegator)
-		self.CBD.addConnection("negatorCBD", "n", output_port_name = "outNegator")
-		self.CBD.addConnection("c", "negatorCBD", input_port_name = "inNegator")
+		self.CBD.addConnection("negatorCBD", "n", output_port_name="outNegator")
+		self.CBD.addConnection("c", "negatorCBD", input_port_name="inNegator")
 		
 		depGraph = createDepGraph(self.CBD, 0)
 		sortedGraph = self.scheduler.obtain(depGraph, 1, 0.0)
@@ -42,10 +42,10 @@ class SortedGraphCBDTest(unittest.TestCase):
 		CBDAdder = CBD("adderCBD", input_ports = ["in1", "in2"], output_ports = ["outAdd"])
 		addCBD = AdderBlock(block_name="aC")
 		CBDAdder.addBlock(addCBD)
-		CBDAdder.addConnection("in1", "aC")	
-		CBDAdder.addConnection("in2", "aC")	
-		CBDAdder.addConnection("aC", "outAdd")	
-		
+		CBDAdder.addConnection("in1", "aC")
+		CBDAdder.addConnection("in2", "aC")
+		CBDAdder.addConnection("aC", "outAdd")
+
 		const1 = ConstantBlock(block_name="c1", value=5.5)
 		const2 = ConstantBlock(block_name="c2", value=4.5)
 		self.CBD.addBlock(const1)
@@ -53,9 +53,9 @@ class SortedGraphCBDTest(unittest.TestCase):
 		neg = NegatorBlock(block_name="n")
 		self.CBD.addBlock(neg)
 		self.CBD.addBlock(CBDAdder)
-		self.CBD.addConnection("adderCBD", "n", output_port_name = "outAdd")
-		self.CBD.addConnection("c1", "adderCBD", input_port_name = "in1")
-		self.CBD.addConnection("c2", "adderCBD", input_port_name = "in2")
+		self.CBD.addConnection("adderCBD", "n", output_port_name="outAdd")
+		self.CBD.addConnection("c1", "adderCBD", input_port_name="in1")
+		self.CBD.addConnection("c2", "adderCBD", input_port_name="in2")
 		
 		depGraph = createDepGraph(self.CBD, 0)
 		sortedGraph = self.scheduler.obtain(depGraph, 1, 0.0)
@@ -75,19 +75,19 @@ class SortedGraphCBDTest(unittest.TestCase):
 		invCBD = InverterBlock(block_name="iC")
 		CBDNegator.addBlock(negCbd)
 		CBDNegator.addBlock(invCBD)
-		CBDNegator.addConnection("inNegator", "nC")	
-		CBDNegator.addConnection("inNegator", "iC")	
-		CBDNegator.addConnection("nC", "outNegator")	
-		CBDNegator.addConnection("iC", "outInverter")	
-		
+		CBDNegator.addConnection("inNegator", "nC")
+		CBDNegator.addConnection("inNegator", "iC")
+		CBDNegator.addConnection("nC", "outNegator")
+		CBDNegator.addConnection("iC", "outInverter")
+
 		const = ConstantBlock(block_name="c", value=5.5)
 		self.CBD.addBlock(const)
 		add = AdderBlock(block_name="a")
 		self.CBD.addBlock(add)
 		self.CBD.addBlock(CBDNegator)
-		self.CBD.addConnection("negatorCBD", "a", output_port_name = "outNegator")
-		self.CBD.addConnection("negatorCBD", "a", output_port_name = "outInverter")
-		self.CBD.addConnection("c", "negatorCBD", input_port_name = "inNegator")
+		self.CBD.addConnection("negatorCBD", "a", output_port_name="outNegator")
+		self.CBD.addConnection("negatorCBD", "a", output_port_name="outInverter")
+		self.CBD.addConnection("c", "negatorCBD", input_port_name="inNegator")
 		
 		depGraph = createDepGraph(self.CBD, 0)
 		sortedGraph = self.scheduler.obtain(depGraph, 1, 0.0)
@@ -107,7 +107,7 @@ class SortedGraphCBDTest(unittest.TestCase):
 		CBDStrong.addBlock(AdderBlock(block_name="a1"))
 		CBDStrong.addBlock(AdderBlock(block_name="a3"))
 		CBDStrong.addBlock(AdderBlock(block_name="a2"))
-		CBDStrong.addConnection("a3", "a1")		
+		CBDStrong.addConnection("a3", "a1")
 		CBDStrong.addConnection("a1", "a3")
 		CBDStrong.addConnection("a2", "a3")
 		CBDStrong.addConnection("inC1", "a1")
@@ -117,8 +117,8 @@ class SortedGraphCBDTest(unittest.TestCase):
 		self.CBD.addBlock(CBDStrong)
 		self.CBD.addBlock(ConstantBlock(block_name="c2", value=5.5))
 		self.CBD.addBlock(ConstantBlock(block_name="c1", value=-5))
-		self.CBD.addConnection("c1", "strongCBD", input_port_name = "inC1")
-		self.CBD.addConnection("c2", "strongCBD", input_port_name = "inC2")
+		self.CBD.addConnection("c1", "strongCBD", input_port_name="inC1")
+		self.CBD.addConnection("c2", "strongCBD", input_port_name="inC2")
 		
 		depGraph = createDepGraph(self.CBD, 0)
 		sortedGraph = self.scheduler.obtain(depGraph, 1, 0.0)
@@ -130,7 +130,7 @@ class SortedGraphCBDTest(unittest.TestCase):
 		CBDStrong = CBD("strongCBD", input_ports = ["inC1", "inC2", "inA"], output_ports = ["out1", "out2"])
 		CBDStrong.addBlock(AdderBlock(block_name="a1"))
 		CBDStrong.addBlock(AdderBlock(block_name="a2"))
-		CBDStrong.addConnection("inA", "a1")		
+		CBDStrong.addConnection("inA", "a1")
 		CBDStrong.addConnection("a1", "out1")
 		CBDStrong.addConnection("a2", "out2")
 		CBDStrong.addConnection("inC1", "a1")
@@ -141,11 +141,11 @@ class SortedGraphCBDTest(unittest.TestCase):
 		self.CBD.addBlock(AdderBlock(block_name="a3"))
 		self.CBD.addBlock(ConstantBlock(block_name="c2", value=5.5))
 		self.CBD.addBlock(ConstantBlock(block_name="c1", value=-5))
-		self.CBD.addConnection("c1", "strongCBD", input_port_name = "inC1")
-		self.CBD.addConnection("c2", "strongCBD", input_port_name = "inC2")
-		self.CBD.addConnection("a3", "strongCBD", input_port_name = "inA")
-		self.CBD.addConnection("strongCBD", "a3", output_port_name = "out1")
-		self.CBD.addConnection("strongCBD", "a3", output_port_name = "out2")
+		self.CBD.addConnection("c1", "strongCBD", input_port_name="inC1")
+		self.CBD.addConnection("c2", "strongCBD", input_port_name="inC2")
+		self.CBD.addConnection("a3", "strongCBD", input_port_name="inA")
+		self.CBD.addConnection("strongCBD", "a3", output_port_name="out1")
+		self.CBD.addConnection("strongCBD", "a3", output_port_name="out2")
 		
 		depGraph = createDepGraph(self.CBD, 0)
 		sortedGraph = self.scheduler.obtain(depGraph, 1, 0.0)