def test_adjoint():
solver = kode.Solver()
primal_step = solver.primal_step
adjoint_step = solver.adjoint_step
s0 = solver.s0
state_dim = solver.state_dim
u0 = primal_step(solver.u_init,s0,100)
epsi = 1.e-4
y1 = array([0.0,1.,0.,0.])
y0_ana = adjoint_step(y1,u0,s0,y1)
y0_fd = zeros(state_dim)
v0 = zeros(state_dim)
for i in arange(state_dim):
v0 = zeros(state_dim)
v0[i] = 1.0
u0pert = u0 + epsi*v0
u1pert = primal_step(u0pert,s0,1)
obj2 = u0pert[1] + u1pert[1]
u0pert = u0 - epsi*v0
u1pert = primal_step(u0pert,s0,1)
obj1 = u0pert[1] + u1pert[1]
y0_fd[i] = (obj2 - obj1)/(2.0*epsi)
assert(norm(y0_fd-y0_ana) < 1.e-8)
def test_DfDs():
solver = kode.Solver()
state_dim = solver.state_dim
param_dim = solver.param_dim
u0 = solver.u_init
dt = solver.dt
primal_step = solver.primal_step
DfDs = solver.DfDs
s0 = solver.s0
n_epsi = 10
param_dim = s0.size
epsi = logspace(-n_epsi,-1.0,n_epsi)
dfds_fd = zeros((n_epsi,param_dim,state_dim))
dfds_ana = zeros((param_dim,state_dim))
for i in range(param_dim):
for k in range(n_epsi):
splus = copy(s0)
splus[i] += epsi[k]
sminus = copy(s0)
sminus[i] -= epsi[k]
dfds_fd[k,i] = (primal_step(u0,splus,1) -
primal_step(u0,sminus,1))/(2.0*epsi[k])/dt
err_dfds = zeros(n_epsi)
dfds_ana = DfDs(u0,s0)
for k in range(n_epsi):
err_dfds[k] = norm(dfds_fd[k]-dfds_ana)
figure()
loglog(epsi,err_dfds, 'o-')
savefig('err_dfds')
assert(min(err_dfds) < 1.e-8)
def test_jacobian():
solver = kode.Solver()
state_dim = solver.state_dim
T = solver.T
dt = solver.dt
primal_step = solver.primal_step
tangent_step = solver.tangent_step
gradfs = solver.gradfs
s0 = solver.s0
u0 = rand(state_dim)
u0[3] *= T
epsi = 1.e-4
Jacu = zeros((state_dim,state_dim))
Jacu[:,0] = ((primal_step(u0 + epsi*array([1.0,0.0,0.0,0.0]),s0,1) -
primal_step(u0 - epsi*array([1.0,0.0,0.0,0.0]),s0,1))/
(2.0*epsi))
Jacu[:,1] = ((primal_step(u0 + epsi*array([0.0,1.0,0.0,0.0]),s0,1) -
primal_step(u0 - epsi*array([0.0,1.0,0.0,0.0]),s0,1))/
(2.0*epsi))
Jacu[:,2] = ((primal_step(u0 + epsi*array([0.0,0.0,1.0,0.0]),s0,1) -
primal_step(u0 - epsi*array([0.0,0.0,1.0,0.0]),s0,1))/
(2.0*epsi))
Jacu[:,3] = ((primal_step(u0 + epsi*array([0.0,0.0,0.0,1.0]),s0,1) -
primal_step(u0 - epsi*array([0.0,0.0,0.0,1.0]),s0,1))/
(2.0*epsi))
dFds1 = (primal_step(u0,s0 + epsi*array([1.0,0.0]),1)-primal_step(u0,s0
- epsi*array([1.0,0.0]),1))/(2.0*epsi)
dFds2 = (primal_step(u0,s0 + epsi*array([0.0,1.0]),1)-primal_step(u0,s0
- epsi*array([0.0,1.0]),1))/(2.0*epsi)
Jacana = dt*gradfs(u0,s0) + eye(state_dim,state_dim)
assert(norm(Jacu-Jacana) < 1.e-5)
v0 = rand(4)
v0_fd = dot(Jacu,v0)
v0_hand = tangent_step(v0,u0,s0,zeros(2))
assert(norm(v0_fd - v0_hand) < 1.e-6)
v1_fd = v0_fd + dFds1
v1_hand = tangent_step(v0,u0,s0,[1.0,0.0])
assert(norm(v1_fd - v1_hand) < 1.e-6)
v2_fd = v0_fd + dFds2
v2_hand = tangent_step(v0,u0,s0,[0.0,1.0])
assert(norm(v2_fd - v2_hand) < 1.e-6)
def visualize_tangent_stereographic(u, v, c1="black"):
EPS = 1E-8
u_plus, u_minus = u + v * EPS, u - v * EPS
stereographic_projection = kode.Solver().stereographic_projection
stereo_real, stereo_imag = stereographic_projection(u.T)
stereo_real_plus, stereo_imag_plus = stereographic_projection(u_plus.T)
stereo_real_minus, stereo_imag_minus = stereographic_projection(u_minus.T)
stereo_real_plus = extrapolate(stereo_real, stereo_real_plus, 1E6)
stereo_real_minus = extrapolate(stereo_real, stereo_real_minus, 1E6)
stereo_imag_plus = extrapolate(stereo_imag, stereo_imag_plus, 1E6)
stereo_imag_minus = extrapolate(stereo_imag, stereo_imag_minus, 1E6)
plot([stereo_real_plus, stereo_real_minus],
[stereo_imag_plus, stereo_imag_minus], color=c1, ms=10)
def test_tangent():
n_testpoints = 1
n_epsi = 8
solver = kode.Solver()
s0 = solver.s0
state_dim = solver.state_dim
param_dim = s0.size
n_poincare = solver.n_poincare
u0 = rand(n_testpoints,state_dim)
epsi = logspace(-n_epsi,-1.0,n_epsi)
vu_fd = zeros((n_epsi,n_testpoints,state_dim))
vs_fd = zeros((n_epsi,n_testpoints,state_dim))
vu_ana = zeros((n_testpoints,state_dim))
vs_ana = zeros((n_testpoints,state_dim))
v0 = rand(state_dim)
ds0 = array([1.,1.])
primal_step = solver.primal_step
tangent_step = solver.tangent_step
for i in arange(n_testpoints):
u0[i] = primal_step(solver.u_init,s0,int(200*\
rand()))
for k in arange(n_epsi):
vu_fd[k,i] = (primal_step(u0[i] + epsi[k]*v0,
s0,1)-\
primal_step(u0[i] - epsi[k]*v0,s0,1)\
)/(2.0*epsi[k])
vs_fd[k,i] = (primal_step(u0[i],s0 + epsi[k]*ds0,1) -
primal_step(u0[i],s0 - epsi[k]*ds0,1)) \
/(2.0*epsi[k])
#vu_ana[i] = solver.dt*dot(solver.gradfs(u0[i],s0),v0)
vu_ana[i] = tangent_step(v0,u0[i],s0,zeros(param_dim))
vs_ana[i] = tangent_step(zeros(state_dim),u0[i],s0,ds0)
erru = zeros(n_epsi)
errs = zeros(n_epsi)
for k in arange(n_epsi):
erru[k] = norm(vu_ana-vu_fd[k])
errs[k] = norm(vs_ana-vs_fd[k])
figure()
loglog(epsi,erru, 'o-')
savefig('erru')
figure()
loglog(epsi,errs, 'o-')
savefig('errs')
assert(min(erru) < 1.e-5)
assert(min(errs) < 1.e-5)
def test_tangentadjoint():
solver = kode.Solver()
tangent_step = solver.tangent_step
adjoint_step = solver.adjoint_step
state_dim = solver.state_dim
param_dim = solver.param_dim
s0 = solver.s0
T = solver.T
u = solver.primal_step(solver.u_init,\
s0,int(3000*rand()))
y1 = rand(state_dim)
v0 = rand(state_dim)
v1 = tangent_step(v0,u,s0,zeros(param_dim))
y0 = adjoint_step(y1,u,s0,zeros(state_dim))
assert(abs(dot(v1,y1)-dot(v0,y0)) < 1.e-10)
def visualize_poincare_primal():
solver_ode = kode.Solver()
u_init = solver_ode.u_init
n_map = solver_ode.n_poincare
n_steps = 500*n_map
s0 = solver_ode.s0
sens_object = flow_sens.Sensitivity(solver_ode,n_steps)
solve_primal = sens_object.solve_primal
u_ode = solve_primal(solver_ode,\
u_init,n_steps,s0)
u_ode = u_ode[::n_map]
stereo_real, stereo_imag = \
solver_ode.stereographic_projection(u_ode.T)
figure()
plot(stereo_real, stereo_imag, '.')
savefig('st_proj_poincare_attractor.png')
def visualize_unstable_direction():
solver_ode = kode.Solver()
u_init = solver_ode.u_init
v_init = rand(u_init.size)
v_init /= norm(v_init)
n_map = solver_ode.n_poincare
n_steps = 500*n_map
s0 = solver_ode.s0
sens_object = flow_sens.Sensitivity(solver_ode,n_steps)
solve_primal = sens_object.solve_primal
u_ode = solve_primal(solver_ode,\
u_init,n_steps,s0)
solve_unstable_direction = sens_object.\
solve_unstable_direction
v = solve_unstable_direction(solver_ode,\
u_ode, v_init,n_steps,\
s0)
visualize_tangent_2D(u_ode[::n_map],\
v[::n_map])
def test_divGradfs():
n_samples = 100
n_epsi = 10
epsi = logspace(-n_epsi,-1,n_epsi)
solver = kode.Solver()
state_dim = solver.state_dim
s0 = solver.s0
gradfs = solver.gradfs
primal_step = solver.primal_step
divGradfs = solver.divGradfs
u0 = zeros((n_samples,state_dim))
dgf_hand = zeros((n_samples,state_dim))
dgf_fd = zeros((n_epsi,n_samples,state_dim))
tmp_matrix = zeros((state_dim,state_dim))
for i in range(n_samples):
u0[i] = primal_step(solver.u_init,\
s0,int(10*n_samples*rand()))
dgf_hand[i] = divGradfs(u0[i],s0)
for k in range(n_epsi):
for j in range(state_dim):
v0 = zeros(state_dim)
v0[j] = 1.0
tmp_matrix = (gradfs(u0[i]+epsi[k]*v0,s0) -
gradfs(u0[i]-epsi[k]*v0,s0))/(2.0*epsi[k])
dgf_fd[k,i] += tmp_matrix[j]
err = zeros(n_epsi)
for k in range(n_epsi):
err[k] = norm(dgf_hand-dgf_fd[k])
figure()
loglog(epsi,err,'o-')
ylabel(r'$|| \nabla\cdot(\nabla f_s) -\nabla\cdot(\nabla f_s)_\epsilon^{\rm FD}||$')
xlabel(r'$\epsilon$')
savefig('err_divGradfs')
assert(min(err)<1.e-8)
def test_step_primal():
holes = array([1./sqrt(2.),0,1./sqrt(2.0),\
-1./sqrt(2.),0,1./sqrt(2.0), \
1./sqrt(2.),0,-1./sqrt(2.0), \
-1./sqrt(2.),0,-1./sqrt(2.0)])
holes = holes.reshape(4,3)
solver_ode = kode.Solver()
flag = 1
u_init = solver_ode.u_init
T = solver_ode.T
dt = solver_ode.dt
fac = 100
n_steps = fac*int(T/dt)
s0 = solver_ode.s0
primal_step = solver_ode.primal_step
sens_object = flow_sens.Sensitivity(solver_ode,n_steps)
u_init = primal_step(u_init,s0,sens_object.n_runup)
solve_primal = sens_object.solve_primal
u = solve_primal(solver_ode,u_init,n_steps,s0)
for i in range(1,n_steps):
if(dot((u[i,:3]-u[i-1,:3])/dt,u[i-1,:3])>1.e-8):
break
assert(i==n_steps-1)
u = u[::int(T/dt)]
epsi = 1.e-1
for i in range(1,fac):
if(not(flag)):
break
for j in range(holes.shape[0]):
if(norm(u[i,:3]-holes[j])<epsi):
flag = 0
if(norm(u[i,:3])>1.0 + epsi):
flag = 0
assert(i==fac-1)
import sys
sys.path.insert(0, '../examples/')
import kuznetsov_poincare as kmap
import kuznetsov as kode
import map_sens as map_sens
import flow_sens as flow_sens
from time import clock
if __name__ == "__main__":
solver_ode = kode.Solver()
solver_map = kmap.Solver()
n_map = solver_ode.n_poincare
n_steps_map = 50
n_steps = n_map * n_steps_map
plykin = flow_sens.Sensitivity(solver_ode, n_steps)
t0 = clock()
u_ode = plykin.solve_primal(solver_ode,solver_ode.u_init,\
n_steps,
solver_ode.s0)
t1 = clock()
print('{:<60s}{:>16.10f}'.format(\
"Time to solve primal: ",\
t1-t0))
t2 = clock()
plykin.precompute_sources(solver_ode, u_ode)
t3 = clock()
print('{:<60s}{:>16.10f}'.format(\
"Time for flow precomputations: ",\
t3-t2))
poincare_plykin = map_sens.Sensitivity(solver_map, n_steps_map)
