cbd

materials/lib/CBDSimulatorInterpreter/cbd/examples/SimulateTrainControlCBD.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+from bokeh.plotting import figure, output_file, show
+from cbd.models.TrainControlCBD import TrainControlCBD, TrainUncontrolledCBD
+from cbd.models.TrainCostModelBlock import StopSimulationException
+
+def simulateCBD(optimalKp, optimalKi, optimalKd):
+    cbd = TrainControlCBD("train_control", optimalKp, optimalKi, optimalKd)
+    #cbd = TrainUncontrolledCBD("train_control", optimalKp, optimalKi, optimalKd)
+    cbd.run(3500, 0.1)
+    
+    times = []
+    velocity = []
+    ideal_velocity = []
+    displacement_person = []
+    acceleration_train = []
+    costs = []
+    
+    for timeValuePair in cbd.getBlockByName("time").getSignal("OutTime"):
+        times.append(timeValuePair.value)
+    
+    for timeValuePair in cbd.getBlockByName("plant").getSignal("OutVTrain"):
+        velocity.append(timeValuePair.value)
+        
+    for timeValuePair in cbd.getBlockByName("computer").getSignal():
+        ideal_velocity.append(timeValuePair.value)
+    
+    for timeValuePair in cbd.getBlockByName("plant").getSignal("OutXPerson"):
+        displacement_person.append(timeValuePair.value)
+    
+    for timeValuePair in cbd.getBlockByName("plant").getSignal("OutATrain"):
+        acceleration_train.append(timeValuePair.value)
+    
+    for timeValuePair in cbd.getBlockByName("cost").getSignal("OutCost"):
+        costs.append(timeValuePair.value)
+    
+    #Plot
+    output_file("./train_velocity.html", title="Ideal and real velocity of the train")
+    p = figure(title="Ideal and real velocity of the train ("+str(optimalKp)+", "+str(optimalKi)+", "+str(optimalKd)+")", x_axis_label='t', y_axis_label='m/s')
+    p.line(times, ideal_velocity, legend="ideal velocity", line_width=2, line_color="red")
+    p.line(times, velocity, legend="velocity", line_width=2, line_color="blue")
+    show(p)
+    
+    output_file("./train_ideal_velocity.html", title="Ideal velocity of the train")
+    p = figure(title="Ideal velocity of the train", x_axis_label='t', y_axis_label='m/s')
+    p.line(times, ideal_velocity, legend="ideal velocity", line_width=2, line_color="red")
+    show(p)
+    
+    
+    #Plot
+    output_file("./people_displacement.html", title="People displacement and train acceleration")
+    p = figure(title="People displacement and train acceleration ("+str(optimalKp)+", "+str(optimalKi)+", "+str(optimalKd)+")", x_axis_label='t', y_axis_label='')
+    p.line(times, displacement_person, legend="People displacement (m)", line_width=2, line_color="red")
+    p.line(times, acceleration_train, legend="Train acceleration (m/s^2)", line_width=2, line_color="blue")
+    show(p)
+    
+    output_file("./costs.html", title="Costs")
+    p = figure(title="Costs ("+str(optimalKp)+", "+str(optimalKi)+", "+str(optimalKd)+")", x_axis_label='t', y_axis_label='')
+    p.line(times, costs, legend="Cost", line_width=2, line_color="red")
+    show(p)
+    
+    return cbd
+
+'''
+cbd = TrainControlCBD("train_control")
+draw(cbd, "train_control.dot")
+draw(cbd.getBlockByName("time"), "fixed_time_cbd.dot")
+draw(cbd.getBlockByName("controller"), "controller.dot")
+draw(cbd.getBlockByName("plant"), "plant.dot")
+draw(cbd.getBlockByName("plant").getBlockByName("accelerationPerson"), "accelerationPerson.dot")
+draw(cbd.getBlockByName("plant").getBlockByName("accelerationTrain"), "accelerationTrain.dot")
+'''
+
+'''
+Optimal parameters list
+Kp            Ki            Kd
+570           100            190
+490           147            183
+
+'''
+
+optimalKp = 570.0
+optimalKps = []
+
+optimalKi = 100.0
+optimalKis = []
+
+optimalKd = 190.0
+optimalKds = []
+
+cost = float("inf")
+costs = []
+for i in range(1):
+    newOptimalKp = input("Kp: ")
+    newOptimalKi = input("Ki: ")
+    newOptimalKd = input("Kd: ")
+    try:
+        cbd = simulateCBD(newOptimalKp, newOptimalKi, newOptimalKd)
+        
+        # commit new parameters
+        optimalKp = newOptimalKp
+        optimalKps.append(optimalKp)
+        
+        optimalKi = newOptimalKi
+        optimalKis.append(optimalKi)
+        
+        optimalKd = newOptimalKd
+        optimalKds.append(optimalKd)
+        
+        costs.append(cbd.getBlockByName("cost").getSignal("OutCost")[-1].value)
+        print("cost: " + str(costs[-1]))
+    except StopSimulationException:
+        print("StopSimulationException")
+
+

materials/lib/CBDSimulatorInterpreter/cbd/examples/circlePlot.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python
+from bokeh.plotting import figure, output_file, show
+from cbd.src.CBD import *
+import math
+        
+class CircleCBDIntegrator(CBD):
+    def __init__(self, delta_t):
+        CBD.__init__(self,"HarmonicOscilatorIntegrator", [], [])
+        self.delta=delta_t;
+        self.addBlock(ConstantBlock(block_name="one", value=1.0))
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(ConstantBlock(block_name="delta", value=self.delta))
+        self.addBlock(NegatorBlock(block_name="neg"))
+        self.addBlock(IntegratorBlock(block_name="intx"))
+        self.addBlock(IntegratorBlock(block_name="intv"))
+        
+        self.addConnection("delta", "intx",  input_port_name="delta_t")
+        self.addConnection("delta", "intv",  input_port_name="delta_t")
+        self.addConnection("zero", "intx",  input_port_name="IC")
+        self.addConnection("one", "intv",  input_port_name="IC")
+        self.addConnection("intx", "neg")
+        self.addConnection("neg", "intv")
+        self.addConnection("intv", "intx")
+        
+        # error measurement blocks
+        self.addBlock(IntegratorBlock(block_name="inte"))
+        self.addBlock(NegatorBlock(block_name="negX"))
+        self.addBlock(AdderBlock(block_name="addNeg"))
+        self.addBlock(ABSBlock(block_name="absError"))
+        self.addBlock(SinBlock(block_name="sin"))
+        self.addConnection("zero", "inte",  input_port_name="IC")
+        self.addConnection("delta", "inte",  input_port_name="delta_t")
+        self.addConnection("intx", "negX")
+        self.addConnection("negX", "addNeg")
+        self.addConnection("sin", "addNeg")
+        self.addConnection("addNeg", "absError")
+        self.addConnection("absError", "inte", input_port_name="IN1")
+        
+
+
+class SinBlock(BaseBlock):
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, [], ["OUT1"])
+
+    def compute(self, curIteration):
+        self.appendToSignal(math.sin(self.getClock().getTime()))
+        
+     
+
+class CircleCBDDerivative(CBD):
+    def __init__(self, delta_t):
+        CBD.__init__(self,"HarmonicOscilatorDerivative", [], [])
+        self.delta=delta_t;
+        self.addBlock(ConstantBlock(block_name="one", value=1.0))
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(ConstantBlock(block_name="delta", value=self.delta))
+        self.addBlock(NegatorBlock(block_name="neg"))
+        self.addBlock(DerivatorBlock(block_name="derxv"))
+        self.addBlock(DerivatorBlock(block_name="derva"))
+        
+        self.addConnection("delta", "derxv",  input_port_name="delta_t")
+        self.addConnection("delta", "derva",  input_port_name="delta_t")
+        self.addConnection("zero", "derva",  input_port_name="IC")
+        self.addConnection("one", "derxv",  input_port_name="IC")
+        self.addConnection("derva", "neg")
+        self.addConnection("neg", "derxv")
+        self.addConnection("derxv", "derva")
+        
+        # error measuring blocks 
+        self.addBlock(IntegratorBlock(block_name="inte"))
+        self.addBlock(NegatorBlock(block_name="negX"))
+        self.addBlock(AdderBlock(block_name="addNeg"))
+        self.addBlock(ABSBlock(block_name="absError"))
+        self.addBlock(SinBlock(block_name="sin"))
+        self.addConnection("zero", "inte",  input_port_name="IC")
+        self.addConnection("delta", "inte",  input_port_name="delta_t")
+        self.addConnection("neg", "negX")
+        self.addConnection("negX", "addNeg")
+        self.addConnection("sin", "addNeg")
+        self.addConnection("addNeg", "absError")
+        self.addConnection("absError", "inte", input_port_name="IN1")
+
+
+def plotTime(cbd, blockToInspect, fileName, title, label):
+    
+    times = []
+    values = []
+    
+    for timeValuePair in cbd.getBlockByName(blockToInspect).getSignal():
+        times.append(timeValuePair.time)
+        values.append(timeValuePair.value)
+    
+    #Output solution and numerical approximation
+    output_file("./"+fileName+".html", title=title)
+    p = figure(title=title, x_axis_label='time', y_axis_label=label)
+    p.line(times, values, legend=label, line_width=1, line_color="red")
+    
+    show(p)
+
+def plotError(cbd, fileName, title):
+    
+    times = []
+    values = []
+    
+    for timeValuePair in cbd.getBlockByName("inte").getSignal():
+        times.append(timeValuePair.time)
+        values.append(timeValuePair.value)
+    
+    #Output solution and numerical approximation
+    output_file("./"+fileName+".html", title=title)
+    p = figure(title=title, x_axis_label='time', y_axis_label="error")
+    p.line(times, values, legend="error", line_width=1, line_color="red")
+    show(p)
+
+def plotParametric(cbd, blockToInspectHorAxis, blockToInspectVerAxis, fileName, title, horLabel, verLabel):
+    
+    times = []
+    values = []
+    
+    for timeValuePair in cbd.getBlockByName(blockToInspectHorAxis).getSignal():
+        times.append(timeValuePair.value)
+    
+    for timeValuePair in cbd.getBlockByName(blockToInspectVerAxis).getSignal():
+        values.append(timeValuePair.value)
+    
+    #Output solution and numerical approximation
+    output_file("./"+fileName+".html", title=title)
+    p = figure(title=title, x_axis_label=horLabel, y_axis_label=verLabel)
+    p.line(times, values, legend=horLabel + " vs " + verLabel, line_width=1, line_color="red")
+    show(p)
+
+def getErrorSin(cbd, blockThatGivesSin):
+    error = 0.0
+    fullSignal = cbd.getBlockByName(blockThatGivesSin).getSignal()
+    for timeValuePair in fullSignal:
+        error += abs(timeValuePair.value - math.sin(timeValuePair.time))
+    return error/len(fullSignal)
+
+NUM_STEPS = 100
+
+delta = 0.1
+cbdInt = CircleCBDIntegrator(delta)
+cbdInt.run(int(NUM_STEPS/delta), delta_t = delta)    
+
+times = []
+values = []
+valuesSin = []
+
+for timeValuePair in cbdInt.getBlockByName("intx").getSignal():
+    times.append(timeValuePair.time)
+    values.append(timeValuePair.value)
+    valuesSin.append(math.sin(timeValuePair.time))
+
+#Output solution and numerical approximation
+output_file("./plots.html", title="title")
+p = figure(title="", x_axis_label='time', y_axis_label="asas")
+p.line(times, values, legend="asas", line_width=1, line_color="red")
+p.line(times, valuesSin, legend="eeeee", line_width=1, line_color="blue")
+show(p)
+
+'''
+#General plotting
+for delta in [0.1, 0.01 , 0.001, 0.0001]:
+    cbdInt = CircleCBDIntegrator(delta)
+    cbdInt.run(int(NUM_STEPS/delta), delta_t = delta)
+    plotTime(cbdInt, "intx", "circle_integrator_delta"+str(delta), "Harmonic Oscillator with integrators and delta " + str(delta), "position (x)")
+    plotParametric(cbdInt, "intx", "intv", "circle_integrator_parametric_delta"+str(delta), "Circle with integrators and delta " + str(delta), "x", "y")
+    plotError(cbdInt, "circle_integrator_delta"+str(delta)+"_error", "Error of Harmonic Oscillator with integrators and delta " + str(delta))
+    
+    cbdDer = CircleCBDDerivative(delta)
+    cbdDer.run(int(NUM_STEPS/delta), delta_t = delta)
+    plotTime(cbdDer, "neg", "circle_derivative_delta"+str(delta), "Harmonic Oscillator with derivatives and delta " + str(delta), "position (x)")
+    plotParametric(cbdDer, "neg", "derxv", "circle_derivative_parametric_delta"+str(delta), "Circle test with derivatives and delta " + str(delta), "x", "y")
+    plotError(cbdDer, "circle_derivative_delta"+str(delta)+"_error", "Error of Harmonic Oscillator with derivatives and delta " + str(delta))
+'''
+
+'''
+# Error plotting
+MAX_TIME_ERROR = 10
+errorValuesInt = []
+errorValuesDer = []
+#deltas = map((lambda x: 10 ** (-x)),range(5))
+deltas = map((lambda x: (x+1)/10000.0),range(10000))
+for delta in deltas:
+    cbdInt = CircleCBDIntegrator(delta)
+    cbdInt.run(int(MAX_TIME_ERROR/delta), delta_t = delta)
+    errorValuesInt.append(getErrorSin(cbdInt, "intx"))
+    
+    cbdDer = CircleCBDDerivative(delta)
+    cbdDer.run(int(MAX_TIME_ERROR/delta), delta_t = delta)
+    errorValuesDer.append(getErrorSin(cbdDer, "neg"))
+
+
+output_file("./error_vs_delta.html", title="Error vs Step Size")
+p = figure(title="Error vs Step Size", x_axis_label="Step size", y_axis_label="Error")
+p.line(deltas, errorValuesInt, legend="Integrator", line_width=1, line_color="red")
+p.line(deltas, errorValuesDer, legend="Derivative", line_width=1, line_color="blue")
+show(p)
+'''
+
+
+
+
+
+
+

materials/lib/CBDSimulatorInterpreter/cbd/models/EvenNumbersCBD.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+from bokeh.plotting import figure, output_file, show
+from cbd.src.CBD import *
+from cbd.src.CBDDraw import draw
+
+
+class Counter(CBD):
+    def __init__(self, block_name):
+        CBD.__init__(self, 
+                    block_name, 
+                    input_ports=[], 
+                    output_ports=["OutCount"])
+        
+        self.addBlock(DelayBlock(block_name="delay"))
+        self.addBlock(AdderBlock(block_name="sum"))
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(ConstantBlock(block_name="one", value=1.0))
+        
+        self.addConnection("zero", "delay", 
+                            input_port_name="IC")
+        self.addConnection("delay", "OutCount")
+        self.addConnection("delay", "sum")
+        self.addConnection("sum", "delay", input_port_name="IN1")
+        self.addConnection("one", "sum")
+        
+class Double(CBD):        
+    def __init__(self, block_name):
+        CBD.__init__(self, 
+                     block_name, 
+                     input_ports=["InNumber"], 
+                     output_ports=["OutDouble"])
+        self.addBlock(ProductBlock(block_name="mult"))
+        self.addBlock(ConstantBlock(block_name="two", value=2.0))
+        
+        self.addConnection("InNumber", "mult")
+        self.addConnection("two", "mult")
+        self.addConnection("mult", "OutDouble")
+    
+    
+class EvenNumberGen(CBD):
+    def __init__(self, block_name):
+        CBD.__init__(self, 
+                     block_name, 
+                     input_ports=[],
+                     output_ports=["OutEven"])
+        
+        self.addBlock(Counter(block_name="counter"))
+        self.addBlock(Double(block_name="double"))
+        
+        self.addConnection("counter", "double", 
+                           input_port_name="InNumber",
+                           output_port_name="OutCount")
+        self.addConnection("double", "OutEven",
+                           output_port_name="OutDouble")
+        
+
+
+
+cbd = EvenNumberGen("number_gen")
+
+# Get cbd dot and render them.
+cbdDot = draw(cbd)
+counterDot = draw(cbd.getBlockByName("counter"))
+cbdDot.render('evenCBD.pdf')
+counterDot.render('counterCBD')
+
+cbd.run(10)
+
+times = []
+output = []
+
+for timeValuePair in cbd.getSignal("OutEven"):
+    times.append(timeValuePair.time)
+    output.append(timeValuePair.value)
+            
+#Plot
+output_file("./number_gen.html", title="Even Numbers")
+p = figure(title="Even Numbers", x_axis_label='time', y_axis_label='N')
+p.circle(x=times, y=output, legend="Even numbers")
+show(p)
+
+
+
+

materials/lib/CBDSimulatorInterpreter/cbd/models/TrainControlCBD.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python
+from cbd.src.CBD import *
+from TrainCostModelBlock import CostFunctionBlock
+
+DELTA = 0.1
+MASS_PERSON = 73
+MASS_TRAIN = 6000
+K = 300
+C = 150
+
+class TrainControlCBD(CBD):
+    def __init__(self, block_name, kp, ki, kd):
+        CBD.__init__(self, block_name)
+        self.addBlock(FixedTimeCBD(block_name="time"))
+        self.addBlock(LookUpBlockFixed(block_name="computer"))
+        self.addBlock(AdderBlock(block_name="sum"))
+        self.addBlock(NegatorBlock(block_name="neg"))
+        self.addBlock(TrainPIDController("controller", kp, ki, kd))
+        self.addBlock(TrainPerson(block_name="plant"))
+        self.addBlock(CostFunctionBlock(block_name="cost"))
+        
+        # the connections follow the topological sort.
+        self.addConnection("time", "computer", 
+                            input_port_name="IN1", output_port_name="OutTime")
+        self.addConnection("time", "plant", 
+                            input_port_name="InDelta", output_port_name="OutDelta")
+        self.addConnection("time", "controller", 
+                            input_port_name="InDelta", output_port_name="OutDelta")
+        self.addConnection("computer", "sum", 
+                            input_port_name="IN1", output_port_name="OUT1")
+        self.addConnection("plant", "neg", 
+                            input_port_name="IN1", output_port_name="OutVTrain")
+        self.addConnection("neg", "sum", 
+                            input_port_name="IN2", output_port_name="OUT1")
+        self.addConnection("sum", "controller", 
+                            input_port_name="InError", output_port_name="OUT1")
+        self.addConnection("controller", "plant", 
+                            input_port_name="InTraction", output_port_name="OutTraction")
+        self.addConnection("plant", "cost", 
+                            input_port_name="InVTrain", output_port_name="OutVTrain")
+        self.addConnection("time", "cost", 
+                            input_port_name="InDelta", output_port_name="OutDelta")
+        self.addConnection("plant", "cost", 
+                            input_port_name="InXPerson", output_port_name="OutXPerson")
+        self.addConnection("computer", "cost", 
+                            input_port_name="InVi", output_port_name="OUT1")       
+
+
+class TrainUncontrolledCBD(CBD):
+    def __init__(self, block_name, kp, ki, kd):
+        CBD.__init__(self, block_name)
+        self.addBlock(FixedTimeCBD(block_name="time"))
+        self.addBlock(LookUpBlockFixed(block_name="computer"))
+        self.addBlock(ConstantBlock(block_name="gainConstant", value=MASS_TRAIN))
+        self.addBlock(ProductBlock(block_name="gainAmp"))
+        self.addBlock(TrainPerson(block_name="plant"))
+        
+        # the connections follow the topological sort.
+        self.addConnection("time", "computer", 
+                            input_port_name="IN1", output_port_name="OutTime")
+        self.addConnection("time", "plant", 
+                            input_port_name="InDelta", output_port_name="OutDelta")
+        self.addConnection("computer", "gainAmp")
+        self.addConnection("gainConstant", "gainAmp")
+        self.addConnection("gainAmp", "plant", 
+                            input_port_name="InTraction")
+        
+
+class LookUpBlockFixed(BaseBlock):
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
+        
+    def compute(self, curIteration):
+        currentTime = self.getInputSignal(curIteration, "IN1").value
+        if currentTime < 10:
+            result = 0
+        elif currentTime < 160:
+            result = 10
+        elif currentTime < 200:
+            result = 4
+        elif currentTime < 260:
+            result = 14
+        else:
+            result = 6
+        
+        self.appendToSignal(result)
+
+
+class FixedTimeCBD(CBD):        
+    def __init__(self, block_name):
+        CBD.__init__(self, block_name, [], ["OutTime", "OutDelta"])
+        self.addBlock(ConstantBlock(block_name="delta", value=DELTA))
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(AdderBlock(block_name="sum"))
+        self.addBlock(DelayBlock(block_name="delay"))
+        
+        self.addConnection("delta", "OutDelta")
+        self.addConnection("delay", "OutTime")
+        self.addConnection("delay", "sum")
+        self.addConnection("delta", "sum")
+        self.addConnection("sum", "delay")
+        self.addConnection("zero", "delay",
+                            input_port_name="IC")
+    
+
+class TrainPIDController(CBD):
+    def __init__(self, block_name, kp, ki, kd):
+        CBD.__init__(self, block_name, ["InError","InDelta"],["OutTraction"])
+        self.addBlock(IntegratorBlock(block_name="integral"))
+        self.addBlock(DerivatorBlock(block_name="derivative"))
+        self.addBlock(ConstantBlock(block_name="Kp", value=kp))
+        self.addBlock(ProductBlock(block_name="multKp"))
+        self.addBlock(ConstantBlock(block_name="Ki", value=ki))
+        self.addBlock(ProductBlock(block_name="multKi"))
+        self.addBlock(ConstantBlock(block_name="Kd", value=kd))
+        self.addBlock(ProductBlock(block_name="multKd"))
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(AdderBlock(block_name="sum1"))
+        self.addBlock(AdderBlock(block_name="sum2"))
+        
+        self.addConnection("InError", "multKp")
+        self.addConnection("Kp", "multKp")
+        self.addConnection("InError", "integral")
+        self.addConnection("InError", "derivative")
+        self.addConnection("InDelta", "derivative", 
+                            input_port_name="delta_t")
+        self.addConnection("InDelta", "integral", 
+                            input_port_name="delta_t")
+        self.addConnection("zero", "derivative", 
+                            input_port_name="IC")
+        self.addConnection("zero", "integral", 
+                            input_port_name="IC")
+        self.addConnection("integral", "multKi")
+        self.addConnection("Ki", "multKi")
+        self.addConnection("derivative", "multKd")
+        self.addConnection("Kd", "multKd")
+        self.addConnection("multKd", "sum1")
+        self.addConnection("multKi", "sum1")
+        self.addConnection("sum1", "sum2")
+        self.addConnection("multKp", "sum2")
+        self.addConnection("sum2", "OutTraction")
+        
+        
+class TrainPerson(CBD):
+    def __init__(self, block_name):
+        CBD.__init__(self, block_name, ["InTraction","InDelta"],["OutVTrain", "OutXPerson", "OutATrain"])
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(AccelerationPerson(block_name="accelerationPerson"))
+        self.addBlock(AccelerationTrain(block_name="accelerationTrain"))
+        self.addBlock(IntegratorBlock(block_name="integral_person_a_v"))
+        self.addBlock(IntegratorBlock(block_name="integral_person_v_x"))
+        self.addBlock(IntegratorBlock(block_name="integral_train_a_v"))
+        
+        self.addConnection("zero", "integral_person_a_v", 
+                            input_port_name="IC")
+        self.addConnection("zero", "integral_person_v_x", 
+                            input_port_name="IC")
+        self.addConnection("zero", "integral_train_a_v", 
+                            input_port_name="IC")
+        
+        self.addConnection("InDelta", "integral_person_a_v", 
+                            input_port_name="delta_t")
+        self.addConnection("InDelta", "integral_person_v_x", 
+                            input_port_name="delta_t")
+        self.addConnection("InDelta", "integral_train_a_v", 
+                            input_port_name="delta_t")
+        
+        self.addConnection("InTraction", "accelerationPerson", 
+                            input_port_name="InTraction")
+        self.addConnection("InTraction", "accelerationTrain", 
+                            input_port_name="InTraction")
+        
+        self.addConnection("accelerationPerson", "integral_person_a_v", 
+                            input_port_name="IN1", output_port_name="OutAPerson")
+        self.addConnection("integral_person_a_v", "accelerationPerson", 
+                            input_port_name="InVPerson", output_port_name="OUT1")
+        self.addConnection("integral_person_a_v", "integral_person_v_x", 
+                            input_port_name="IN1", output_port_name="OUT1")
+        self.addConnection("integral_person_v_x", "accelerationPerson", 
+                            input_port_name="InXPerson", output_port_name="OUT1")
+        
+        self.addConnection("accelerationTrain", "integral_train_a_v", 
+                            input_port_name="IN1", output_port_name="OutATrain")
+        
+        self.addConnection("integral_train_a_v", "OutVTrain")
+        
+        self.addConnection("integral_person_v_x", "OutXPerson")
+        
+        self.addConnection("accelerationTrain", "OutATrain", input_port_name=None, output_port_name="OutATrain")
+        
+        
+        
+class AccelerationPerson(CBD):
+    def __init__(self, block_name):
+        CBD.__init__(self, block_name, ["InTraction","InVPerson","InXPerson"],["OutAPerson"])
+        self.addBlock(ConstantBlock(block_name="m_train", value=MASS_TRAIN))
+        self.addBlock(ConstantBlock(block_name="m_person", value=MASS_PERSON))
+        self.addBlock(ConstantBlock(block_name="c", value=C))
+        self.addBlock(ConstantBlock(block_name="k", value=K))
+        self.addBlock(AdderBlock(block_name="sum_masses"))
+        self.addBlock(InverterBlock(block_name="inv_sum_masses"))
+        self.addBlock(ProductBlock(block_name="mult_inv_sum_masses"))
+        self.addBlock(ProductBlock(block_name="mult_mult_inv_sum_masses"))
+        self.addBlock(InverterBlock(block_name="inv_mperson"))
+        self.addBlock(NegatorBlock(block_name="neg_mult_mult_inv_sum_masses"))
+        self.addBlock(NegatorBlock(block_name="neg_vperson"))
+        self.addBlock(NegatorBlock(block_name="neg_xperson"))
+        self.addBlock(ProductBlock(block_name="mult_neg_vperson"))
+        self.addBlock(ProductBlock(block_name="mult_neg_xperson"))
+        self.addBlock(AdderBlock(block_name="sum_mults_person"))
+        self.addBlock(AdderBlock(block_name="sum_sum_mults_person"))
+        self.addBlock(ProductBlock(block_name="mult_inv_mperson"))
+        
+        self.addConnection("m_train", "sum_masses")
+        self.addConnection("m_person", "sum_masses")
+        self.addConnection("sum_masses", "inv_sum_masses")
+        self.addConnection("inv_sum_masses", "mult_inv_sum_masses")
+        self.addConnection("InTraction", "mult_inv_sum_masses")
+        self.addConnection("mult_inv_sum_masses", "mult_mult_inv_sum_masses")
+        
+        self.addConnection("m_person", "mult_mult_inv_sum_masses")
+        
+        self.addConnection("m_person", "inv_mperson")
+        self.addConnection("inv_mperson", "mult_inv_mperson")
+        
+        self.addConnection("mult_mult_inv_sum_masses", "neg_mult_mult_inv_sum_masses")
+        self.addConnection("neg_mult_mult_inv_sum_masses", "sum_sum_mults_person")
+        
+        self.addConnection("InVPerson", "neg_vperson")
+        self.addConnection("neg_vperson", "mult_neg_vperson")
+        self.addConnection("c", "mult_neg_vperson")
+        
+        self.addConnection("InXPerson", "neg_xperson")
+        self.addConnection("neg_xperson", "mult_neg_xperson")
+        self.addConnection("k", "mult_neg_xperson")
+        
+        self.addConnection("mult_neg_vperson", "sum_mults_person")
+        self.addConnection("mult_neg_xperson", "sum_mults_person")
+        
+        self.addConnection("sum_mults_person", "sum_sum_mults_person")
+        self.addConnection("sum_sum_mults_person", "mult_inv_mperson")
+        self.addConnection("mult_inv_mperson", "OutAPerson")
+        
+        
+        
+class AccelerationTrain(CBD):
+    def __init__(self, block_name):
+        CBD.__init__(self, block_name, ["InTraction"],["OutATrain"])
+        self.addBlock(ConstantBlock(block_name="m_train", value=MASS_TRAIN))
+        self.addBlock(ConstantBlock(block_name="m_person", value=MASS_PERSON))
+        self.addBlock(AdderBlock(block_name="sum"))
+        self.addBlock(InverterBlock(block_name="inv"))
+        self.addBlock(ProductBlock(block_name="mult"))
+        
+        self.addConnection("InTraction", "mult")
+        self.addConnection("m_train", "sum")
+        self.addConnection("m_person", "sum")
+        self.addConnection("sum", "inv")
+        self.addConnection("inv", "mult")
+        self.addConnection("mult", "OutATrain")
+
+
+
+
+
+
+
+
+