def prob3_again():
"""
Using scikits.bvp_solver to solve the bvp
"""
epsilon = .1
lbc, rbc = 0., 1.
def function1(x, y):
return np.array([
y[1], (4. / epsilon) * (pi - x**2.) * y[0] + 1. / epsilon * cos(x)
])
def boundary_conditions(ya, yb):
return (np.array([ya[0] - lbc]), np.array([yb[0] - rbc]))
problem = bvp_solver.ProblemDefinition(
num_ODE=2,
num_parameters=0,
num_left_boundary_conditions=1,
boundary_points=(0., pi / 2.),
function=function1,
boundary_conditions=boundary_conditions)
solution = bvp_solver.solve(problem, solution_guess=(1., 0.))
A = np.linspace(0., pi / 2., 200)
T = solution(A)
plt.plot(A, T[0, :], '-k', linewidth=2.0)
plt.show()
plt.clf()
return
def prob5_again():
"""
Using scikits.bvp_solver to solve the bvp
"""
epsilon = .05
lbc, rbc = 1. / (1. + epsilon), 1. / (1. + epsilon)
def function1(x, y):
return np.array([
y[1],
-4. * x / (epsilon + x**2.) * y[1] - 2. / (epsilon + x**2.) * y[0]
])
def boundary_conditions(ya, yb):
return (np.array([ya[0] - lbc]), np.array([yb[0] - rbc]))
problem = bvp_solver.ProblemDefinition(
num_ODE=2,
num_parameters=0,
num_left_boundary_conditions=1,
boundary_points=(-1, 1),
function=function1,
boundary_conditions=boundary_conditions)
solution = bvp_solver.solve(problem,
solution_guess=(1. / (1. + epsilon), 0.))
A = np.linspace(-1., 1., 200)
T = solution(A)
plt.plot(A, T[0, :], '-k', linewidth=2.0)
plt.show()
plt.clf()
return
def prob5_again():
"""
Using scikits.bvp_solver to solve the bvp
"""
epsilon = 0.05
lbc, rbc = 1.0 / (1.0 + epsilon), 1.0 / (1.0 + epsilon)
def function1(x, y):
return np.array([y[1], -4.0 * x / (epsilon + x ** 2.0) * y[1] - 2.0 / (epsilon + x ** 2.0) * y[0]])
def boundary_conditions(ya, yb):
return (np.array([ya[0] - lbc]), np.array([yb[0] - rbc]))
problem = bvp_solver.ProblemDefinition(
num_ODE=2,
num_parameters=0,
num_left_boundary_conditions=1,
boundary_points=(-1, 1),
function=function1,
boundary_conditions=boundary_conditions,
)
solution = bvp_solver.solve(problem, solution_guess=(1.0 / (1.0 + epsilon), 0.0))
A = np.linspace(-1.0, 1.0, 200)
T = solution(A)
plt.plot(A, T[0, :], "-k", linewidth=2.0)
plt.show()
plt.clf()
return
def prob3_again():
"""
Using scikits.bvp_solver to solve the bvp
"""
epsilon = 0.1
lbc, rbc = 0.0, 1.0
def function1(x, y):
return np.array([y[1], (4.0 / epsilon) * (pi - x ** 2.0) * y[0] + 1.0 / epsilon * cos(x)])
def boundary_conditions(ya, yb):
return (np.array([ya[0] - lbc]), np.array([yb[0] - rbc]))
problem = bvp_solver.ProblemDefinition(
num_ODE=2,
num_parameters=0,
num_left_boundary_conditions=1,
boundary_points=(0.0, pi / 2.0),
function=function1,
boundary_conditions=boundary_conditions,
)
solution = bvp_solver.solve(problem, solution_guess=(1.0, 0.0))
A = np.linspace(0.0, pi / 2.0, 200)
T = solution(A)
plt.plot(A, T[0, :], "-k", linewidth=2.0)
plt.show()
plt.clf()
return
def Exercise4(): # measles
a, b = 0., 1. # Interval of the BVP
n, N = 3, 80 # Dimension of the system/ Number of subintervals
# Tolerance/ Maximum number of Newton steps
TOL, Max_IT = 10.**(-12), 40
init_mesh = np.linspace(a, b, N + 1) # Initial Mesh
lmbda, mu, eta = .0279, .02, .01
def beta1(x):
return 1575. * (1. + np.cos(2. * np.pi * x))
def Guess(x):
S = .1 + .05 * np.cos(2. * np.pi * x)
return np.array([S, 05 * (1. - S), 05 * (1. - S), .05, .05, .05])
def ODE(x, y):
return np.array([
mu - beta1(x) * y[0] * y[2],
beta1(x) * y[0] * y[2] - y[1] / lmbda, y[1] / lmbda - y[2] / eta,
0, 0, 0
])
def g(Ya, Yb):
BCa = Ya[0:3] - Ya[3:]
BCb = Yb[0:3] - Yb[3:]
return BCa, BCb
problem = bvp_solver.ProblemDefinition(num_ODE=6,
num_parameters=0,
num_left_boundary_conditions=3,
boundary_points=(a, b),
function=ODE,
boundary_conditions=g)
solution = bvp_solver.solve(problem,
solution_guess=Guess,
trace=0,
max_subintervals=1000,
tolerance=1e-9)
Num_Sol = solution(np.linspace(a, b, N + 1))
# Guess_array = np.zeros((6,N+1))
# for index, x in zip(range(N+1),np.linspace(a,b,N+1)):
# Guess_array[:,index] = Guess(x)
# plt.plot(np.linspace(a,b,N+1), Guess_array[0,:] ,'-g')
plt.plot(np.linspace(a, b, N + 1),
Num_Sol[0, :],
'-k',
label='Susceptible')
plt.plot(np.linspace(a, b, N + 1), Num_Sol[1, :], '-g', label='Exposed')
plt.plot(np.linspace(a, b, N + 1), Num_Sol[2, :], '-r', label='Infectious')
plt.legend(loc=5) # middle right placement
plt.axis([0., 1., -.01, .1])
plt.xlabel('T (days)')
plt.ylabel('Proportion of Population')
# plt.savefig("measles.pdf")
plt.clf()
def Exercise4(): # measles
a, b = 0., 1. # Interval of the BVP
n, N = 3, 80 # Dimension of the system/ Number of subintervals
# Tolerance/ Maximum number of Newton steps
TOL, Max_IT = 10. ** (-12), 40
init_mesh = np.linspace(a, b, N + 1) # Initial Mesh
lmbda, mu, eta = .0279, .02, .01
def beta1(x):
return 1575. * (1. + np.cos(2. * np.pi * x))
def Guess(x):
S = .1 + .05 * np.cos(2. * np.pi * x)
return np.array([S, 05 * (1. - S), 05 * (1. - S), .05, .05, .05])
def ODE(x, y):
return np.array([mu - beta1(x) * y[0] * y[2],
beta1(x) * y[0] * y[2] - y[1] / lmbda,
y[1] / lmbda - y[2] / eta,
0, 0, 0])
def g(Ya, Yb):
BCa = Ya[0:3] - Ya[3:]
BCb = Yb[0:3] - Yb[3:]
return BCa, BCb
problem = bvp_solver.ProblemDefinition(num_ODE=6,
num_parameters=0,
num_left_boundary_conditions=3,
boundary_points=(a, b),
function = ODE,
boundary_conditions = g)
solution = bvp_solver.solve(problem,
solution_guess=Guess,
trace=0,
max_subintervals=1000,
tolerance=1e-9)
Num_Sol = solution(np.linspace(a, b, N + 1))
# Guess_array = np.zeros((6,N+1))
# for index, x in zip(range(N+1),np.linspace(a,b,N+1)):
# Guess_array[:,index] = Guess(x)
# plt.plot(np.linspace(a,b,N+1), Guess_array[0,:] ,'-g')
plt.plot(np.linspace(a, b, N + 1),
Num_Sol[0, :], '-k', label='Susceptible')
plt.plot(np.linspace(a, b, N + 1),
Num_Sol[1, :], '-g', label='Exposed')
plt.plot(np.linspace(a, b, N + 1),
Num_Sol[2, :], '-r', label='Infectious')
plt.legend(loc=5) # middle right placement
plt.axis([0., 1., -.01, .1])
plt.xlabel('T (days)')
plt.ylabel('Proportion of Population')
plt.savefig("measles.pdf")
plt.clf()
def bvp2_check():
"""
Using scikits.bvp_solver to solve the bvp
y'' + y' + sin y = 0, y(0) = y(2*pi) = 0
y0 = y, y1 = y'
y0' = y1, y1' = y'' = -sin(y0) - y1
"""
from math import exp, pi, sin
lbc, rbc = .1, .1
def function1(x, y):
return np.array([y[1], -sin(y[0]) - y[1]])
def boundary_conditions(ya, yb):
return (
np.array(
[ya[0] - lbc]
), #evaluate the difference between the temperature of the hot stream on the
#left and the required boundary condition
np.array([yb[0] - rbc])
) #evaluate the difference between the temperature of the cold stream on the
#right and the required boundary condition
problem = bvp_solver.ProblemDefinition(
num_ODE=2,
num_parameters=0,
num_left_boundary_conditions=1,
boundary_points=(0, 2. * pi),
function=function1,
boundary_conditions=boundary_conditions)
guess = np.linspace(0., 2. * pi, 10)
guess = np.array([.1 - np.sin(2 * guess), np.sin(2 * guess)])
# plt.plot(guess,np.sin(guess))
# plt.show()
solution = bvp_solver.solve(problem, solution_guess=guess)
#
A = np.linspace(0., 2. * pi, 200)
T = solution(A)
plt.plot(A, T[0, :], '-k', linewidth=2.0)
plt.show()
plt.clf()
N = 150
x = (2. * np.pi / N) * np.arange(1, N + 1).reshape(N, 1)
print x.shape
print solution(x)[0, :].shape
plt.plot(x, solution(x)[0, :])
plt.show()
# np.save('sol',solution(x)[0,:])
return
def bvp2_check():
"""
Using scikits.bvp_solver to solve the bvp
y'' + y' + sin y = 0, y(0) = y(2*pi) = 0
y0 = y, y1 = y'
y0' = y1, y1' = y'' = -sin(y0) - y1
"""
from math import exp, pi, sin
lbc, rbc = .1, .1
def function1(x , y):
return np.array([y[1] , -sin(y[0]) -y[1] ])
def boundary_conditions(ya,yb):
return (np.array([ya[0] - lbc]), #evaluate the difference between the temperature of the hot stream on the
#left and the required boundary condition
np.array([yb[0] - rbc]))#evaluate the difference between the temperature of the cold stream on the
#right and the required boundary condition
problem = bvp_solver.ProblemDefinition(num_ODE = 2,
num_parameters = 0,
num_left_boundary_conditions = 1,
boundary_points = (0, 2.*pi),
function = function1,
boundary_conditions = boundary_conditions)
guess = np.linspace(0.,2.*pi, 10)
guess = np.array([.1-np.sin(2*guess),np.sin(2*guess)])
# plt.plot(guess,np.sin(guess))
# plt.show()
solution = bvp_solver.solve(problem,
solution_guess = guess)
#
A = np.linspace(0.,2.*pi, 200)
T = solution(A)
plt.plot(A, T[0,:],'-k',linewidth=2.0)
plt.show()
plt.clf()
N = 150
x = (2.*np.pi/N)*np.arange(1,N+1).reshape(N,1)
print x.shape
print solution(x)[0,:].shape
plt.plot(x,solution(x)[0,:])
plt.show()
# np.save('sol',solution(x)[0,:])
return
def boundary_conditions(ya,yb):
return (np.array([ya[0] - 1]), np.array([yb[0]]))
# Implementing the ProblemDefinition technique
problem = bvp_solver.ProblemDefinition(num_ODE = 2,
num_parameters = 0,
num_left_boundary_conditions = 1,
boundary_points = (0, np.pi),
function = rhs_function,
boundary_conditions = boundary_conditions)
# Solving the Bvp
solution = bvp_solver.solve(problem,
solution_guess = (2.0,
2.0))
x = np.linspace(0, np.pi/2, 45)
y = solution(x)
print "Solution to the Boundary Value Problem", y
pylab.plot(x, y[0,:],'r-', ms = 2)
pylab.plot(x, y[1,:],'g.-', ms = 2)
pylab.legend('function 1', 'function # 2')
pylab.show()
BCa = np.zeros((2)) BCb = np.zeros((1)) BCa[0] = Ya[0] # u(-1)= 0 BCa[1] = Ya[1]-1.0 #u'(-1) = 1 BCb[0] = Yb[0] # u(1) = 0 return BCa, BCb problem_definition = bvp.ProblemDefinition(num_ODE = 2, num_parameters = 1, num_left_boundary_conditions = 2, boundary_points = (-1.0, 1.0), function = function, boundary_conditions = boundary_conditions) sol = bvp.solve(bvp_problem = problem_definition, solution_guess = [1.0 ,1.0 ], parameter_guess = [168.0 ], trace=1) print sol.parameters fig = plt.figure() x = sol.mesh y = sol.solution plt.plot(x, y[0,:], 'k-', lw=2) plt.plot(x, y[0,:], 'bo', markersize=5) plt.show()
import scikits.bvp_solver as bvp
import numpy as np
import pylab as pl
y0 = 0
y2 = 1
def function(a, x):
return np.array([x[1], np.sin(a) - 9 * x[0]])
def bcs(left, right):
return (np.array([left[0] - y0]), np.array([right[0] - y2]))
problem = bvp.ProblemDefinition(num_ODE=2,
num_parameters=0,
num_left_boundary_conditions=1,
boundary_points=(0, 2),
function=function,
boundary_conditions=bcs)
solution = bvp.solve(problem, solution_guess=(0, 0))
xx = np.linspace(0, 2, 100)
yy = solution(xx)
pl.plot(xx, yy.T)
pl.show()
################################################################ #--------------------------------------------------------------# problem_auxiliary = bvp_solver.ProblemDefinition(num_ODE = 6, num_parameters = 0, num_left_boundary_conditions = 3, boundary_points = (0, T0), function = ode_auxiliary, boundary_conditions = bcs_auxiliary) solution_auxiliary = bvp_solver.solve(problem_auxiliary, solution_guess = guess_auxiliary,trace = 0,max_subintervals = 20000) N = 240 x_guess = linspace(0,T0,N+1) guess = solution_auxiliary(x_guess) #--------------------------------------------------------------# ################################################################ T0 = x_guess[-1] def ode(x,y): u = arctan((6*y[4])/(9*y[0]*y[3] )) rho = rho0*exp(-beta*R*y[2]) out = y[6]*array([ -s*rho*y[0]**2*C_d(u) - g*sin(y[1])/(1+y[2])**2, # G_0
#--------------------------------------------------------------#
################################################################
################################################################
#--------------------------------------------------------------#
problem_auxiliary = bvp_solver.ProblemDefinition(
num_ODE=6,
num_parameters=0,
num_left_boundary_conditions=3,
boundary_points=(0, T0),
function=ode_auxiliary,
boundary_conditions=bcs_auxiliary)
solution_auxiliary = bvp_solver.solve(problem_auxiliary,
solution_guess=guess_auxiliary,
trace=0,
max_subintervals=20000)
N = 240
x_guess = linspace(0, T0, N + 1)
guess = solution_auxiliary(x_guess)
#--------------------------------------------------------------#
################################################################
T0 = x_guess[-1]
def ode(x, y):
u = arctan((6 * y[4]) / (9 * y[0] * y[3]))
rho = rho0 * exp(-beta * R * y[2])
out = y[6] * array([
def reentry_auxiliary_problem(N=240,plot=True):
R = 209
beta = 4.26
rho0 = 2.704e-3
g = 3.2172e-4
s = 26600
T_init = 230
def C_d(u):
return 1.174 - 0.9*cos(u)
def C_l(u):
return 0.6*sin(u)
# Construct initial guess for the auxiliary BVP
# p1, p2, p3 = 1.09835, 6.48578, .347717 # Exact solutions
p1, p2, p3 = 1.3, 4.5, .5
#############################################################
def guess_auxiliary(x):
out = array([ .5*(.36+.27)-.5*(.36-.27)*tanh(.025*(x-.45*T_init)),
pi/180*(.5*(-8.1 + 0)-.5*(-8.1 - 0)*tanh(.025*(x-.25*T_init)) ),
(1/R)*( .5*(4+2.5)-.5*(4-2.5)*tanh(.03*(x-.3*T_init)) -
1.4*cosh(.025*(x-.25*T_init))**(-2) ),
p1*ones(x.shape),
p2*ones(x.shape),
p3*ones(x.shape) ])
return out
#############################################################
def ode_auxiliary(x,y):
u = y[3]*erf( y[4]*(y[5]-x/T_init) )
rho = rho0*exp(-beta*R*y[2])
out = array([-s*rho*y[0]**2*C_d(u) - g*sin(y[1])/(1+y[2])**2,
( s*rho*y[0]*C_l(u) + y[0]*cos(y[1])/(R*(1 + y[2])) -
g*cos(y[1])/(y[0]*(1+y[2])**2) ),
y[0]*sin(y[1])/R,
0,
0,
0 ])
return out
#############################################################
def bcs_auxiliary(ya,yb):
out1 = array([ ya[0]-.36,
ya[1]+8.1*pi/180,
ya[2]-4/R
])
out2 = array([ yb[0]-.27,
yb[1],
yb[2]-2.5/R
])
return out1, out2
#############################################################
problem_auxiliary = bvp_solver.ProblemDefinition(num_ODE = 6,
num_parameters = 0,
num_left_boundary_conditions = 3,
boundary_points = (0., T_init),
function = ode_auxiliary,
boundary_conditions = bcs_auxiliary)
solution_auxiliary = bvp_solver.solve(problem_auxiliary,
solution_guess = guess_auxiliary)
# N = 240 # Number of subintervals
xint_guess = linspace(0,T_init,N+1)
yint_guess = solution_auxiliary(xint_guess)
if plot==True:
# Plot guess for v
plt.plot(xint_guess,np.real(yint_guess[0,:]),'-k',linewidth=2.0)
plt.xlabel('$t$',fontsize=18); plt.ylabel('$v$',fontsize=18)
# plt.savefig('guess_v.pdf')
plt.show(); plt.clf()
# Plot guess for gamma
plt.plot(xint_guess,np.real(yint_guess[1,:]),'-k',linewidth=2.0)
plt.xlabel('$t$',fontsize=18); plt.ylabel(r'$\gamma$',fontsize=18)
# plt.savefig('guess_gamma.pdf');
plt.show(); plt.clf()
# Plot guess for xi
plt.plot(xint_guess,np.real(yint_guess[2,:]),'-k',linewidth=2.0)
plt.xlabel('$t$',fontsize=18); plt.ylabel(r'$\xi$',fontsize=18)
# plt.savefig('guess_xi.pdf')
plt.show(); plt.clf()
# Plot guess for control u
p1, p2, p3 = yint_guess[3,0], yint_guess[4,0], yint_guess[5,0]
plt.plot(xint_guess,p1*erf( p2*(p3-xint_guess/T_init) ),'-k',linewidth=2.0)
plt.xlabel('$t$',fontsize=18); plt.ylabel(r'$u$',fontsize=18)
# plt.savefig('guess_u.pdf')
plt.show(); plt.clf()
return xint_guess, yint_guess
def reentry_auxiliary_problem(N=240, plot=True):
R = 209
beta = 4.26
rho0 = 2.704e-3
g = 3.2172e-4
s = 26600
T_init = 230
def C_d(u):
return 1.174 - 0.9 * cos(u)
def C_l(u):
return 0.6 * sin(u)
# Construct initial guess for the auxiliary BVP
# p1, p2, p3 = 1.09835, 6.48578, .347717 # Exact solutions
p1, p2, p3 = 1.3, 4.5, .5
#############################################################
def guess_auxiliary(x):
out = array([
.5 * (.36 + .27) - .5 * (.36 - .27) * tanh(.025 *
(x - .45 * T_init)),
pi / 180 * (.5 * (-8.1 + 0) - .5 *
(-8.1 - 0) * tanh(.025 * (x - .25 * T_init))),
(1 / R) * (.5 * (4 + 2.5) - .5 *
(4 - 2.5) * tanh(.03 * (x - .3 * T_init)) -
1.4 * cosh(.025 * (x - .25 * T_init))**(-2)),
p1 * ones(x.shape), p2 * ones(x.shape), p3 * ones(x.shape)
])
return out
#############################################################
def ode_auxiliary(x, y):
u = y[3] * erf(y[4] * (y[5] - x / T_init))
rho = rho0 * exp(-beta * R * y[2])
out = array([
-s * rho * y[0]**2 * C_d(u) - g * sin(y[1]) / (1 + y[2])**2,
(s * rho * y[0] * C_l(u) + y[0] * cos(y[1]) / (R * (1 + y[2])) -
g * cos(y[1]) / (y[0] * (1 + y[2])**2)), y[0] * sin(y[1]) / R, 0,
0, 0
])
return out
#############################################################
def bcs_auxiliary(ya, yb):
out1 = array([ya[0] - .36, ya[1] + 8.1 * pi / 180, ya[2] - 4 / R])
out2 = array([yb[0] - .27, yb[1], yb[2] - 2.5 / R])
return out1, out2
#############################################################
problem_auxiliary = bvp_solver.ProblemDefinition(
num_ODE=6,
num_parameters=0,
num_left_boundary_conditions=3,
boundary_points=(0., T_init),
function=ode_auxiliary,
boundary_conditions=bcs_auxiliary)
solution_auxiliary = bvp_solver.solve(problem_auxiliary,
solution_guess=guess_auxiliary)
# N = 240 # Number of subintervals
xint_guess = linspace(0, T_init, N + 1)
yint_guess = solution_auxiliary(xint_guess)
if plot == True:
# Plot guess for v
plt.plot(xint_guess, np.real(yint_guess[0, :]), '-k', linewidth=2.0)
plt.xlabel('$t$', fontsize=18)
plt.ylabel('$v$', fontsize=18)
# plt.savefig('guess_v.pdf')
plt.show()
plt.clf()
# Plot guess for gamma
plt.plot(xint_guess, np.real(yint_guess[1, :]), '-k', linewidth=2.0)
plt.xlabel('$t$', fontsize=18)
plt.ylabel(r'$\gamma$', fontsize=18)
# plt.savefig('guess_gamma.pdf');
plt.show()
plt.clf()
# Plot guess for xi
plt.plot(xint_guess, np.real(yint_guess[2, :]), '-k', linewidth=2.0)
plt.xlabel('$t$', fontsize=18)
plt.ylabel(r'$\xi$', fontsize=18)
# plt.savefig('guess_xi.pdf')
plt.show()
plt.clf()
# Plot guess for control u
p1, p2, p3 = yint_guess[3, 0], yint_guess[4, 0], yint_guess[5, 0]
plt.plot(xint_guess,
p1 * erf(p2 * (p3 - xint_guess / T_init)),
'-k',
linewidth=2.0)
plt.xlabel('$t$', fontsize=18)
plt.ylabel(r'$u$', fontsize=18)
# plt.savefig('guess_u.pdf')
plt.show()
plt.clf()
return xint_guess, yint_guess
def reentry(x_guess,guess,N=240,plot=False):
R = 209
beta = 4.26
rho0 = 2.704e-3
g = 3.2172e-4
s = 26600
T_init = x_guess[-1]
def C_d(u):
return 1.174 - 0.9*cos(u)
def C_l(u):
return 0.6*sin(u)
#############################################################
def ode(x,y):
u = arctan((6*y[4])/(9*y[0]*y[3] ))
rho = rho0*exp(-beta*R*y[2])
out = y[6]*array([
-s*rho*y[0]**2*C_d(u) - g*sin(y[1])/(1+y[2])**2, # G_0
( s*rho*y[0]*C_l(u) + y[0]*cos(y[1])/(R*(1 + y[2])) -
g*cos(y[1])/(y[0]*(1+y[2])**2) ), # G_1
y[0]*sin(y[1])/R, # G_2
-( 30*y[0]**2.*sqrt(rho)+ y[3]*(-2*s*rho*y[0]*C_d(u)) +
y[4]*( s*rho*C_l(u) +cos(y[1])/(R*(1 + y[2])) +
g*cos(y[1])/( y[0]**2*(1+y[2])**2 )
) +
y[5]*(sin(y[1])/R) ), # G_3
-( y[3]*( -g*cos(y[1])/(1+y[2])**2 ) +
y[4]*( -y[0]*sin(y[1])/(R*(1+y[2])) +
g*sin(y[1])/(y[0]*(1+y[2])**2 )
) +
y[5]*(y[0]*cos(y[1])/R ) ), # G_4
-( 5*y[0]**3.*sqrt(rho)*(-beta*R) +
y[3]*(s*beta*R*rho*y[0]**2*C_d(u) + 2*g*sin(y[1])/(1+y[2])**3 ) +
y[4]*(-s*beta*R*rho*y[0]*C_l(u) - y[0]*cos(y[1])/(R*(1+y[2])**2) +
2*g*cos(y[1])/(y[0]*(1+y[2])**3)
)
), # G_5
0 # T' = 0 # G_6
])
return out
#############################################################
def bcs(ya,yb):
out1 = array([ ya[0]-.36,
ya[1]+8.1*pi/180,
ya[2]-4/R
])
out2 = array([yb[0]-.27,
yb[1],
yb[2]-2.5/R,
H(yb)
])
return out1, out2
#############################################################
def H(y):
u = arctan((6*y[4])/(9*y[0]*y[3] ))
rho = rho0*exp(-beta*R*y[2])
out = ( 10*y[0]**3*sqrt(rho) +
y[3]*(-s*rho*y[0]**2*C_d(u) - g*sin(y[1])/(1+y[2])**2 ) +
y[4]*( s*rho*y[0]*C_l(u) + y[0]*cos(y[1])/(R*(1 + y[2])) -
g*cos(y[1])/(y[0]*(1+y[2])**2)
) +
y[5]*y[0]*sin(y[1])/R )
return out
#############################################################
yint = np.concatenate( (guess,T_init*np.ones((1,len(x_guess)))) ,axis=0)
yint[3,:] = -1
p1, p2, p3 = yint[3,0], yint[4,0], yint[5,0]
u = p1*erf( p2*(p3-x_guess/T_init) )
yint[4,:] = 1.5*yint[0,:]*yint[3,:]*np.tan(u)
for j in range(len(yint[5,:])):
y = yint[:6,j]
def new_func(x):
if y[1] < 0 and y[1] > -.05:
y[1] = -.05
if y[1] > 0 and y[1] < .05:
y[1] = .05
y[5] = x
return H(y)
sol = root(new_func,-8)
if j>0:
if sol.success == True:
yint[5,j] = sol.x
else:
yint[5,j] = yint[5,j-1]
else:
if sol.success == True:
yint[5,0] = sol.x
plt.plot(x_guess,yint[5,:])
plt.show(); plt.clf()
problem = bvp_solver.ProblemDefinition(num_ODE = 7,
num_parameters = 0,
num_left_boundary_conditions = 3,
boundary_points = (0., 1),
function = ode,
boundary_conditions = bcs)
solution = bvp_solver.solve(problem,
solution_guess = yint,
initial_mesh = linspace(0,1,len(x_guess)),
max_subintervals=1000,
trace = 1)
# For more info on the available options for bvp_solver, look at
# the docstrings for bvp_solver.ProblemDefinition and bvp_solver.solve
numerical_soln = solution(linspace(0,1,N+1))
u = arctan((6*numerical_soln[4,:])/(9*numerical_soln[0,:]*numerical_soln[3,:] ))
domain = linspace(0,numerical_soln[6,0],N+1)
plt.plot(domain,np.real(numerical_soln[5,:]),'-k',linewidth=2.0)
plt.xlabel('$t$',fontsize=18); plt.ylabel(r'$\lambda_2$',fontsize=18)
# plt.savefig('solution_xi.pdf')
plt.show(); plt.clf()
if plot==True:
# Plot guess for v
plt.plot(domain,np.real(guess[0,:]),'-r',linewidth=2.0)
plt.plot(domain,np.real(numerical_soln[0,:]),'-k',linewidth=2.0)
plt.xlabel('$t$',fontsize=18); plt.ylabel('$v$',fontsize=18)
# plt.savefig('solution_v.pdf')
plt.show(); plt.clf()
# Plot guess for gamma
plt.plot(domain,np.real(guess[1,:]),'-r',linewidth=2.0)
plt.plot(domain,np.real(numerical_soln[1,:]),'-k',linewidth=2.0)
plt.xlabel('$t$',fontsize=18); plt.ylabel(r'$\gamma$',fontsize=18)
# plt.savefig('solution_gamma.pdf')
plt.show(); plt.clf()
# Plot guess for xi
plt.plot(domain,np.real(guess[2,:]),'-r',linewidth=2.0)
plt.plot(domain,np.real(numerical_soln[2,:]),'-k',linewidth=2.0)
plt.xlabel('$t$',fontsize=18); plt.ylabel(r'$\xi$',fontsize=18)
# plt.savefig('solution_xi.pdf')
plt.show(); plt.clf()
# Plot guess for control u
p1, p2, p3 = guess[3,0], guess[4,0], guess[5,0]
plt.plot(domain,p1*erf( p2*(p3-x_guess/T_init) ) ,'-r',linewidth=2.0)
plt.plot(domain,u,'-k',linewidth=2.0)
plt.xlabel('$t$',fontsize=18); plt.ylabel(r'$u$',fontsize=18)
# plt.savefig('solution_u.pdf')
plt.show(); plt.clf()
return ( domain, numerical_soln[0,:], numerical_soln[1,:], numerical_soln[2,:],
numerical_soln[3,:], numerical_soln[4,:], numerical_soln[5,:], u )
num_parameters_c=1,
num_left_boundary_conditions_c=2,
boundary_points=(0, 2.0 * np.pi),
function_c=function,
boundary_conditions_c=boundary_conditions,
function_derivative_c=function_derivative,
boundary_conditions_derivative_c=boundary_conditions_derivative)
def guess(X, P0):
return np.array([np.sin(P0 * X), 0.0, 0.0, -np.cos(P0 * X)])
initmesh = np.linspace(problem.boundary_points[0],
problem.boundary_points[1], 512)
solution = bvp.solve(problem,
initial_mesh=initmesh,
solution_guess=lambda x: guess(x, P0),
parameter_guess=np.array([P0, 0.0]),
trace=2)
x = np.linspace(problem.boundary_points[0], problem.boundary_points[1],
100)
y = solution(x)
print("lambda = " + str(solution.parameters[0]))
solution.save("test_ExampleC1.sol")
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(x, y[0, :], c='C0')
ax.plot(x, y[1, :], c='C0', ls='--')
ax.plot(x, y[2, :], c='C1')
def reentry(x_guess, guess, N=240, plot=False):
R = 209
beta = 4.26
rho0 = 2.704e-3
g = 3.2172e-4
s = 26600
T_init = x_guess[-1]
def C_d(u):
return 1.174 - 0.9 * cos(u)
def C_l(u):
return 0.6 * sin(u)
#############################################################
def ode(x, y):
u = arctan((6 * y[4]) / (9 * y[0] * y[3]))
rho = rho0 * exp(-beta * R * y[2])
out = y[6] * array([
-s * rho * y[0]**2 * C_d(u) - g * sin(y[1]) / (1 + y[2])**2, # G_0
(s * rho * y[0] * C_l(u) + y[0] * cos(y[1]) /
(R * (1 + y[2])) - g * cos(y[1]) / (y[0] * (1 + y[2])**2)), # G_1
y[0] * sin(y[1]) / R, # G_2
-(30 * y[0]**2. * sqrt(rho) + y[3] *
(-2 * s * rho * y[0] * C_d(u)) + y[4] *
(s * rho * C_l(u) + cos(y[1]) / (R *
(1 + y[2])) + g * cos(y[1]) /
(y[0]**2 * (1 + y[2])**2)) + y[5] * (sin(y[1]) / R)), # G_3
-(y[3] * (-g * cos(y[1]) / (1 + y[2])**2) + y[4] *
(-y[0] * sin(y[1]) / (R * (1 + y[2])) + g * sin(y[1]) /
(y[0] * (1 + y[2])**2)) + y[5] * (y[0] * cos(y[1]) / R)), # G_4
-(5 * y[0]**3. * sqrt(rho) * (-beta * R) + y[3] *
(s * beta * R * rho * y[0]**2 * C_d(u) + 2 * g * sin(y[1]) /
(1 + y[2])**3) + y[4] *
(-s * beta * R * rho * y[0] * C_l(u) - y[0] * cos(y[1]) /
(R * (1 + y[2])**2) + 2 * g * cos(y[1]) /
(y[0] * (1 + y[2])**3))), # G_5
0 # T' = 0 # G_6
])
return out
#############################################################
def bcs(ya, yb):
out1 = array([ya[0] - .36, ya[1] + 8.1 * pi / 180, ya[2] - 4 / R])
out2 = array([yb[0] - .27, yb[1], yb[2] - 2.5 / R, H(yb)])
return out1, out2
#############################################################
def H(y):
u = arctan((6 * y[4]) / (9 * y[0] * y[3]))
rho = rho0 * exp(-beta * R * y[2])
out = (10 * y[0]**3 * sqrt(rho) + y[3] *
(-s * rho * y[0]**2 * C_d(u) - g * sin(y[1]) / (1 + y[2])**2) +
y[4] * (s * rho * y[0] * C_l(u) + y[0] * cos(y[1]) /
(R * (1 + y[2])) - g * cos(y[1]) /
(y[0] * (1 + y[2])**2)) + y[5] * y[0] * sin(y[1]) / R)
return out
#############################################################
yint = np.concatenate((guess, T_init * np.ones((1, len(x_guess)))), axis=0)
yint[3, :] = -1
p1, p2, p3 = yint[3, 0], yint[4, 0], yint[5, 0]
u = p1 * erf(p2 * (p3 - x_guess / T_init))
yint[4, :] = 1.5 * yint[0, :] * yint[3, :] * np.tan(u)
for j in range(len(yint[5, :])):
y = yint[:6, j]
def new_func(x):
if y[1] < 0 and y[1] > -.05:
y[1] = -.05
if y[1] > 0 and y[1] < .05:
y[1] = .05
y[5] = x
return H(y)
sol = root(new_func, -8)
if j > 0:
if sol.success == True:
yint[5, j] = sol.x
else:
yint[5, j] = yint[5, j - 1]
else:
if sol.success == True:
yint[5, 0] = sol.x
plt.plot(x_guess, yint[5, :])
plt.show()
plt.clf()
problem = bvp_solver.ProblemDefinition(num_ODE=7,
num_parameters=0,
num_left_boundary_conditions=3,
boundary_points=(0., 1),
function=ode,
boundary_conditions=bcs)
solution = bvp_solver.solve(problem,
solution_guess=yint,
initial_mesh=linspace(0, 1, len(x_guess)),
max_subintervals=1000,
trace=1)
# For more info on the available options for bvp_solver, look at
# the docstrings for bvp_solver.ProblemDefinition and bvp_solver.solve
numerical_soln = solution(linspace(0, 1, N + 1))
u = arctan((6 * numerical_soln[4, :]) /
(9 * numerical_soln[0, :] * numerical_soln[3, :]))
domain = linspace(0, numerical_soln[6, 0], N + 1)
plt.plot(domain, np.real(numerical_soln[5, :]), '-k', linewidth=2.0)
plt.xlabel('$t$', fontsize=18)
plt.ylabel(r'$\lambda_2$', fontsize=18)
# plt.savefig('solution_xi.pdf')
plt.show()
plt.clf()
if plot == True:
# Plot guess for v
plt.plot(domain, np.real(guess[0, :]), '-r', linewidth=2.0)
plt.plot(domain, np.real(numerical_soln[0, :]), '-k', linewidth=2.0)
plt.xlabel('$t$', fontsize=18)
plt.ylabel('$v$', fontsize=18)
# plt.savefig('solution_v.pdf')
plt.show()
plt.clf()
# Plot guess for gamma
plt.plot(domain, np.real(guess[1, :]), '-r', linewidth=2.0)
plt.plot(domain, np.real(numerical_soln[1, :]), '-k', linewidth=2.0)
plt.xlabel('$t$', fontsize=18)
plt.ylabel(r'$\gamma$', fontsize=18)
# plt.savefig('solution_gamma.pdf')
plt.show()
plt.clf()
# Plot guess for xi
plt.plot(domain, np.real(guess[2, :]), '-r', linewidth=2.0)
plt.plot(domain, np.real(numerical_soln[2, :]), '-k', linewidth=2.0)
plt.xlabel('$t$', fontsize=18)
plt.ylabel(r'$\xi$', fontsize=18)
# plt.savefig('solution_xi.pdf')
plt.show()
plt.clf()
# Plot guess for control u
p1, p2, p3 = guess[3, 0], guess[4, 0], guess[5, 0]
plt.plot(domain,
p1 * erf(p2 * (p3 - x_guess / T_init)),
'-r',
linewidth=2.0)
plt.plot(domain, u, '-k', linewidth=2.0)
plt.xlabel('$t$', fontsize=18)
plt.ylabel(r'$u$', fontsize=18)
# plt.savefig('solution_u.pdf')
plt.show()
plt.clf()
return (domain, numerical_soln[0, :], numerical_soln[1, :],
numerical_soln[2, :], numerical_soln[3, :], numerical_soln[4, :],
numerical_soln[5, :], u)
def boundary_conditions(Ta,Tb):
return (np.array([Ta[0] - T10]), np.array([Tb[1] - T2Ahx]))
# Implementing the ProblemDefinition technique
problem = bvp_solver.ProblemDefinition(num_ODE = 2,
num_parameters = 0,
num_left_boundary_conditions = 1,
boundary_points = (0, Ahx),
function = rhs_function,
boundary_conditions = boundary_conditions)
# Solving the Bvp
solution = bvp_solver.solve(problem,
solution_guess = ((T10 + T2Ahx)/2.0,
(T10 + T2Ahx)/2.0))
A = np.linspace(0, Ahx, 45)
T = solution(A)
print "Solution to the Boundary Value Problem", T
pylab.plot(A, T[0,:],'r-', ms = 2)
pylab.plot(A, T[1,:],'g.-', ms = 2)
pylab.legend('function 1', 'function # 2')
pylab.show()
