Python Programs.pdf. University of California, Berkeley. From the SelectedWorks of David D Nolte. David D Nolte. April 22, 2019

Transcription

1 University of California, Berkeley From the SelectedWorks of David D Nolte April 22, 2019 Python Programs.pdf David D Nolte Available at:

2 Python Scripts for 2D, 3D and 4D Flows Flow2D.py Simple flows for 2D autonomous dynamical systems. Options are: Medio, van der Pol, and Fitzhugh-Nagumo models. Flow3D.py Flows for 3D autonomous dynamical systems. Options are: Lorenz, Rössler and Chua s Circuit. DampedDriven.py Driven-damped oscillators. Options are: driven-damped pendulum and drivendamped double well potential. Plots a two-dimensional Poincaré section. Hamilton4D.py Hamiltonian flows for 4D autonomous systems. Options are: Henon-Heiles potential, and the crescent potential. Plots a two-dimensional Poincaré section. Perturbed.py Driven undampded oscillators with a plane-wave perturbation. Options are: pendulum and double-well potential. These are driven nonlinear Hamiltonian systems. When driven at small perturbation amplitude near the separatrix, chaos emerges. These systems do not conserve energy, because there is a constant input and output of energy as the system reacts against the drive force. Plots a two-dimensional Poincaré section. Lozi.py Discrete iterated Lozi map conserves volume. StandMap.py The Chirikov map, also known as the standard map, is a discrete itereated map with winding numbers and islands of stability. WebMap.py The discrete map of a periodically kicked oscillator displays a broad web of dynamics. D. D. Nolte 1

3 Flow2D.py #!/usr/bin/env python3 # -*- coding: utf-8 -*- Created on Mon Apr 16 07:38:57 David Nolte import numpy as np from scipy import integrate from matplotlib import pyplot as plt plt.close('all') # model_case 1 = Medio # model_case 2 = vdp # model_case 3 = Fitzhugh-Nagumo model_case = int(input('input Model Case (1-3)')) def solve_flow(param,lim = [-3,3,-3,3],max_time=10.0): if model_case == 1: # Medio 2D flow def flow_deriv(x_y, t0, a,b,c,alpha): #Compute the time-derivative of a Medio system. x, y = x_y return [a*y + b*x*(c - y**2),-x+alpha] model_title = 'Medio Economics' elif model_case == 2: # van der pol 2D flow def flow_deriv(x_y, t0, alpha,beta): #Compute the time-derivative of a Medio system. x, y = x_y return [y,-alpha*x+beta*(1-x**2)*y] model_title = 'van der Pol Oscillator' # Fitzhugh-Nagumo def flow_deriv(x_y, t0, alpha, beta, gamma): #Compute the time-derivative of a Medio system. x, y = x_y return [y-alpha,-gamma*x+beta*(1-y**2)*y] model_title = 'Fitzhugh-Nagumo Neuron' D. D. Nolte 2

4 plt.figure() xmin = lim[0] xmax = lim[1] ymin = lim[2] ymax = lim[3] plt.axis([xmin, xmax, ymin, ymax]) N=144 colors = plt.cm.prism(np.linspace(0, 1, N)) x0 = np.zeros(shape=(n,2)) ind = -1 for i in range(0,12): for j in range(0,12): ind = ind + 1; x0[ind,0] = ymin-1 + (ymax-ymin+2)*i/11 x0[ind,1] = xmin-1 + (xmax-xmin+2)*j/11 # Solve for the trajectories t = np.linspace(0, max_time, int(250*max_time)) x_t = np.asarray([integrate.odeint(flow_deriv, x0i, t, param) for x0i in x0]) for i in range(n): x, y = x_t[i,:,:].t lines = plt.plot(x, y, '-', c=colors[i]) plt.setp(lines, linewidth=1) plt.show() plt.title(model_title) plt.savefig('flow2d') return t, x_t if model_case == 1: param = (0.9,0.7,0.5,0.6) # Medio lim = (-7,7,-5,5) elif model_case == 2: param = (5, 0.5) # van der Pol lim = (-7,7,-10,10) D. D. Nolte 3

5 param = (0.02,0.5,0.2) lim = (-7,7,-4,4) # Fitzhugh-Nagumo t, x_t = solve_flow(param,lim) D. D. Nolte 4

6 Flow3D.py #!/usr/bin/env python3 # -*- coding: utf-8 -*- Created on Mon Apr 16 07:38:57 nolte import numpy as np import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D from scipy import integrate from matplotlib import pyplot as plt plt.close('all') fig = plt.figure() ax = fig.add_axes([0, 0, 1, 1], projection='3d') ax.axis('on') # model_case 1 = Lorenz # model_case 2 = Rossler # model_case 3 = Chua model_case = int(input('enter Model Case (1-3)')); def solve_lorenz(param, max_time=8.0, angle=0.0): if model_case == 1: # Lorenz 3D flow def flow_deriv(x_y_z, t0, sigma, beta, rho): #Compute the time-derivative of a Lorenz system. x, y, z = x_y_z return [sigma * (y - x), x * (rho - z) - y, x * y - beta * z] model_title = 'Lorenz Attractor' elif model_case == 2: # Rossler 3D flow def flow_deriv(x_y_z, t0, sigma, beta, rho): #Compute the time-derivative of a Medio system. x, y, z = x_y_z return [-y-z, x + sigma*y, beta + z*(x - rho)] model_title = 'Rossler Attractor' # Chua 3D flow def flow_deriv(x_y_z, t0, alpha, beta, c, d): D. D. Nolte 5

7 #Compute the time-derivative of a Medio system. x, y, z = x_y_z f = c*x + 0.5*(d-c)*(abs(x+1)-abs(x-1)) return [alpha*(y-x-f), x-y+z, -beta*y] model_title = 'Chua Attractor' N=12 colors = plt.cm.prism(np.linspace(0, 1, N)) # Choose random starting points, uniformly distributed from -15 to 15 np.random.seed(1) x0 = init1 + init2*np.random.random((n, 3)) # Settle-down Solve for the trajectories t = np.linspace(0, max_time/4, int(250*max_time/4)) x_t = np.asarray([integrate.odeint(flow_deriv, x0i, t, param) for x0i in x0]) # Solve for trajectories x0 = x_t[0:n,int(250*max_time/4)-1,0:3] t = np.linspace(0, max_time, int(250*max_time)) x_t = np.asarray([integrate.odeint(flow_deriv, x0i, t, param) for x0i in x0]) # choose a different color for each trajectory # colors = plt.cm.viridis(np.linspace(0, 1, N)) # colors = plt.cm.rainbow(np.linspace(0, 1, N)) # colors = plt.cm.spectral(np.linspace(0, 1, N)) colors = plt.cm.prism(np.linspace(0, 1, N)) for i in range(n): x, y, z = x_t[i,:,:].t lines = ax.plot(x, y, z, '-', c=colors[i]) plt.setp(lines, linewidth=0.5) ax.view_init(30, angle) plt.show() plt.title(model_title) plt.savefig('flow3d') return t, x_t D. D. Nolte 6

8 if model_case == 1: param = (10, 8/3, 28) # Lorenz ax.set_xlim((-25, 25)) ax.set_ylim((-35, 35)) ax.set_zlim((5, 55)) max_time = 50.0 init1 = -15 init2 = 30 elif model_case == 2: param = (0.2, 0.2, 5.7) # Rossler ax.set_xlim((-15, 15)) ax.set_ylim((-15, 15)) ax.set_zlim((0, 20)) max_time = 200 init1 = -15 init2 = 30 param = (15.6, 28.0, -0.7, ) ax.set_xlim((-3, 3)) ax.set_ylim((-1, 1)) ax.set_zlim((-3, 3)) max_time = 100 init1 = 0 init2 = 0.1 # Chua t, x_t = solve_lorenz(param, max_time,angle=30) plt.figure(2) lines = plt.plot(t,x_t[1,:,0],t,x_t[1,:,1],t,x_t[1,:,2]) plt.setp(lines, linewidth=1) for i in range(4): plt.figure(3) lines = plt.plot(x_t[i,:,0],x_t[i,:,1]) plt.setp(lines,linewidth=0.5) plt.figure(4) lines = plt.plot(x_t[i,:,1],x_t[i,:,2]) plt.setp(lines,linewidth=0.5) plt.figure(5) lines = plt.plot(x_t[i,:,0],x_t[i,:,2]) plt.setp(lines,linewidth=0.5) D. D. Nolte 7

9 D. D. Nolte 8

10 DampedDriven.py #!/usr/bin/env python3 # -*- coding: utf-8 -*- Created on Wed May 21 06:03:32 nolte import numpy as np import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D from scipy import integrate from matplotlib import pyplot as plt from matplotlib import cm import time import os plt.close('all') # model_case 1 = Pendulum # model_case 2 = Double Well model_case = int(input('enter the Model Case (1-2)')) if model_case == 1: F = 1.2 # 0.6 delt = 0.5 # 0.1 w = 2/3 # 0.7 def flow_deriv(x_y_z,tspan): x, y, z = x_y_z a = y b = F*np.cos(w*tspan) - np.sin(x) - delt*y c = w return[a,b,c] alpha = -1 # -1 beta = 1 # 1 gam = 0.3 # 0.3 delta = 0.15 # 0.15 w = 1 def flow_deriv(x_y_z,tspan): x, y, z = x_y_z a = y b = gam*np.cos(w*tspan) - alpha*x - beta*x**3 - delta*y c = w D. D. Nolte 9

11 return[a,b,c] T = 2*np.pi/w px1 =.1 xp1 =.1 w1 = 0 x_y_z = [xp1, px1, w1] # Settle-down Solve for the trajectories t = np.linspace(0, 1000, 10000) x_t = integrate.odeint(flow_deriv, x_y_z, t) x0 = x_t[9999,0:3] tspan = np.linspace(1,40000,400000) x_t = integrate.odeint(flow_deriv, x0, tspan) siztmp = np.shape(x_t) siz = siztmp[0] if model_case == 1: y1 = np.mod(x_t[:,0]-np.pi,2*np.pi)-np.pi y2 = x_t[:,1] y3 = x_t[:,2] y1 = x_t[:,0] y2 = x_t[:,1] y3 = x_t[:,2] plt.figure(2) lines = plt.plot(y1,y2,'ko',ms=1) plt.setp(lines, linewidth=0.5) plt.show() repnum = 5000 px = np.zeros(shape=(2*repnum,)) xvar = np.zeros(shape=(2*repnum,)) cnt = -1 testwt = np.mod(tspan,t)-0.5*t; last = testwt[1] for loop in range(2,siz): if (last < 0)and(testwt[loop] > 0): D. D. Nolte 10

12 cnt = cnt+1 del1 = -testwt[loop-1]/(testwt[loop] - testwt[loop-1]) px[cnt] = (y2[loop]-y2[loop-1])*del1 + y2[loop-1] xvar[cnt] = (y1[loop]-y1[loop-1])*del1 + y1[loop-1] last = testwt[loop] last = testwt[loop] plt.figure(3) lines = plt.plot(xvar,px,'ko',ms=1) plt.show() if model_case == 1: plt.savefig(pendulum) plt.savefig(doublewell) Fig. Driven damped pendulum D. D. Nolte 11

13 Fig. Driven damped double-well potential. D. D. Nolte 12

14 Hamilton4D.py #!/usr/bin/env python3 # -*- coding: utf-8 -*- Created on Wed Apr 18 06:03:32 nolte import numpy as np import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D from scipy import integrate from matplotlib import pyplot as plt from matplotlib import cm import time import os plt.close('all') # model_case 1 = Heiles # model_case 2 = Crescent model_case = int(input('enter the Model Case (1-3)')) if model_case == 1: E = 1 # Heiles: 1, Crescent: 0.05, 1 epse = # 3411 def flow_deriv(x_y_z_w,tspan): x, y, z, w = x_y_z_w a = z b = w c = -x - epse*(2*x*y) d = -y - epse*(x**2 - y**2) return[a,b,c,d] E =.05 # Heiles: 1, Crescent: 0.05, 1 epse = 1 # 3411 def flow_deriv(x_y_z_w,tspan): x, y, z, w = x_y_z_w a = z b = w c = -(epse*(y-2*x**2)*(-4*x) + x) D. D. Nolte 13

15 d = -(y-epse*2*x**2) return[a,b,c,d] prms = np.sqrt(e) pmax = np.sqrt(2*e) # Potential Function if model_case == 1: V = np.zeros(shape=(100,100)) for xloop in range(100): x = *xloop/100 for yloop in range(100): y = *yloop/100 V[yloop,xloop] = 0.5*x** *y**2 + epse*(x**2*y *y**3) V = np.zeros(shape=(100,100)) for xloop in range(100): x = *xloop/100 for yloop in range(100): y = *yloop/100 V[yloop,xloop] = 0.5*x** *y**2 + epse*(2*x**4-2*x**2*y) fig = plt.figure(1) contr = plt.contourf(v,100, cmap=cm.coolwarm, vmin = 0, vmax = 10) fig.colorbar(contr, shrink=0.5, aspect=5) fig = plt.show() repnum = 250 mulnum = 64/repnum np.random.seed(1) for reploop in range(repnum): px1 = 2*(np.random.random((1))-0.499)*pmax py1 = np.sign(np.random.random((1))-0.499)*np.real(np.sqrt(2*(e-px1**2/2))) xp1 = 0 yp1 = 0 x_y_z_w0 = [xp1, yp1, px1, py1] tspan = np.linspace(1,1000,10000) x_t = integrate.odeint(flow_deriv, x_y_z_w0, tspan) siztmp = np.shape(x_t) siz = siztmp[0] D. D. Nolte 14

16 if reploop % 50 == 0: plt.figure(2) lines = plt.plot(x_t[:,0],x_t[:,1]) plt.setp(lines, linewidth=0.5) plt.show() time.sleep(0.1) #os.system("pause") y1 = x_t[:,0] y2 = x_t[:,1] y3 = x_t[:,2] y4 = x_t[:,3] py = np.zeros(shape=(2*repnum,)) yvar = np.zeros(shape=(2*repnum,)) cnt = -1 last = y1[1] for loop in range(2,siz): if (last < 0)and(y1[loop] > 0): cnt = cnt+1 del1 = -y1[loop-1]/(y1[loop] - y1[loop-1]) py[cnt] = y4[loop-1] + del1*(y4[loop]-y4[loop-1]) yvar[cnt] = y2[loop-1] + del1*(y2[loop]-y2[loop-1]) last = y1[loop] last = y1[loop] plt.figure(3) lines = plt.plot(yvar,py,'o',ms=1) plt.show() if model_case == 1: plt.savefig('heiles') plt.savefig('crescent') D. D. Nolte 15

17 Fig. Heiles Figl Crescent D. D. Nolte 16

18 Perturbed.py #!/usr/bin/env python3 # -*- coding: utf-8 -*- Created on Wed May 21 06:03:32 nolte from IPython import get_ipython get_ipython().magic('reset -f') import numpy as np import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D from scipy import integrate from matplotlib import pyplot as plt from matplotlib import cm import time import os plt.close('all') # model_case 1 = Pendulum # model_case 2 = Double Well print(' ') print('dampeddriven.py') print('case: 1 = Pendulum 2 = Double Well') model_case = int(input('enter the Model Case (1-2)')) if model_case == 1: F = 0.02 # 0.6 delt = 0.0 # 0.1 w = 3/4 # 0.7 k = 2 phase = 0 px1 = xp1 = 0 w1 = 0 def flow_deriv(x_y_z,tspan): x, y, z = x_y_z a = y b = F*np.cos(-w*tspan + k*x + phase) - np.sin(x) - delt*y c = w D. D. Nolte 17

19 return[a,b,c] alpha = -1 # -1 beta = 1 # 1 F = # 0.3 delta = 0.0 # 0.15 w = 1 k = 1 phase = np.random.random() px1 = 0 xp1 = 0 w1 = 0 def flow_deriv(x_y_z,tspan): x, y, z = x_y_z a = y b = F*np.cos(-w*tspan + k*x + phase) - alpha*x - beta*x**3 - delta*y c = w return[a,b,c] T = 2*np.pi/w x_y_z = [xp1, px1, w1] # Settle-down Solve for the trajectories t = np.linspace(0, 2000, 20000) x_t1 = integrate.odeint(flow_deriv, x_y_z, t) x0 = x_t1[9999,0:3] tlim = # number of points nt = #stop time tspan = np.linspace(1,nt,tlim) x_t = integrate.odeint(flow_deriv, x0, tspan, rtol=1e-8) siztmp = np.shape(x_t) siz = siztmp[0] y1 = np.zeros(shape=(2*tlim,)) y2 = np.zeros(shape=(2*tlim,)) if model_case == 1: y1tmp = np.mod(x_t[:,0]-np.pi,2*np.pi)-np.pi y2tmp = x_t[:,1] y1[0:tlim] = y1tmp y1[tlim:2*tlim] = y1tmp+2*np.pi y2[0:tlim] = y2tmp D. D. Nolte 18

20 y2[tlim:2*tlim] = y2tmp y3 = x_t[:,2] Energy = 0.5*x_t[:,1]** np.cos(x_t[:,0]) y1 = x_t[:,0] y2 = x_t[:,1] y3 = x_t[:,2] Energy = 0.5*x_t[:,1]** *alpha*x_t[:,0]** *beta*x_t[:,0]**4 plt.figure(1) lines = plt.plot(y1,y2,'ko',ms=1) plt.setp(lines, linewidth=0.5) plt.title('phase Portrait') plt.show() plt.figure(2) lines = plt.plot(y3[0:3000],y2[0:3000]) plt.setp(lines, linewidth=0.5) plt.title('velocity') plt.show() plt.figure(3) lines = plt.plot(y3[0:3000],energy[0:3000]) plt.setp(lines, linewidth=0.5) plt.title('energy') plt.show() # First-Return Map repnum = 5000 px = np.zeros(shape=(2*repnum,)) xvartmp = np.zeros(shape=(2*repnum,)) cnt = -1 testwt = np.mod(tspan,t)-0.5*t; last = testwt[0] for loop in range(1,siz): if (last < 0)and(testwt[loop] > 0): cnt = cnt+1 del1 = -testwt[loop-1]/(testwt[loop] - testwt[loop-1]) px[cnt] = (y2[loop]-y2[loop-1])*del1 + y2[loop-1] xvartmp[cnt] = (x_t[loop,0]-x_t[loop-1,0])*del1 + x_t[loop-1,0] #xvar[cnt] = y1[loop] D. D. Nolte 19

21 last = testwt[loop] last = testwt[loop] # Plot First Return Map if model_case == 1: xvar = np.mod(xvartmp-np.pi,2*np.pi)-np.pi pxx = np.zeros(shape=(2*cnt,)) xvarr = np.zeros(shape=(2*cnt,)) xvarr[0:cnt] = xvar[0:cnt] xvarr[cnt:2*cnt] = xvar[0:cnt]+2*np.pi pxx[0:cnt] = px[0:cnt] pxx[cnt:2*cnt] = px[0:cnt] plt.figure(4) lines = plt.plot(xvarr,pxx,'ko',ms=0.5) plt.xlim(xmin=0, xmax=2*np.pi) plt.title('first Return Map') plt.show() plt.savefig('ppendulum') xvar = xvartmp plt.figure(4) lines = plt.plot(xvar,px,'ko',ms=0.5) #mpl.pyplot.xlim(xmin=0, xmax=2*np.pi) plt.title('first Return Map') plt.show() plt.savefig('pdoublewell') D. D. Nolte 20

22 Fig. Perturbed pendulum Fig. Perturbed double well D. D. Nolte 21

23 Lozi.py #!/usr/bin/env python3 # -*- coding: utf-8 -*- Created on Wed May 2 16:17:27 nolte import numpy as np from scipy import integrate from matplotlib import pyplot as plt #plt.close('all') B = -1 C = 0.5 np.random.seed(2) plt.figure(1) for eloop in range(0,100): xlast = np.random.normal(0,1,1) ylast = np.random.normal(0,1,1) xnew = np.zeros(shape=(500,)) ynew = np.zeros(shape=(500,)) for loop in range(0,500): xnew[loop] = 1 + ylast - C*abs(xlast) ynew[loop] = B*xlast xlast = xnew[loop] ylast = ynew[loop] plt.plot(np.real(xnew),np.real(ynew),'o',ms=1) plt.xlim(xmin=-1.25,xmax=2) plt.ylim(ymin=-2,ymax=1.25) plt.savefig('lozi') D. D. Nolte 22

24 Fig. Lozi map. B = -1, C = 0.5. D. D. Nolte 23

25 StandMap.py #!/usr/bin/env python3 # -*- coding: utf-8 -*- Created on Wed May 2 16:17:27 nolte import numpy as np from scipy import integrate from matplotlib import pyplot as plt plt.close('all') eps = 0.97 np.random.seed(2) plt.figure(1) for eloop in range(0,200): rlast = 2*np.pi*(0.5-np.random.random()) thlast = 2*np.pi*np.random.random() # rold = 2.0*pi*(0.5-rand); # thetold = 2.0*pi*rand; rplot = np.zeros(shape=(200,)) thetaplot = np.zeros(shape=(200,)) for loop in range(0,200): rnew = rlast + eps*np.sin(thlast) thnew = np.mod(thlast+rnew,2*np.pi) thetaplot[loop] = np.mod(thnew-np.pi,2*np.pi) - np.pi if rnew > np.pi: rtemp = rnew-2*np.pi elif rnew < -np.pi: rtemp = 2*np.pi + rnew rtemp = rnew rplot[loop] = np.mod(0.5 + (rtemp + np.pi)/2/np.pi,1) D. D. Nolte 24

26 rlast = rnew thlast = thnew plt.plot(np.real(thetaplot),np.real(rplot),'o',ms=1) # plt.xlim(xmin=-np.pi,xmax=np.pi) # plt.ylim(ymin=-np.pi,ymax=2*np.pi) plt.savefig('standmap') Fig. Standard map. ε = 0.97 D. D. Nolte 25

27 WebMap.py #!/usr/bin/env python3 # -*- coding: utf-8 -*- Created on Wed May 2 16:17:27 nolte import numpy as np from scipy import integrate from matplotlib import pyplot as plt plt.close('all') phi = (1+np.sqrt(5))/2 K = 1-phi # (0.618, 4) (0.618,5) (0.618,7) (1.2, 4) q = 4 # 4, 5, 6, 7 alpha = 2*np.pi/q np.random.seed(2) plt.figure(1) for eloop in range(0,1000): xlast = 50*np.random.random() ylast = 50*np.random.random() xnew = np.zeros(shape=(300,)) ynew = np.zeros(shape=(300,)) for loop in range(0,300): xnew[loop] = (xlast + K*np.sin(ylast))*np.cos(alpha) + ylast*np.sin(alpha) ynew[loop] = -(xlast + K*np.sin(ylast))*np.sin(alpha) + ylast*np.cos(alpha) xlast = xnew[loop] ylast = ynew[loop] plt.plot(np.real(xnew),np.real(ynew),'o',ms=1) plt.xlim(xmin=-60,xmax=60) plt.ylim(ymin=-60,ymax=60) plt.title('webmap') plt.savefig('webmap') D. D. Nolte 26

28 Fig. Web map. K = φ 1. q = 4 D. D. Nolte 27