def advanced_linear_test(loc, plot=False, plot3d=False):
""" almost entire pipeline """
coil = datastore.coils.iloc[loc]
coil = l_construct(
{
'Lp': coil.Lp,
'Rp': coil.Rp,
'Lb': coil.Lb,
'Rbi': coil.Rbi,
'Rbo': coil.Rbo,
'mu': 100
},
space=5)
convex = convexApprox.Convex_approx(coil.dLz_z, coil.dLz, order=2)
lz = splinify.splinify(convex.dLz_z, coil.L0, d2L=convex.run_approx())
if plot:
plot_l(coil)
test = solver.gaussSolver(lz,
C=0.0047,
R=0.1 + coil.resistance,
E=450,
m=0.031)
res = test._linear_opt(-(5 * coil.Lb) / 2000,
plot=plot,
plot3d=plot3d,
epsilon=0.00005)
# print(res)
if plot:
test.plot_single(res[1])
print(test.computeMaxEc(res[1]),
str(int(test.computeTau(res[1]) * 100)) + "%")
return (test.computeMaxEc(res[1]),
str(int(test.computeTau(res[1]) * 100)) + "%")
def solver_test(loc, nb=1):
""" Compute the dynamic of a solution for a simple case, nb it the number of initial position to try """
coil = datastore.coils.iloc[loc]
convex = convexApprox.Convex_approx(coil.dLz_z, coil.dLz, order=2)
lz = splinify.splinify(convex.dLz_z, coil.L0, d2L=convex.run_approx())
test = solver.gaussSolver(lz, C=0.0047, R=0.1, E=450, m=0.0078)
res = []
for i in range(nb):
res.append(test.solve(-(2.4 * coil.Lb - i) / 2000, 0))
print("ec" + str(i), test.computeMaxEc(res[i]))
print("etotal" + str(i), test.computeMaxE(res[i]))
print("tau" + str(i), test.computeTau(res[i]) * 100)
test.plot_multiple(res)
def find_optimal_launch(loc, C, R, E, v0=0, plot=False, plot3d=False):
"""Compute the optimal launch position
Given a coil number and an electrical setup,
computes the optimal launch position of the projectile
and the key statistics linked (kinetic energy and efficiency).
Use plot to:
- plot the coil parameters
- plot the projection of all launch positions tested
- plot the dynamic of the best solution
Use plot3d to:
- plot the 3d representation of all solutions tested
Arguments:
loc {number} -- coil id
C {number} -- capacity in Farad
R {number} -- circuit resistance without coil in Ohm
E {number} -- capacitor tension in Volts
Keyword Arguments:
v0 {number} -- starting speed for chained coils (default: {0})
plot {bool} -- plot 2d informations (default: {False})
plot3d {bool} -- plot 3d solutions (default: {False})
Returns:
tuple - starting position, system's dynamic, output kinetic energy, power efficiency
"""
coil = datastore.coils.iloc[loc]
m = numpy.pi * coil.Rp**2 * coil.Lp * 7860 * 10**(-9)
convex = convexApprox.Convex_approx(coil.dLz_z,
coil.dLz,
est_freq=utils.estFreq(coil))
lz = splinify.splinify(coil.dLz_z, coil.L0, d2L=convex.run_approx())
if plot:
plot_l_b(coil, lz)
test = solver.gaussSolver(lz,
C=C,
R=(R + coil.resistance),
E=E,
m=m,
v0=v0)
res = test.computeOptimal(-(1.5 * coil.Lb) / 1000, plot=plot, plot3d=plot)
if plot:
test.plot_single(res[1])
print("Coil " + str(coil.name) + " opt launch", test.computeMaxEc(res[1]),
str(int(test.computeTau(res[1]) * 100)) + "%")
return (res[0], res[1], test.computeMaxEc(res[1]), test.computeTau(res[1]))
def linear_test(loc, plot=False, plot3d=False):
""" Compute the optimal launch for a given problem, be careful plot3d takes some time """
coil = datastore.coils.iloc[loc]
convex = convexApprox.Convex_approx(coil.dLz_z, coil.dLz, order=2)
lz = splinify.splinify(convex.dLz_z, coil.L0, d2L=convex.run_approx())
if plot:
plot_l(coil)
test = solver.gaussSolver(lz,
C=0.0047,
R=0.1 + coil.resistance,
E=450,
m=0.031)
res = test._linear_opt(-(5 * coil.Lb) / 2000, plot=plot, plot3d=plot3d)
# print(res)
if plot:
test.plot_single(res[1])
print(test.computeMaxEc(res[1]),
str(int(test.computeTau(res[1]) * 100)) + "%")
return (test.computeMaxEc(res[1]),
str(int(test.computeTau(res[1]) * 100)) + "%")
def vs_old_maple():
""" test vs. some legacy code (not provided) """
coil = l_construct({
'Lp': 22,
'Rp': 4.5,
'Lb': 31,
'Rbi': 6,
'Rbo': 7,
'mu': 3.5,
})
convex = convexApprox.Convex_approx(coil.dLz_z, coil.dLz, order=2)
lz = splinify.splinify(convex.dLz_z, coil.L0, d2L=convex.run_approx())
plot_l(coil)
print("rb", coil.resistance)
test = solver.gaussSolver(lz, C=0.0050, R=0.016 + 0.075, E=170, m=0.0109)
res = test._linear_opt(-0.08, plot=True, plot3d=True, epsilon=0.001)
test.plot_single(res[1])
print(test.computeMaxEc(res[1]),
str(int(test.computeTau(res[1]) * 10000) / 100) + "%")
return (test.computeMaxEc(res[1]),
str(int(test.computeTau(res[1]) * 100)) + "%")
def plot_l(test):
""" Plot the inductance (raw vs. convex approx and splines) """
convex = convexApprox.Convex_approx(test.dLz_z, test.dLz)
lz = splinify.splinify(test.dLz_z, test.L0, dL=convex.run_approx())
z = numpy.linspace(lz.z[0], lz.z[-1], 5000)
ax1 = plt.subplot(311)
plt.plot(z, lz.Lz()(z), color=(0, 0, 1))
plt.setp(ax1.get_xticklabels())
ax2 = plt.subplot(312, sharex=ax1)
plt.plot(lz.z, test.dLz, color=(1, 0, 0))
plt.plot(z, lz.dLz()(z), color=(0, 0, 1))
plt.setp(ax2.get_xticklabels(), visible=False)
plt.subplot(313, sharex=ax1)
plt.plot(lz.z, discrete_fprime(test.dLz, test.dLz_z), color=(1, 0, 0))
plt.plot(lz.z, convex.run_approx(), color=(0, 1, 0))
plt.plot(z, lz.d2Lz()(z), color=(0, 0, 1))
plt.show()
def Mu_impact(cas):
"""Shows the impact of Mu
Given a project setup, computes the inductance
and its 2 derivatives for several Mu values and
plots them nicely.
The output is not raw but the splinified convex
approx.
Arguments:
cas {dict} -- a setup
"""
Lp = cas["Lp"]
Rp = cas["Rp"]
Lb = cas["Lb"]
Rbi = cas["Rbi"]
Rbo = cas["Rbo"]
mu = [5, 10, 50, 100, 500, 1000, 5000] # [5, 10, 50, 100, 500, 1000, 5000]
n = len(mu)
res = []
for k in range(n):
test = coilCalculator(True, 5)
test.defineCoil(Lb, Rbi, Rbo)
test.drawCoil()
test.defineProjectile(Lp, Rp, mu=mu[k])
test.drawProjectile()
test.setSpace()
test.computeL0()
test.computedLz()
res += [max(test.dLz)]
convex = convexApprox.Convex_approx(test.dLz_z, test.dLz, order=2)
lz = splinify.splinify(convex.dLz_z, test.L0, d2L=convex.run_approx())
z = numpy.linspace(2 * lz.z[0], 2 * lz.z[-1], 10000)
ax1 = plt.subplot(321)
plt.plot(z, lz.Lz()(z), color=(k / n, 0, 1 - k / n), label=k)
plt.setp(ax1.get_xticklabels(), visible=False)
ax1 = plt.subplot(322, sharex=ax1)
plt.plot(z, (lz.Lz()(z) - test.L0) / res[-1] + test.L0,
color=(k / n, 0, 1 - k / n),
label=k)
plt.setp(ax1.get_xticklabels(), visible=False)
ax2 = plt.subplot(323, sharex=ax1)
plt.plot(z, lz.dLz()(z), color=(k / n, 0, 1 - k / n), label=k)
plt.setp(ax2.get_xticklabels(), visible=False)
ax2 = plt.subplot(324, sharex=ax1)
plt.plot(z,
lz.dLz()(z) / res[-1],
color=(k / n, 0, 1 - k / n),
label=k)
plt.setp(ax2.get_xticklabels(), visible=False)
plt.subplot(325, sharex=ax1)
plt.plot(z, lz.d2Lz()(z), color=(k / n, 0, 1 - k / n), label=k)
plt.subplot(326, sharex=ax1)
plt.plot(z,
lz.d2Lz()(z) / res[-1],
color=(k / n, 0, 1 - k / n),
label=k)
plt.setp(ax1.get_xticklabels(), visible=False)
plt.show()