def check_exact():
y0 = 3.2
yT = 10.5
T = 10
a = -2
problem = create_simple_CN_problem(y0, yT, T, a, c=20)
problem.c = 20
#problem = non_lin_problem(y0,yT,T,a,2,func=lambda x : 0*x)
N = 100 * T
ue, t, _ = problem.simple_problem_exact_solution(N)
res = problem.solve(N, Lbfgs_options={'jtol': 1e-10})
res2 = problem.PPCLBFGSsolve(N,
80, [10000, 200000],
tol_list=[1e-5, 1e-8, 1e-8],
options={'jtol': 1e-5})[-1]
val1 = problem.Functional(ue, N)
val2 = problem.Functional(res.x, N)
print val1, val2, val1 - val2
print res.counter(), res2.counter()
u0 = res.x[-1]
y = problem.ODE_solver(res.x, N)
u_test = lambda x: u0 * np.exp(a * (T - t))
print max(abs(res.x[1:-1] - ue[1:-1])), np.sqrt(
trapz((res.x[1:-1] - ue[1:-1])**2,
t[1:-1])), max(abs(res2.x[1:N] - ue[1:-1]))
plt.plot(t, ue + 20, '--')
plt.plot(t, res.x)
plt.plot(t, res2.x[:N + 1])
#plt.plot(t,u_test(t),'.')
plt.show()
def main():
y0 = 3.2
yT=11.5
a = -0.097
T=100
problem = create_simple_CN_problem(y0,yT,T,a)
N = 1000
ue,t,_ = problem.simple_problem_exact_solution(N)
seq_res = problem.solve(N,Lbfgs_options={'jtol':1e-7})
MU = [0.01*N,0.1*N,N,10*N,100*N,100000*N,10000000*N]
Ls = seq_res.counter()[0]+seq_res.counter()[1]
m = 16
table = {'err':[],'L':[],'S':[],'err2':[],'L2':[],'S2':[]}
for i in range(len(MU)):
res1 = problem.PPCLBFGSsolve(N,m,[MU[i]],tol_list=[1e-5,1e-5],options = {'jtol':1e-5})
#res2 = problem.penalty_solve(N,m,[MU[i]],Lbfgs_options={'jtol':1e-5})
res2=res1
err1=np.sqrt(trapz((res1.x[1:N]-ue[1:-1])**2,t[1:-1]))/np.sqrt(trapz(ue**2,t))
err2=np.sqrt(trapz((res2.x[1:N]-ue[1:-1])**2,t[1:-1]))/np.sqrt(trapz(ue**2,t))
L1 = res1.counter()[1]+res1.counter()[0]
L2 = res2.counter()[1]+res2.counter()[0]
table['err'].append(err1)
table['err2'].append(err2)
table['L'].append(L1)
table['L2'].append(L2)
table['S'].append(m*Ls/float(L1))
table['S2'].append(m*Ls/float(L2))
print Ls, np.sqrt(trapz((seq_res.x[1:-1]-ue[1:-1])**2,t[1:-1]))/np.sqrt(trapz(ue**2,t))
data = pd.DataFrame(table,index=MU)
res3 = problem.PPCLBFGSsolve(N,m,[100*N,1000000*N,10000000*N],tol_list=[1e-5,1e-5])
print res3[-1].counter(),res3[0].counter(),np.sqrt(trapz((res3[-1].x[1:N]-ue[1:-1])**2,t[1:-1]))/np.sqrt(trapz(ue**2,t))
#data.to_latex('report/draft/parareal/mu_test2.tex')
print data
m = 16
res2mu = problem.PPCLBFGSsolve(N,m,[100*N,100000*N],tol_list=[1e-5,1e-5],options = {'jtol':1e-5})
mu2err1 = table['err'][4]
mu2err2 = np.sqrt(trapz((res2mu[-1].x[1:N]-ue[1:-1])**2,t[1:-1]))/np.sqrt(trapz(ue**2,t))
Lmu2 = res2mu[-1].counter()[0]+res2mu[-1].counter()[1]
print mu2err1,mu2err2,Lmu2,table['L'][4],m*Ls/float(Lmu2)
def main():
y0 = 3.2
yT = 11.5
T = 1
a = -3.9
problem = create_simple_CN_problem(y0, yT, T, a, c=0)
general_taylor_test(problem)
euler_con(y0, yT, T, a)
crank_con(y0, yT, T, a)
jump_difference(problem)
return 0
def test_con():
problem = create_simple_CN_problem(1, 1, 1, 1)
N = [100, 1000, 10000, 100000, 1000000]
u = lambda x: x
for n in N:
t = np.linspace(0, 1, n + 1)
grad = problem.solve(n, Lbfgs_options={'jtol': 1e-7})
print grad.counter()
plt.plot(t, grad.x)
plt.show()
return 0
def test():
y0 = 3.2
yT = 10.5
T = 5
a = -2
problem = create_simple_CN_problem(y0, yT, T, a, c=0)
N = 1000
m = 10
res3 = problem.solve(N, algorithm='my_steepest_decent')
print res3.counter()
"""
res2 = problem.penalty_solve(N,m,[1,10],algorithm='my_steepest_decent')[-1]
print res2.counter()
plt.plot(res2.x[:N+1])
plt.plot(res3.x)
plt.show()
"""
pc = None
pc = problem.PC_maker4(N, m)
res = problem.alternate_direction_penalty_solve(N, m, [1, 10, 100], ppc=pc)
x = res[2]
print res[0].counter(), res[1].counter()
plt.plot(x[:N + 1])
plt.plot(res3.x, '--r')
plt.show()
plt.plot(x[N + 1:])
plt.show()
return
def crank_con(y0, yT, T, a):
problem = create_simple_CN_problem(y0, yT, T, a, c=0)
gen_con(problem, name='CN_exact_convergence')
def jump_difference(problem=None):
import sys
y0 = 3.2
yT = 11.5
T = 1
a = -3.9
p = 2
if problem==None:
problem = create_simple_CN_problem(y0,yT,T,a)#non_lin_problem(y0,yT,T,a,p,func=lambda x : 0*x)#10*np.sin(np.pi*2*x))
try:
N = int(sys.argv[1])
m = int(sys.argv[2])
except:
N = 100
m = 2
part_start,_,_,_ = v_comm_numbers(N+1,m)
dt = float(T)/N
ls = {"ftol": 1e-3, "gtol": 1-1e-1, "xtol": 0.1, "start_stp": 1}
seq_opt = {'jtol':0,'maxiter':50,'mem_lim':50,"line_search_options":ls}
opt = {'jtol':0,'scale_factor':1,'mem_lim':50,'scale_hessian':False,'maxiter':90,
"line_search_options":ls}
res = problem.solve(N,Lbfgs_options=seq_opt)
u_exact,t,_ = problem.simple_problem_exact_solution(N)
u_exact2,t2,_ = problem.simple_problem_exact_solution(10*N)
table = {'J(vmu)-J(v)/J(v)':[],'||v_mu-v||':[],'jumps':[],'Jmu(v_mu)-Jmu(v)/Jmu(v)':[],'A rate':['--'],
'C rate':['--'],'B rate':['--'] }
table2 = {'J(vmu)-J(v)/J(v)':[],'||v_mu-v||':[],'jumps':[],'Jmu(v_mu)-Jmu(v)/Jmu(v)':[] }
table3 = {'J(vmu)-J(v)/J(v)':[],'||v_mu-v||':[],'jumps':[],'Jmu(v_mu)-Jmu(v)/Jmu(v)':[] }
table4 = {'J(vmu)-J(v)/J(v)':[],'||v_mu-v||':[],'jumps':[],'Jmu(v_mu)-Jmu(v)/Jmu(v)':[] }
t = np.linspace(0,T,N+1)
y_seq = problem.ODE_solver(res['control'].array(),N)
#plt.figure()
#plt.plot(t,y_seq,'r--')
end_crit = lambda mu0,dt,m : mu0<(1./dt)**2
#mu_updater1=lambda mu,dt,m,last_iter : mu + 10000
"""
res2 = problem.PPCLBFGSadaptive_solve(N,m,options=opt,
scale=True,mu_stop_codition=end_crit,
mu_updater=mu_updater1,mu0=N)
"""
mu_list = [N,2*N,5*N,10*N,50*N,70*N,200*N,2000*N,3000*N,4000*N,5000*N,6000*N,10000*N,100000*N,200000*N,1000000*N,1e11,1e12,1e13,1e14,1e16]
mu_list = [1e1,1e2,1e3,1e4,2e4,5e4,7e4,1e5,2e5,3e5,4e5,5e5,6e5,7e5,8e5,9e5,1e6,1.5e6,2e6,3e6,5e6,7e6,9e6,1e7,1.5e7,2e7,5e7,8e7,1e8,5e8,7e8,1e9,2e9,3e9,7e9,1e10,2e10,3e10,5e10,7e10,1e11,2e11,3e11,4e11,6e11,9e11,1e12,2e12,5e12,8e12,1e13,2e13,5e13,1e14,1e15,1e16]
#mu_list = [1e5,5e5,1e6,1e7]
res2 = problem.PPCLBFGSsolve(N,m,mu_list,options=opt)
#res2 = problem.penalty_solve(N,m,mu_list,Lbfgs_options=opt)
MORE = True
seq_norm = l2_norm(res['control'].array(),t)
exact_error = l2_diff_norm(u_exact[1:-1],res.x[1:-1],t[1:-1])/seq_norm
y_end=problem.ODE_solver(res['control'].array(),N)
val1=problem.J(res['control'].array(),y_end[-1],yT,T)
if MORE:
res22 = problem.PPCLBFGSsolve(N,10,mu_list,options=opt)
res23 = problem.PPCLBFGSsolve(10*N,2,mu_list,options=opt)
res24 = problem.PPCLBFGSsolve(10*N,7,mu_list,options=opt)
res21 = problem.solve(10*N,Lbfgs_options=seq_opt)
t2 = np.linspace(0,T,10*N+1)
seq_norm2 = l2_norm(res21['control'].array(),t2)
y_seq2 = problem.ODE_solver(res21['control'].array(),10*N)
val21=problem.J(res21['control'].array(),y_seq2[-1],yT,T)
exact_error2 = l2_diff_norm(u_exact2[1:-1],res21.x[1:-1],t2[1:-1])/seq_norm2
Y_SEQ = [y_seq,y_seq2,y_seq2]
SEQN = [seq_norm,seq_norm2,seq_norm2]
SEQ_RES = [res,res21,res21]
VAL = [val1,val21,val21]
RES = [res22,res23,res24]
TAB = [table2,table3,table4]
TIME = [t,t2,t2]
N2 = [N,10*N,10*N]
jump_diff2 = [[],[],[]]
state_diff2 = [[],[],[]]
all_jump_diff21 = [[],[],[]]
all_jump_diff22 = [[],[],[]]
all_state_diff21 = [[],[],[]]
all_state_diff22 = [[],[],[]]
#res2 = problem.penalty_solve(N,m,mu_list,Lbfgs_options=opt)
#res3 = problem.penalty_solve(N,m,[1,100,1000,10000])
all_jump_diff = []
all_jump_diff2 = []
all_state_diff = []
all_state_diff2 = []
s = 0
y2_end,Y = problem.ODE_penalty_solver(res2[-1].x,N,m)
val2= problem.J(res2[-1].x[:N+1],y2_end[-1][-1],yT,T)
print val1,val2
print val1-val2
val3 = problem.Functional(res['control'].array(),N)
val4 = problem.Functional(res2[-1].x[:N+1],N)
print val3,val4
print val3-val4
for i in range(len(res2)):
y,Y = problem.ODE_penalty_solver(res2[i].x,N,m)
jump_diff = []
state_diff = []
for j in range(len(y)-1):
state_diff.append(abs(y[j+1][0]-y_seq[part_start[j+1]]))
#state_diff.append(max(abs(Y-y_seq)))
jump_diff.append(abs(y[j][-1]-y[j+1][0]))
all_jump_diff.append((max(jump_diff),min((jump_diff))))
all_jump_diff2.append(jump_diff)
all_state_diff.append((max(state_diff),min(state_diff)))
all_state_diff2.append(state_diff)
#plt.plot(t,Y)
err = l2_diff_norm(res['control'].array(),res2[i].x[:N+1],t)/seq_norm
#res2[i].J_func(res2[i].x)
f_val1 = problem.Penalty_Functional(res2[i].x,N,m,mu_list[i])#res2[i].J_func(res2[i].x)
f_val2 = problem.Functional(res2[i].x[:N+1],N)
print res2[i].niter,(f_val2-val1)/val1,all_jump_diff[i][0],err
table['J(vmu)-J(v)/J(v)'].append((f_val2-val1)/val1)
table['||v_mu-v||'].append(err)
table['jumps'].append(all_jump_diff[i][0])
table['Jmu(v_mu)-Jmu(v)/Jmu(v)'].append((f_val1-val1)/val1)
if i>0:
table['A rate'].append(np.log(table['J(vmu)-J(v)/J(v)'][i]/table['J(vmu)-J(v)/J(v)'][i-1])/np.log(mu_list[i]/mu_list[i-1]))
table['B rate'].append(np.log(table['Jmu(v_mu)-Jmu(v)/Jmu(v)'][i]/table['Jmu(v_mu)-Jmu(v)/Jmu(v)'][i-1])/np.log(mu_list[i]/mu_list[i-1]))
table['C rate'].append(np.log(table['||v_mu-v||'][i]/table['||v_mu-v||'][i-1])/np.log(mu_list[i]/mu_list[i-1]))
s+=res2[i].niter
if MORE:
for l in range(len(RES)):
y,Y = problem.ODE_penalty_solver(RES[l][i].x,N2[l],m)
for j in range(len(y)-1):
state_diff2[l].append(abs(y[j+1][0]-Y_SEQ[l][part_start[j+1]]))
#state_diff.append(max(abs(Y-y_seq)))
jump_diff2[l].append(abs(y[j][-1]-y[j+1][0]))
all_jump_diff21[l].append((max(jump_diff),min((jump_diff))))
all_jump_diff22[l].append(jump_diff)
all_state_diff21[l].append((max(state_diff),min(state_diff)))
all_state_diff22[l].append(state_diff)
#plt.plot(t,Y)
err = l2_diff_norm(SEQ_RES[l]['control'].array(),RES[l][i].x[:N2[l]+1],TIME[l])/SEQN[l]
#RES[l][i].J_func(RES[l][i].x)
f_val1 = RES[l][i].J_func(RES[l][i].x)
f_val2 = problem.Functional(RES[l][i].x[:N2[l]+1],N2[l])
print RES[l][i].niter,(f_val2-val1)/val1,all_jump_diff21[l][i][0],err
TAB[l]['J(vmu)-J(v)/J(v)'].append((f_val2-VAL[l])/VAL[l])
TAB[l]['||v_mu-v||'].append(err)
TAB[l]['jumps'].append(all_jump_diff21[l][i][0])
TAB[l]['Jmu(v_mu)-Jmu(v)/Jmu(v)'].append((f_val1-VAL[l])/VAL[l])
print all_jump_diff
print
#print all_state_diff2
print float(T)/N
print val1
pd.set_option('display.float_format', '{:.6e}'.format)
data = pd.DataFrame(table,index = mu_list)
data2 = data.ix[:,['J(vmu)-J(v)/J(v)','||v_mu-v||','A rate','C rate']].head(12)
#data.to_latex('report/whyNotEqual/jump_func_Neql'+str(N)+'meql'+str(m)+'_2.tex')
print data
#data2.to_latex('report/whyNotEqual/consistency_rate.tex')
"""
plt.show()
plt.plot(t,res['control'].array(),'r--')
for i in range(len(res2)):
plt.plot(t,res2[i].x[:N+1])
plt.show()
"""
"""
for i in range(len(res3)):
err=l2_diff_norm(res['control'].array(),res3[i]['control'].array()[:N+1],t)
print err
print s,res['iteration']
"""
"""
for i in range(len(all_jump_diff2)):
plt.figure()
plt.plot(np.array(all_jump_diff2[i]))
"""
#plt.show()
Legg = ['A','B','C','D']
if MORE:
#plt.locator_params(axis='x', nticks=8)
Legg = [r'$\Delta \hat J$',r'$\Delta \hat J_{\mu}$',r'$\Delta v$',r'$\Delta y$',r'$||v-v_e||$']
plt.figure(figsize=(12,6))
ax1 = plt.subplot(121)
ax1.loglog(np.array(mu_list),np.array(table['J(vmu)-J(v)/J(v)']),'--')
ax1.loglog(np.array(mu_list),-np.array(table['Jmu(v_mu)-Jmu(v)/Jmu(v)']),'rx-')
ax1.loglog(np.array(mu_list),np.array(table['||v_mu-v||']),'c-')
ax1.loglog(np.array(mu_list),np.array(table['jumps']),'g.')
help_var11 = np.zeros(len(mu_list)) + exact_error
ax1.loglog(np.array(mu_list),help_var11)
ax1.set_xlabel(r"$\mu$",fontsize=15)
ax1.xaxis.set_ticks(10**np.arange(2,17,2))
ax1.set_title(r'$N=2$')
table = TAB[0]
ax2 = plt.subplot(122)
ax2.loglog(np.array(mu_list),np.array(table['J(vmu)-J(v)/J(v)']),'--')
ax2.loglog(np.array(mu_list),-np.array(table['Jmu(v_mu)-Jmu(v)/Jmu(v)']),'rx-')
ax2.loglog(np.array(mu_list),np.array(table['||v_mu-v||']),'c-')
ax2.loglog(np.array(mu_list),np.array(table['jumps']),'g.')
ax2.set_xlabel(r"$\mu$",fontsize=15)
ax2.loglog(np.array(mu_list),help_var11)
ax2.xaxis.set_ticks(10**np.arange(2,17,2))
ax2.legend(Legg)
ax2.set_title(r'$N=10$')
table = TAB[1]
#plt.savefig('report/draft/draft2/consistency1.png')
plt.figure(figsize=(6,6))
plt.loglog(np.array(mu_list),np.array(table['J(vmu)-J(v)/J(v)']),'--')
plt.loglog(np.array(mu_list),-np.array(table['Jmu(v_mu)-Jmu(v)/Jmu(v)']),'rx-')
plt.loglog(np.array(mu_list),np.array(table['||v_mu-v||']),'c-')
plt.loglog(np.array(mu_list),np.array(table['jumps']),'g.')
help_var11 = np.zeros(len(mu_list)) + exact_error2
plt.loglog(np.array(mu_list),help_var11)
plt.xlabel(r"$\mu$",fontsize=20)
plt.xticks(10**np.arange(2,17,2))
plt.title(r'$N=2$')
plt.legend(Legg)
plt.savefig('presentation/con2.png')
#plt.show()
plt.figure(figsize=(12,6))
ax3 = plt.subplot(121)
ax3.loglog(np.array(mu_list),np.array(table['J(vmu)-J(v)/J(v)']),'--')
ax3.loglog(np.array(mu_list),-np.array(table['Jmu(v_mu)-Jmu(v)/Jmu(v)']),'rx-')
ax3.loglog(np.array(mu_list),np.array(table['||v_mu-v||']),'c-')
ax3.loglog(np.array(mu_list),np.array(table['jumps']),'g.')
ax3.set_xlabel(r"$\mu$",fontsize=15)
help_var21 = np.zeros(len(mu_list)) + exact_error2
ax3.loglog(np.array(mu_list),help_var21)
ax3.set_title(r'$N=2$')
ax3.xaxis.set_ticks(10**np.arange(2,17,2))
table = TAB[2]
ax4 = plt.subplot(122)
ax4.loglog(np.array(mu_list),np.array(table['J(vmu)-J(v)/J(v)']),'--')
ax4.loglog(np.array(mu_list),-np.array(table['Jmu(v_mu)-Jmu(v)/Jmu(v)']),'rx-')
ax4.loglog(np.array(mu_list),np.array(table['||v_mu-v||']),'c-')
ax4.loglog(np.array(mu_list),np.array(table['jumps']),'g.')
ax4.set_xlabel(r"$\mu$",fontsize=15)
ax4.loglog(np.array(mu_list),help_var21)
ax4.xaxis.set_ticks(10**np.arange(2,17,2))
ax4.legend(Legg)
ax4.set_title(r'$N=7$')
#plt.savefig('report/draft/draft2/consistency2.png')
plt.show()
else:
plt.figure(figsize=(6,8))
#plt = plt.subplot(211)
plt.loglog(np.array(mu_list),np.array(table['J(vmu)-J(v)/J(v)']),'--')
plt.loglog(np.array(mu_list),np.array(table['jumps']),'.')
plt.loglog(np.array(mu_list),-np.array(table['Jmu(v_mu)-Jmu(v)/Jmu(v)']),'x-')
plt.loglog(np.array(mu_list),np.array(table['||v_mu-v||']))
plt.loglog()
plt.legend(Legg)
plt.plot(np.array(mu_list),4e-5/(np.array(mu_list)**2))
plt.plot(np.array(mu_list),1./(np.array(mu_list)))
plt.show()