def PartialDynamicSystem(self,ieq,variable):
"""
returns dynamical system blocks associated to output variable
"""
# print(ieq,variable.name)
if ieq==0:
# U1-U2=R(i1)
if variable==self.physical_nodes[0].variable:
# U1 is output
# U1=R(i1)+U2
return [WeightedSum([self.physical_nodes[1].variable,self.variables[0]],variable,[1,self.R])]
elif variable==self.physical_nodes[1].variable:
# U2 is output
# U2=-R(i1)+U2
return [WeightedSum([self.physical_nodes[0].variable,self.variables[0]],variable,[1,-self.R])]
elif variable==self.variables[0]:
# i1 is output
# i1=(U1-U2)/R
return [WeightedSum([self.physical_nodes[0].variable,self.physical_nodes[1].variable],variable,[1/self.R,-1/self.R])]
elif ieq==1:
# i1=-i2
if variable==self.variables[0]:
#i1 as output
return [Gain(self.variables[1],self.variables[0],-1)]
elif variable==self.variables[1]:
#i2 as output
return [Gain(self.variables[0],self.variables[1],-1)]
def ConservativeLaw(self, flux_variables, output_variable):
if output_variable == self.variable:
v1 = Variable(hidden='True')
b1 = WeightedSum(flux_variables, v1, [1] * len(flux_variables),
-self.friction)
b2 = ODE(v1, self.variable, [1], [self.SCx, self.mass])
return [b1, b2]
else:
v1 = Variable(hidden='True')
b1 = ODE(self.variable, v1, [self.SCx, self.mass], [1])
b2 = WeightedSum([v1] + flux_variables, output_variable,
[1] + [-1] * len(flux_variables), self.friction)
return [b1, b2]
def PartialDynamicSystem(self,ieq,variable):
"""
returns dynamical system blocks associated to output variable
"""
if ieq==0:
# U2-U1=signal
if variable==self.physical_nodes[0].variable:
# U1 is output
# U1=U2-signal
return [WeightedSum([self.physical_nodes[1].variable,self.voltage_signal],variable,[1,-1])]
elif variable==self.physical_nodes[1].variable:
# U2 is output
# U2=U1+signal
return [WeightedSum([self.physical_nodes[0].variable,self.voltage_signal],variable,[1,1])]
def partial_dynamic_system(self, ieq, variable):
"""
returns dynamical system blocks associated to output variable
"""
if ieq == 0:
# Soc determination
# soc=1-UI/CP
v1 = Variable('UI', hidden=True) # UI
v2 = Variable('UI/CP', hidden=True) # UI/CP
v3 = Variable('soc0-UI/CP', hidden=True) # soc0-UI/CP
b1 = Product(self.u, self.variables[0], v1)
b2 = ODE(v1, v2, [1], [1, self.c])
b3 = WeightedSum([v2], v3, [-1], self.initial_soc)
b4 = Saturation(v3, self.soc, 0, 1)
b5 = WeightedSum([self.soc], self.u, [self.u_max - self.u_min],
self.u_min)
blocks = [b1, b2, b3, b4, b5]
# U2-U1=U+Ri1
# U=soc(Umax-Umin)+Umin
if variable == self.physical_nodes[0].variable:
print('Bat0#1')
# U1 is output
# U1=-U-Ri1+U2
blocks.append(
WeightedSum([
self.u, self.variables[0], self.physical_nodes[1].variable
], variable, [-1, -self.r, 1]))
elif variable == self.physical_nodes[1].variable:
print('Bat0#2')
# U2 is output
# U2=U1+Ri1+U
blocks.append(
WeightedSum([
self.physical_nodes[0].variable, self.variables[0], self.u
], variable, [1, self.r, 1]))
elif variable == self.variables[0]:
print('Bat0#3')
# i1 is output
# i1=(-U1+U2-U)/R
blocks.append(
WeightedSum([
self.physical_nodes[0].variable,
self.physical_nodes[1].variable, self.u
], variable, [-1 / self.r, 1 / self.r, -1 / self.r]))
return blocks
def PartialDynamicSystem(self, ieq, variable):
"""
returns dynamical system blocks associated to output variable
"""
if ieq == 0:
# C1=-f*Tmax*sign(w1-w2)
if variable == self.variables[0]:
ut = Variable('unsigned clutch friction torque', hidden=True)
b1 = Gain(self.commands[0], ut, self.Tmax)
dw = Variable('Delta rotationnal speed', hidden=True)
sdw = Variable('Sign of delta rotationnal speed')
b2 = WeightedSum([
self.physical_nodes[0].variable,
self.physical_nodes[1].variable
], dw, [-1, 1])
b3 = Sign(dw, sdw)
b4 = Product(ut, sdw, variable)
return [b1, b2, b3, b4]
elif ieq == 1:
# C1=-C2
if variable == self.variables[0]:
return [Gain(self.variables[1], variable, -1)]
if variable == self.variables[1]:
return [Gain(self.variables[0], variable, -1)]
def ConservativeLaw(self,flux_variables,output_variable):
return [WeightedSum(flux_variables,output_variable,[-1]*len(flux_variables))]
#I2=Sinus(('input','i'),100.)
#O2=bms.Variable(('Output','O'))#
#b=ODE(I2,O2,[0,1],[1])
#ds2=bms.DynamicSystem(15,3000,[b])
#ds2.Simulate()
#ds2.PlotVariables()
#print(b.Mi,b.Mo)
#print()
#==============================================================================
# Feedback with derivative for stability test
#==============================================================================
I = Step(('input', 'i'), 100.)
AI = bms.Variable(('adapted input', 'ai'), [100.])
dI = bms.Variable(('error', 'dI'))
O = bms.Variable(('Output', 'O')) #
F = bms.Variable(('Feedback', 'F')) #
b1 = Gain(I, AI, Ka)
b2 = WeightedSum([AI, dI], F, [1, -1])
b3 = ODE(O, dI, [1, tau], [Kb])
b4 = Gain(F, O, 1 / Kc)
#
#ds.
ds = bms.DynamicSystem(0.1, 20, [b1, b2, b3, b4])
ds.Simulate()
ds.PlotVariables([[I, O, dI, F]])
def conservative_law(flux_variables, output_variable):
return [
WeightedSum(flux_variables, output_variable,
[-1] * len(flux_variables))
]
fv2 = 0.01
#e=bmsp.Step(1.,'e')
cc = Sinus(('Brake command', 'cc'), 0.5, 0.1, 0, 0.5)
it = Step(('Input torque', 'it'), 100)
rt = Step(('Resistant torque', 'rt'), -80)
tc = bms.Variable(('brake Torque capacity', 'Tc'))
bt = bms.Variable(('brake torque', 'bt'))
w1 = bms.Variable(('Rotational speed shaft 1', 'w1'))
#dw12=bms.Variable(('Clutch differential speed','dw12'))
st1 = bms.Variable(('Sum torques on 1', 'st1'))
et1 = bms.Variable(('Sum of ext torques on 1', 'et1'))
b1 = Gain(cc, tc, Cmax)
b2 = WeightedSum([it, rt], et1, [1, 1])
b3 = CoulombVariableValue(et1, w1, tc, bt, 0.1)
#b3=Coulomb(it,dw12,ct,150)
b4 = ODE(st1, w1, [1], [fv1, I1])
#b5=ODE(st2,w2,[1],[fv2,I2])
b6 = WeightedSum([it, rt, bt], st1, [1, 1, 1])
#b7=WeightedSum([it,rt],et1,[1,1])
ds = bms.DynamicSystem(100, 400, [b1, b2, b3, b4, b6])
#ds.DrawModel()
r = ds.Simulate()
ds.PlotVariables([[w1], [tc, bt, rt, it, st1, et1]])
import matplotlib.pyplot as plt
plt.figure()
Vb = 0.3 # Speed error at beginning of braking
r1 = 0.05
crankshaft = RotationalNode(Ic, friction_c, 'crankshaft')
shaft_gb1 = RotationalNode(Igb1, friction_c, 'shaft gb1')
shaft_gb2 = RotationalNode(Igb2, friction_c, 'shaft gb2')
vehicle = TranslationalNode(mass, SCx, friction_v, 'vehicle')
engine = ThermalEngine(crankshaft, wmin, wmax, Tmax, fuel_flow)
clutch = Clutch(crankshaft, shaft_gb1, Tmax_c)
gr1 = GearRatio(shaft_gb1, shaft_gb2, 0.05)
brake = Brake(shaft_gb2, Tmax_b)
wheels = Wheel(shaft_gb2, vehicle, r)
# Commands
subs1 = WeightedSum([Vt, vehicle.variable], engine.commands[0], [Ge, -Ge])
v1 = bms.Variable('', hidden=True)
subs2 = WeightedSum([Vt, vehicle.variable], v1, [-Gb, Gb], -Vb)
sat1 = Saturation(v1, brake.commands[0], 0, 1)
# clutch
cc = bms.Variable('Clutch command')
gc = Gain(crankshaft.variable, cc, 1/(wrc-wec), wec/(wec-wrc))
satc = Saturation(cc, clutch.commands[0], 0, 1)
ps = bms.PhysicalSystem(600, 600, [engine, gr1, clutch, wheels, brake], [
subs1, subs2, sat1, gc, satc])
ds = ps.dynamic_system
# ds._ResolutionOrder2()
ds.Simulate()
# e=bmsp.Step(1.,'e')
cc = Sinus(('Clutch command', 'cc'), 0.5, 0.1, 0, 0.5)
it = Step(('Input torque', 'it'), 200)
rt = Step(('Resistant torque', 'rt'), -180)
tc = bms.Variable(('Clutch Torque capacity', 'Tc'))
ct = bms.Variable(('clutch torque', 'ct'))
w1 = bms.Variable(('Rotational speed shaft 1', 'w1'))
w2 = bms.Variable(('Rotational speed shaft 2', 'w2'))
dw12 = bms.Variable(('Clutch differential speed', 'dw12'))
st1 = bms.Variable(('Sum torques on 1', 'st1'))
st2 = bms.Variable(('Sum torques on 2', 'st2'))
b1 = Gain(cc, tc, Cmax)
b2 = WeightedSum([w1, w2], dw12, [1, -1])
b3 = CoulombVariableValue(it, dw12, tc, ct, 1)
# b3=Coulomb(it,dw12,ct,150)
b4 = ODE(st1, w1, [1], [fv1, I1])
b5 = ODE(st2, w2, [1], [fv2, I2])
b6 = WeightedSum([it, ct], st1, [1, 1])
b7 = WeightedSum([rt, ct], st2, [1, -1])
ds = bms.DynamicSystem(50, 150, [b1, b2, b3, b4, b5, b6, b7])
# ds.DrawModel()
r = ds.Simulate()
ds.PlotVariables([[dw12, w1, w2], [tc, ct, rt, it]])
# ds.PlotVariables([[cc]])