def delegates():
dqmin = 0.01
dqmax = 0.01
dqerr = 0.01
sys = liqss.Module("delegates", dqmin=dqmin, dqmax=dqmax, dqerr=dqerr)
def f1():
return 1.0 - sys.node1.q + sys.branch1.q
def f2():
return 1.0 - sys.branch1.q - sys.node1.q
node1 = liqss.Atom("node1", func=f1)
branch1 = liqss.Atom("branch1", func=f2)
node1.connect(branch1)
branch1.connect(node1)
sys.add_atoms(node1, branch1)
sys.initialize()
sys.run_to(10.0)
plt.figure()
plt.subplot(2, 1, 1)
plt.plot(node1.tzoh, node1.qzoh, 'b-')
plt.plot(node1.tout, node1.qout, 'k.')
plt.subplot(2, 1, 2)
plt.plot(branch1.tzoh, branch1.qzoh, 'b-')
plt.plot(branch1.tout, branch1.qout, 'k.')
plt.show()
def gencls():
""" Simplified Sync Machine Model simulation
"""
# parameters:
H = 3.0
Kd = 1.0
fs = 60.0
ws = 2 * pi * fs
# intial conditions:
Tm0 = 5.5
# odes:
def dtheta():
return (wr.q - ws) / ws
# model and state stoms:
gencls = liqss.Module("gencls", print_time=True)
theta = liqss.Atom("theta",
x0=theta0,
func=dtheta,
units="rad",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
theta.connects()
ship.add_atoms(theta)
ship.initialize()
ship.run_to(0.0003, fixed_dt=1e-8)
r = 1
c = 2
i = 0
plt.figure()
for i, (name, atom) in enumerate(ship.atoms.items()):
plt.subplot(r, c, i + 1)
plt.plot(atom.tzoh, atom.qzoh, 'b-')
plt.plot(atom.tout, atom.qout, 'k.')
plt.xlabel("t (s)")
plt.ylabel(name + " (" + atom.units + ")")
plt.show()
def stiffline():
dq = 0.01
sys = liqss.Module("stiffline", dqmin=dq, dqmax=dq)
node1 = liqss.Atom("node1", 1.0, 1.0, 1.0)
node2 = liqss.Atom("node2", 1.0e3, 1.0, 1.0)
node3 = liqss.Atom("node3", 1.0e6, 1.0, 1.0)
branch1 = liqss.Atom("branch1", 1.0, 1.0, 1.0)
branch2 = liqss.Atom("branch2", 1.0, 1.0, 1.0)
node1.connect(branch1, -1.0)
node2.connect(branch2, 1.0)
node3.connect(branch2, -1.0)
branch1.connect(node1, 1.0)
branch2.connect(node2, -1.0)
branch2.connect(node3, 1.0)
sys.add_atoms(node1, node2, node3, branch1, branch2)
sys.initialize()
sys.run_to(1.0e5)
plt.figure()
plt.subplot(3, 2, 1)
plt.plot(node1.tzoh, node1.qzoh, 'b-')
plt.plot(node1.tout, node1.qout, 'k.')
plt.subplot(3, 2, 2)
plt.plot(branch1.tzoh, branch1.qzoh, 'b-')
plt.plot(branch1.tout, branch1.qout, 'k.')
plt.subplot(3, 2, 3)
plt.plot(node2.tzoh, node2.qzoh, 'b-')
plt.plot(node2.tout, node2.qout, 'k.')
plt.subplot(3, 2, 4)
plt.plot(branch2.tzoh, branch2.qzoh, 'b-')
plt.plot(branch2.tout, branch2.qout, 'k.')
plt.subplot(3, 2, 5)
plt.plot(node3.tzoh, node3.qzoh, 'b-')
plt.plot(node3.tout, node3.qout, 'k.')
plt.show()
def simple():
sys = liqss.Module("simple")
node1 = liqss.Atom("node1", 1.0, 1.0, 1.0, dq=1e-2)
branch1 = liqss.Atom("branch1", 1.0, 1.0, 1.0, dq=1e-2)
node1.connect(branch1, -1.0)
branch1.connect(node1, 1.0)
sys.add_atoms(node1, branch1)
sys.initialize()
sys.run_to(10.0)
plt.figure()
plt.subplot(2, 1, 1)
plt.plot(node1.tzoh, node1.qzoh, 'b-')
plt.plot(node1.tout, node1.qout, 'k.')
plt.subplot(2, 1, 2)
plt.plot(branch1.tzoh, branch1.qzoh, 'b-')
plt.plot(branch1.tout, branch1.qout, 'k.')
plt.show()
def shipsys2():
# machine parameters:
Prate = 555.0e6 # V.A
Vrate = 24.0e3 # V_LLRMS
freq = 60.0 # Hz
P = 2 # number of poles
wb = 2 * pi * freq # base speed
vb = 4160.0 # base voltage RMS LL
Lad = 1.66
Laq = 1.61
Lo = 0.15
Ll = 0.15
Ra = 0.003
Lfd = 0.165
Rfd = 0.0006
L1d = 0.1713
R1d = 0.0284
L1q = 0.7252
R1q = 0.00619
L2q = 0.125
R2q = 0.2368
J = 2.525 # 27548.0
# derived:
Lffd = Lad + Lfd
Lf1d = Lffd - Lfd
L11d = Lf1d + L1d
L11q = Laq + L1q
L22q = Laq + L2q
# simulation parameters:
dqmin = 1e-7
dqmax = 1e-2
dqerr = 0.005
sr = 80
tstop = 0.1
# initial states:
efd0 = 92.95
fd0 = 0.0
fq0 = 0.0
fo0 = 0.0
ffd0 = 0.0
f1d0 = 0.0
f1q0 = 0.0
f2q0 = 0.0
wr0 = wb
theta0 = 0.0
# algebraic equations:
def id():
return -(((Lad * Lf1d - L11d * Lad) * ffd.q +
(L11d * Lffd - Lf1d**2) * fd.q +
(Lad * Lf1d - Lad * Lffd) * f1d.q) /
((L11d * Lffd - Lf1d**2) * Ll + (L11d * Lad - Lad**2) * Lffd -
Lad * Lf1d**2 + 2 * Lad**2 * Lf1d - L11d * Lad**2))
def iq():
return -(((Laq**2 - L11q * L22q) * fq.q +
(L11q * Laq - Laq**2) * f2q.q +
(L22q * Laq - Laq**2) * f1q.q) /
((Laq**2 - L11q * L22q) * Ll - Laq**3 +
(L22q + L11q) * Laq**2 - L11q * L22q * Laq))
def io():
return -fo.q / Lo
def ifd():
return (((L11d * Ll - Lad**2 + L11d * Lad) * ffd.q +
(Lad * Lf1d - L11d * Lad) * fd.q +
(-Lf1d * Ll - Lad * Lf1d + Lad**2) * f1d.q) /
((L11d * Lffd - Lf1d**2) * Ll + (L11d * Lad - Lad**2) * Lffd -
Lad * Lf1d**2 + 2 * Lad**2 * Lf1d - L11d * Lad**2))
def i1d():
return -(((Lf1d * Ll + Lad * Lf1d - Lad**2) * ffd.q +
(Lad * Lffd - Lad * Lf1d) * fd.q +
(-Lffd * Ll - Lad * Lffd + Lad**2) * f1d.q) /
((L11d * Lffd - Lf1d**2) * Ll + (L11d * Lad - Lad**2) * Lffd -
Lad * Lf1d**2 + 2 * Lad**2 * Lf1d - L11d * Lad**2))
def i1q():
return -(((Laq**2 - L22q * Laq) * fq.q - (Laq * Ll) * f2q.q +
(L22q * Ll - Laq**2 + L22q * Laq) * f1q.q) /
((Laq**2 - L11q * L22q) * Ll - Laq**3 +
(L22q + L11q) * Laq**2 - L11q * L22q * Laq))
def i2q():
return -(((Laq**2 - L11q * Laq) * fq.q +
(L11q * Ll - Laq**2 + L11q * Laq) * f2q.q -
(Laq * Ll) * f1q.q) /
((Laq**2 - L11q * L22q) * Ll - Laq**3 +
(L22q + L11q) * Laq**2 - L11q * L22q * Laq))
def Te():
return fd.q * iq() + fq.q * id()
def ed():
return vb * cos(theta.q)
def eq():
return -vb * sin(theta.q)
def eo():
return 0
def efd():
return efd0
def tm():
return 0
# derivative functions:
def dfd():
# ed = 1/wb * dfd - fq*wr - Ra * id
return wb * (ed() + fq.q * wr.q + Ra * id())
def dfq():
# eq = 1/wb * dfq + fd*wr - Ra * iq
return wb * (eq() + fd.q * wr.q + Ra * iq())
def dfo():
# eo = 1/wb * dfo - Ra * io
return wb * (eo() + Ra * io())
def dffd():
# efd = 1/wb * dffd - Rfd * ifd
return wb * (efd() + Rfd * ifd())
def df1d():
# 0 = 1/wb * df1d - R1d * i1d
return wb * R1d * i1d()
def df1q():
# 0 = 1/wb * df1q - R1q * i1q
return wb * R1q * i1q()
def df2q():
# 0 = 1/wb * df2q - R2q * i2q
return wb * R2q * i2q()
def dwr():
return P / (2 * J) * (Te() - tm())
def dtheta():
return wr.q - wb
ship = liqss.Module("ship", print_time=True)
#tm = liqss.Atom("tm", source_type=liqss.SourceType.RAMP, x1=0.0, x2=Tm0, t1=0.1, t2=5.1, dq=1e4, units="N.m")
#tm = liqss.Atom("tm", source_type=liqss.SourceType.CONSTANT, x1=0.0, units="N.m", dqmin=dqmin, dqmax=dqmax, dqerr=dqerr)
fd = liqss.Atom("fd",
x0=fd0,
func=dfd,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
fq = liqss.Atom("fq",
x0=fq0,
func=dfq,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
fo = liqss.Atom("fo",
x0=fo0,
func=dfo,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
ffd = liqss.Atom("ffd",
x0=ffd0,
func=dffd,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
f1d = liqss.Atom("f1d",
x0=f1d0,
func=df1d,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
f1q = liqss.Atom("f1q",
x0=f1q0,
func=df1q,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
f2q = liqss.Atom("f2q",
x0=f2q0,
func=df2q,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
wr = liqss.Atom("wr",
x0=wr0,
func=dwr,
units="rad/s",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
theta = liqss.Atom("theta",
x0=theta0,
func=dtheta,
units="rad",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
fd.connects(fd, f1d, ffd, fq, wr)
fq.connects(fq, f1q, f2q, fd, wr)
fo.connects(fo)
ffd.connects(fd, f1d, ffd)
f1d.connects(fd, f1d, ffd)
f1q.connects(fq, f1q, f2q)
f2q.connects(fq, f1q, f2q)
wr.connects(fd, fq, f1d, ffd, f1q, f2q, wr)
theta.connects(wr)
ship.add_atoms(fd, fq, fo, ffd, f1d, f1q, f2q, wr, theta)
# simulation:
ship.initialize()
#ship.run_to(tstop)
ship.run_to(0.0003, fixed_dt=1e-8)
r = 5
c = 2
i = 0
plt.figure()
for i, (name, atom) in enumerate(ship.atoms.items()):
plt.subplot(r, c, i + 1)
plt.plot(atom.tzoh, atom.qzoh, 'b-')
#plt.plot(atom.tout, atom.qout, 'k.')
plt.xlabel("t (s)")
plt.ylabel(name + " (" + atom.units + ")")
plt.show()
def shipsys3():
# machine parameters:
f = 60.0
Ld = 7.0e-3
Lq = 5.61e-3
Rs = 1.6e-3
P = 2.0
J = 2.812e4
Tm0 = -2.65e5
Efd = 20.0e3
Cf = 0.001
Clim = 0.001
Lf = 0.001
Rf = 0.001
Lp = 10.0
Rp = 1.0
# simulation parameters:
dqmin = 1e-7
dqmax = 1e-2
dqerr = 0.005
sr = 80
tstop = 0.1
# initial states:
vd0 = 0.0
vq0 = 0.0
idc0 = 0.0
vdc0 = 0.0
ip0 = 0.0
id0 = 0.0
iq0 = 0.0
wm0 = 377.0
theta0 = 0.0
S = sqrt(3 / 2) * 2 * sqrt(3) / pi
wb = 2 * pi * f
def Sd():
return S * cos(theta.q)
def Sq():
return S * sin(theta.q)
# derivative functions:
def dvd():
return 1 / Clim * (id.q - idc.q * Sd())
def dvq():
return 1 / Clim * (iq.q - idc.q * Sq())
def didc():
return 1 / Lf * (vd.q * Sd() + vq.q * Sq() - idc.q * Rf - vdc.q)
def dvdc():
return 1 / Cf * (idc.q - ip.q)
def dip():
return 1 / Lp * (vdc.q - ip.q * Rp)
def did():
return 1 / Ld * (Efd * sin(theta.q) - id.q * Rs - wm.q * iq.q * Lq -
vd.q)
def diq():
return 1 / Lq * (Efd * cos(theta.q) - iq.q * Rs + wm.q * id.q * Ld -
vq.q)
def dwm():
return P / (2 * J) * (3 / 2 * P / 2 *
(id.q * Ld * iq.q - iq.q * Lq * id.q) - Tm0)
def dtheta():
return wm.q - wb
ship = liqss.Module("ship", print_time=True)
#tm = liqss.Atom("tm", source_type=liqss.SourceType.RAMP, x1=0.0, x2=Tm0, t1=0.1, t2=5.1, dq=1e4, units="N.m")
#tm = liqss.Atom("tm", source_type=liqss.SourceType.CONSTANT, x1=0.0, units="N.m", dqmin=dqmin, dqmax=dqmax, dqerr=dqerr)
vd = liqss.Atom("vd",
x0=vd0,
func=dvd,
units="V",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
vq = liqss.Atom("vq",
x0=vq0,
func=dvq,
units="V",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
idc = liqss.Atom("idc",
x0=id0,
func=didc,
units="A",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
vdc = liqss.Atom("vdc",
x0=vd0,
func=dvdc,
units="V",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
ip = liqss.Atom("ip",
x0=ip0,
func=dip,
units="A",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
id = liqss.Atom("id",
x0=id0,
func=did,
units="A",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
iq = liqss.Atom("iq",
x0=iq0,
func=diq,
units="A",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
wm = liqss.Atom("wm",
x0=wm0,
func=dwm,
units="rad/s",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
theta = liqss.Atom("theta",
x0=theta0,
func=dtheta,
units="rad",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
vd.connects(id, iq)
vq.connects(id, iq)
idc.connects(vd, vq, id, iq)
vdc.connects(id, iq, ip)
ip.connects(vdc, ip)
id.connects(vd, vq, id, iq)
iq.connects(vd, vq, id, iq)
wm.connects(id, iq)
theta.connects(wm)
ship.add_atoms(vd, vq, idc, vdc, ip, id, iq, wm, theta)
# simulation:
# no-load startup:
ship.initialize()
#ship.run_to(tstop)
ship.run_to(tstop, fixed_dt=1e-6)
r = 5
c = 2
i = 0
plt.figure()
for i, (name, atom) in enumerate(ship.atoms.items()):
plt.subplot(r, c, i + 1)
plt.plot(atom.tzoh, atom.qzoh, 'b-')
#plt.plot(atom.tout, atom.qout, 'k.')
plt.xlabel("t (s)")
plt.ylabel(name + " (" + atom.units + ")")
plt.show()
def shipsys4():
"""
Machine model:
t_
/
dw = 1/(2*H) * | [(Tm - Te) - K*dw] dt
_/
0
w = w0 + dw
.----------+----------+-------.
| | | |
,-. 1 _|_ 1 > / \
Tm ( ^ ) --- ___ --- > ( v ) Te
`-' 2*H | Kd > \ /
| | | |
'----------+----------+-------'
Ra Xd" 1:Sd Rf Lf
.----VVV--UUU----+---. .-------VVV--UUU---+-----------------.
| ---> | | | ---> | ---> |
+ ,-. Id + _|_ ) || ( idc | ip |
Ed ( ) Vd ___ ) || ( | |
`-' - | ) || ( | <
| | | | + | + < Rp
+----------------+---' '-. _|_ <
| vdc Cf ___ vf |
Ra Xq" 1:Sq | | (
.----VVV--UUU----+---. .-' - | - ( Lp
| ---> | | | | (
+ ,-. Iq + _|_ ) || ( | |
Eq ( ) Vq ___ ) || ( | |
`-' - | ) || ( | |
| | | | | |
+----------------+---' '------------------+-----------------'
Te = Ed * Id - Eq * Iq
Tm = Pm / w
S = sqrt(3/2) * 2 * sqrt(3) / pi
Sd = S * cos(th)
Sq = -S * sin(th)
dw = 1/(2*H) * (Pm - D*w - Te)
dth = w0 - w
"""
# SI Params:
vnom = 4.16e3
sbase = 10.0e6
fbase = 60.0
npole = 2
wbase = 2 * pi * fbase
Jm = 168870
Kd = 200.0
R = 99.225 * 0.02
L = 99.225 * 0.2 / (wbase)
# Electric to Mechanical:
#
# Pe_pu = vdc_pu * idc_pu (V * A = W)
# Pm_pu = Vs_pu * Ft_pu (ship velocity and thrust, m/s * N = W)
#
# Pe_pu = Pm_pu
#
# vdc_pu * idc_pu = Ft_pu * Vs_pu
#
# voltage_scale = thrust_scale = vbase
# current_scale = velocity_scale = ibase
#
#
# Plots:
#
# Vdc/Idc (in SI units)
# Machine speed
# Pm from the machine
# Ship Velocity (m/s) and Propulsion sys Thurst (N)
# Drag in SI units ??? R = V/I = N / m / s = (N.s/m ??)
# (Cummumlative updates/time for all, and state space value @ dt for all, error quanity/time)
# per unit:
vbase = vnom # * sqrt(2) / sqrt(3)
zbase = vbase**2 / sbase #
ibase = sbase / vnom # * sqrt(2) / sqrt(3)
Ra = R / zbase
Xdpp = L * wbase / zbase
Xqpp = L * wbase / zbase
H = Jm * wbase**2 / (2 * sbase * npole)
Ld = 0.019
Lq = 0.019
Rf = 0.01
Lf = 0.1
Cf = 0.1
Clim = 0.0001
M = 0.019 # machine inertia constant
Cm = 1000.0 # effective ship mass as seen from electrical bus
Rp = 1.0
RpDC = 10.0
RpAmp = 2.0
fp = 1 / 30.0 # wave frequency
S = sqrt(3 / 2) * 2 * sqrt(3) / pi
# initial conditions:
Pm0 = 0.5
id0 = 0.38725615779883765
iq0 = 6.014934903090364
wm0 = 0.0
th0 = 14.01835504544383
ic0 = 0.00609485032397113
vd0 = 0.039542153999850754
vq0 = 0.6102210225728883
vc0 = 0.04174084318643379
ip0 = 0.004538490569804933
# inputs:
efd0 = 1.0149
# algebraic functions:
sq = lambda: S * cos(th.q)
sd = lambda: -S * sin(th.q)
ed = lambda: efd0 * sin(th.q)
eq = lambda: efd0 * cos(th.q)
def pe():
Pe = 3 / 2 * (ed() * id.q - eq() * iq.q)
#print(Pe)
return Pe
# diff eq:
did = lambda: 1 / Ld * (ed() - id.q * 0.02 - wm.q * iq.q * 0.019 - 1.0)
diq = lambda: 1 / Lq * (eq() - iq.q * 0.02 + wm.q * id.q * 0.019)
dwm = lambda: 1 / 10.0 * (Pm.q - Kd * wm.q + pe())
dth = lambda: -wm.q * wbase
dvd = lambda: 1 / 0.1 * (id.q - ic.q * sd() - 10.0 * vd.q)
dvq = lambda: 1 / 0.1 * (iq.q - ic.q * sq() - 10.0 * vq.q)
dvc = lambda: 1 / 0.1 * (ic.q - ip.q)
dic = lambda: 1 / 0.1 * (vd.q * sd() + vq.q * sq() - ic.q * 0.01 - vc.q)
dip = lambda: 1 / Cm * (vc.q - ip.q * rp.q)
dqmin = 0.0001
dqmax = 0.001
dqerr = 0.001
sys = liqss.Module("shipsys", dqmin=dqmin, dqmax=dqmax, dqerr=dqerr)
Pm = liqss.Atom("Pm",
source_type=liqss.SourceType.RAMP,
x1=0.5,
x2=1.0,
t1=5.0,
t2=30.0,
units="MW",
output_scale=sbase * 1e-6)
rp = liqss.Atom("rp",
source_type=liqss.SourceType.SINE,
units="",
x0=RpDC,
xa=RpAmp,
freq=fp,
t1=30.0,
dq=0.0001,
output_scale=zbase)
id = liqss.Atom("id",
x0=id0,
func=did,
units="A",
dq=0.01,
output_scale=ibase)
iq = liqss.Atom("iq",
x0=iq0,
func=diq,
units="A",
dq=0.01,
output_scale=ibase)
wm = liqss.Atom("wm",
x0=wm0,
func=dwm,
units="RPM",
dq=0.001,
output_scale=wbase * 9.5493)
th = liqss.Atom("th",
x0=th0,
func=dth,
units="deg",
dq=0.001,
output_scale=180.0 / pi)
vd = liqss.Atom("vd",
x0=vd0,
func=dvd,
units="kV",
dq=0.01,
output_scale=vbase * 1e-3)
vq = liqss.Atom("vq",
x0=vq0,
func=dvq,
units="kV",
dq=0.01,
output_scale=vbase * 1e-3)
vc = liqss.Atom("vc",
x0=vc0,
func=dvc,
units="kV",
dq=0.01,
output_scale=vbase * 1e-3)
ic = liqss.Atom("ic",
x0=ic0,
func=dic,
units="A",
dq=0.01,
output_scale=ibase)
ip = liqss.Atom("ip",
x0=ip0,
func=dip,
units="knots",
dq=0.00001,
output_scale=ibase * 1.94384)
id.connects(th)
iq.connects(th)
wm.connects(Pm, id, iq, th)
th.connects(wm)
vd.connects(id, ic, th)
vq.connects(iq, ic, th)
vc.connects(ic, ip)
ic.connects(vd, vq, vc)
ip.connects(vc, rp)
sys.add_atoms(Pm, id, iq, wm, th)
sys.add_atoms(ic, vd, vq, vc, ic, ip, rp)
# scenerio 1 (flat seas, slow)
if 0:
sys.initialize()
Rp = 1.0
sys.run_to(1.0, verbose=True) #, fixed_dt=1.0e-2)
# scenerio 2 (fast, flat)
if 0:
sys.initialize()
Rp = 0.1
sys.run_to(300.0, verbose=True) #, fixed_dt=1.0e-2)
# scenerio 3 (choppy)
if 1:
sys.initialize()
sys.run_to(10.0, verbose=True) #, fixed_dt=1.0e-2)
# scenerio 2: plot time/quantum for the first few seconds
f = open(r"c:\temp\initcond.txt", "w")
r, c, j = 6, 2, 1
plt.figure()
for i, (name, atom) in enumerate(sys.atoms.items()):
dat = open(r"c:\temp\output_{}_{}.dat".format(name, atom.units), "w")
for t, x in zip(atom.tzoh, [x * atom.output_scale for x in atom.qzoh]):
dat.write("{}\t{}\n".format(t, x))
f.write(" {}0 = {}\n".format(name, atom.x))
if name in ("id", "iq"): continue
plt.subplot(r, c, j)
plt.plot(atom.tzoh, [x * atom.output_scale for x in atom.qzoh], 'b-')
#plt.plot(atom.tout, atom.qout, 'k.')
plt.xlabel("t (s)")
plt.ylabel(name + " (" + atom.units + ")")
j += 1
dat.close()
f.close()
plt.show()
def genset():
# parametmrs:
# machine:
f = 50.0
wb = 2 * pi * f
Ld = 7.0e-3
Ll = 2.5067e-3
Lm = 6.6659e-3
LD = 8.7419e-3
LF = 7.3835e-3
Lq = 5.61e-3
MQ = 4.7704e-3
Ra = 0.001
Rs = 1.6e-3
RF = 9.845e-4
RD = 0.11558
RQ = 0.0204
n = 1.0
J = 2.812e4
Xd = wb * Ld
Ra = Rs
# converter:
Rf = 0.001
Lf = 0.01
Cf = 0.01
Clim = 0.001
Rlim = 100.0
# propulsion system:
Rp = 100.0
Lp = 1000.0
# avr control:
Ka = 10.0 / 120.0e3
Ta = 10.0
Tm_max = -2.65e5
vb = 20.0e3
efd0 = 10.3
efd_cmd = 9.406
# simulation parametmrs:
dqmin = 1e-7
dqmax = 1e-2
dqerr = 0.005
sr = 80
tstop = 5.0
# derived:
det1 = Lm * (Lm**2 - LF * Lm) + Lm * (Lm**2 - LD * Lm) + (Ll + Ld) * (
LD * LF - Lm**2)
det2 = (Lq + Ll) * MQ - MQ**2
a11 = (LD * LF - Lm**2) / det1
a12 = (Lm**2 - LD * Lm) / det1
a13 = (Lm**2 - LF * Lm) / det1
a21 = (Lm**2 - LD * Lm) / det1
a22 = (LD * (Ll + Ld) - Lm**2) / det1
a23 = (Lm**2 - (Ll + Ld) * Lm) / det1
a31 = (Lm**2 - LF * Lm) / det1
a32 = (Lm**2 - (Ll + Ld) * Lm) / det1
a33 = (LF * (Ll + Ld) - Lm**2) / det1
b11 = MQ / det2
b12 = -MQ / det2
b21 = -MQ / det2
b22 = (Lq + Ll) / det2
# initial states:
tm0 = -212000.0
fdr0 = 58.44942346499838
fqr0 = -25.271948253597103
fF0 = 69.33085257064145
fD0 = 61.82320401807718
fQ0 = -14.852994683671291
wr0 = 314.1592653589795
theta0 = 0.40811061756185407
vdc0 = 9887.2451996174
vt0 = 7321.34308456133
idc0 = 98.87242841394591
vf0 = 9887.146328154422
ip0 = 98.87242831447921
S = sqrt(3 / 2) * 2 * sqrt(3) / pi
# algebraic functions:
def Sd():
return S * cos(theta.q)
def Sq():
return -S * sin(theta.q)
def efd():
return efd0
def id():
return a11 * fdr.q + a12 * fF.q + a13 * fD.q
def iq():
return b11 * fqr.q + b12 * fQ.q
def iF():
return a21 * fdr.q + a22 * fF.q + a23 * fD.q
def iD():
return a31 * fdr.q + a32 * fF.q + a33 * fD.q
def iQ():
return b21 * fqr.q + b22 * fQ.q
def vt():
return sqrt(Xd**2 + Ra**2) * sqrt((iq() - Sq() * idc.q)**2 +
(id() - Sd() * idc.q)**2)
def ed():
return vb * sin(theta.q)
def eq():
return vb * cos(theta.q)
def vdc():
return (Sd() * (Ra * (id() - Sd() * idc.q) - Xd *
(iq() - Sq() * idc.q)) + Sq() *
(Ra * (iq() - Sq() * idc.q) + Xd * (id() - Sd() * idc.q)))
# derivative functions:
def didc():
return 1 / Lf * (Vdc.q - idc.q * Rf - vf.q)
def dvf():
return 1 / Cf * (idc.q - ip.q)
def dip():
return 1 / Lp * (vf.q - ip.q * Rp)
def dfdr():
return ed() - Rs * id() + wr.q * fqr.q
def dfqr():
return eq() - Rs * iq() - wr.q * fdr.q
def dfF():
return efd() - iF() * RF
def dfD():
return -iD() * RD
def dfQ():
return -iQ() * RQ
def dwr():
return (n / J) * (iq() * fdr.q - id() * fqr.q - tm.q)
def dtheta():
return wr.q - wb
def davr():
#return (1/Ta) * (Ka * sqrt(vd.q**2 + vq.q**2) - avr.q)
return (1 / Ta) * (Ka * vdc.q - avr.q
) # v = i'*L + i*R i' = (R/L)*(v/R - i)
ship = liqss.Module("genset",
print_time=True,
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
# machine:
#tm = liqss.Atom("tm", source_type=liqss.SourceType.RAMP, x1=Tm_max, x2=Tm_max*0.8, t1=30.0, t2=60.0, dq=1e4, units="N.m")
#tm = liqss.Atom("tm", source_type=liqss.SourceType.CONSTANT, x0=tm0, units="N.m", dqmin=dqmin, dqmax=dqmax, dqerr=dqerr)
tm = liqss.Atom("tm",
source_type=liqss.SourceType.STEP,
x0=tm0,
x1=tm0 * 1.1,
t1=10.0,
units="N.m")
fdr = liqss.Atom("fdr",
x0=fdr0,
func=dfdr,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
fqr = liqss.Atom("fqr",
x0=fqr0,
func=dfqr,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
fF = liqss.Atom("fF",
x0=fF0,
func=dfF,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
fD = liqss.Atom("fD",
x0=fD0,
func=dfD,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
fQ = liqss.Atom("fQ",
x0=fQ0,
func=dfQ,
units="Wb",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
wr = liqss.Atom("wr",
x0=wr0,
func=dwr,
units="rad/s",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
theta = liqss.Atom("theta",
x0=theta0,
func=dtheta,
units="rad",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
idc = liqss.Atom("idc",
x0=idc0,
func=didc,
units="A",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
vf = liqss.Atom("vf",
x0=vf0,
func=dvf,
units="V",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr,
dmax=0.1)
ip = liqss.Atom("ip",
x0=ip0,
func=dip,
units="A",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
Vdc = liqss.Atom("vdc",
source_type=liqss.SourceType.FUNCTION,
srcfunc=vdc,
srcdt=1e-3,
x0=vdc0,
units="V",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
Vt = liqss.Atom("vt",
source_type=liqss.SourceType.FUNCTION,
srcfunc=vt,
srcdt=1e-3,
x0=vt0,
units="V",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
fdr.connects(fdr, fqr, fF, fD, wr, theta)
fqr.connects(fdr, fqr, fF, fD, wr, theta)
fF.connects(fdr, fqr, fF, fD, wr, theta)
fD.connects(fdr, fqr, fF, fD, wr, theta)
fQ.connects(fdr, fqr, fF, fD, wr, theta)
wr.connects(fqr, fdr, fF, fD, fQ, tm)
theta.connects(wr)
idc.connects(fdr, fF, fD, fqr, fQ, theta, vf)
vf.connects(idc, ip)
ip.connects(vf)
ship.add_atoms(tm, fdr, fqr, fF, fD, fQ, wr, theta)
ship.add_atoms(Vdc, Vt)
ship.add_atoms(idc, vf, ip)
# simulation:
ship.initialize()
#ship.run_to(50.0, fixed_dt=1e-3)
ship.run_to(10.0, verbose=True)
Rp *= 0.8
#ship.run_to(90.0, fixed_dt=1e-3)
ship.run_to(10.01, verbose=True)
# plot all results:
r, c = 4, 4
plt.figure()
f = open(r"c:\temp\initcond.txt", "w")
for i, (name, atom) in enumerate(ship.atoms.items()):
plt.subplot(r, c, i + 1)
plt.plot(atom.tzoh, atom.qzoh, 'b-')
#plt.plot(atom.tout, atom.qout, 'k.')
plt.xlabel("t (s)")
plt.ylabel(name + " (" + atom.units + ")")
f.write(" {}0 = {}\n".format(name, atom.q))
f.close()
plt.show()
def genphasor():
# simulation parameters:
dqmin = 0.03
dqmax = 0.03
dqerr = 0.01
# per unit bases:
sbase = 100.0
fbase = 60.0
# parameters (per unit):
Ra = 0.001
Tdop = 5.000
Tdopp = 0.060
Tqop = 0.200
Tqopp = 0.060
H = 3.000
D = 0.000
Xd = 1.600
Xq = 1.550
Xdp = 0.700
Xqp = 0.850
Xdpp = 0.350
Xqpp = 0.350
Xl = 0.200
Pmech = 100.0 / sbase
# derived:
omega0 = 2.0 * pi * fbase
G = Ra / (Xdpp**2 + Ra**2)
B = -Xdpp / (Xdpp**2 + Ra**2)
# initial conditions:
delta0 = 0.0
eqpp0 = 0.0
edpp0 = 0.0
eqp0 = 0.0
edp0 = 0.0
# algebraic functions:
def Telec():
return edpp.q * iq() - eqpp.q * id()
def id():
return ((Ra * edpp.q + Xdpp * eqpp.q) * omega.q) / (
(Xdpp**2 + Ra**2) * omega0)
def iq():
return ((Ra * eqpp.q - Xdpp * edpp.q) * omega.q) / (
(Xdpp**2 + Ra**2) * omega0)
def theta():
return delta.q
def Isource():
return complex(
cos(delta.q) * id - sin(delta.q) * iq,
cos(delta.q) * iq + sin(delta.q) * id)
def efd():
return 1.0
# derivative functions:
def ddelta():
return omega.q * omega0
def domega():
return 1 / (2 * H) * ((Pmech - D * omega.q) / (1 + omega.q) - Telec())
def deqpp():
return (edp.q - edpp.q + (Xqp - Xl) * iq()) / Tqopp
def dedpp():
return (eqp.q - eqpp.q - (Xdp - Xl) * id()) / Tdopp
def deqp():
return (efd() - (Xd - Xdpp) / (Xdp - Xdpp) * eqp.q + (Xd - Xdp) /
(Xdp - Xdpp) * eqpp.q) / Tdop
def dedp():
return (-(Xq - Xqpp) / (Xqp - Xqpp) * edp.q + (Xq - Xqp) /
(Xqp - Xqpp) * edpp.q) / Tqop
# system object:
sys = liqss.Module("genphasor", dqmin=dqmin, dqmax=dqmax, dqerr=dqerr)
# atoms:
delta = liqss.Atom("delta",
x0=delta0,
func=ddelta,
units="rad",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
omega = liqss.Atom("omega",
x0=omega0,
func=domega,
units="rad/s",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
eqpp = liqss.Atom("eqpp",
x0=eqpp0,
func=deqpp,
units="vpu",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
edpp = liqss.Atom("edpp",
x0=edpp0,
func=dedpp,
units="vpu",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
eqp = liqss.Atom("eqp",
x0=eqp0,
func=deqp,
units="vpu",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
edp = liqss.Atom("edp",
x0=edp0,
func=dedp,
units="vpu",
dqmin=dqmin,
dqmax=dqmax,
dqerr=dqerr)
sys.add_atoms(delta, omega, eqpp, edpp, eqp, edp)
sys.initialize()
sys.run_to(0.1, verbose=True, fixed_dt=1.0e-6)
#sys.run_to(2.0, verbose=True, fixed_dt=1.0e-4)
# plot all results:
r = 3
c = 2
i = 0
plt.figure()
f = open(r"c:\temp\initcond.txt", "w")
j = 0
for i, (name, atom) in enumerate(sys.atoms.items()):
plt.subplot(r, c, j + 1)
plt.plot(atom.tzoh, atom.qzoh, 'b-')
#plt.plot(atom.tout, atom.qout, 'k.')
plt.xlabel("t (s)")
plt.ylabel(name + " (" + atom.units + ")")
j += 1
f.write("\t{}0 = {}\n".format(name, atom.q))
f.close()
plt.show()
def dynphasor():
"""
I
--->
.---VVV---UUU---o------.------.
+| R L | | | +
E (~) C === G [ ] H (~) v V
-| | | | -
'---------------+------'------'
_|_
-
VL = ZL * IL + d*IL/dt * L
E = I'*L + I*(R + jwL) + V
I = V'*C + V*(G + 1/jwC) + H
I' = (1/L) * (E - I*(R + jwL)) - V
V' = (1/C) * (I - V*(G + 1/jwC)) - H
"""
dqmin = 0.03
dqmax = 0.03
dqerr = 0.01
f = 2.0
omega = 2.0 * pi * f
E = rect(1.0, 0.0)
H = rect(1.0, 0.0)
R = 10.0
L = 1.0
C = 1.0
G = 10.0
jwL = complex(0.0, omega * L)
jwC = complex(0.0, omega * C)
sys = liqss.Module("dynphasor", dqmin=dqmin, dqmax=dqmax, dqerr=dqerr)
def dI():
return (1 / L) * (E - branch1.q * (R + jwL)) - node1.q
def dV():
return (1 / C) * (branch1.q - node1.q * (G + 1 / jwC)) - H
branch1 = liqss.ComplexAtom("branch1",
units="A",
func=dI,
dq=0.00002,
freq1=f)
node1 = liqss.ComplexAtom("node1", units="V", func=dV, dq=0.00001, freq1=f)
branch1.connect(node1)
node1.connect(branch1)
sys.add_atoms(node1, branch1)
sys.initialize()
sys.run_to(4, verbose=True)
E = 2.0 * E
sys.run_to(8, verbose=True)
plot_cqss(node1, branch1)