def sir(initial, Usir, MO, NM, scov_bg, scov_model, H, y, tobs, pinv_obs, F, dt): #Sizes Nsir = len(Usir[:, 0, 0]) N = len(Usir[0, :, 0]) J = len(Usir[0, 0, :]) - 1 weights = np.zeros(Nsir) eff = np.zeros(NM) mcn = 0 for t in range(J): for m in range(Nsir): if (t == 0): #random = np.random.randn(N) #force = np.dot(scov_bg,random) #Usir[m,:,t] = initial + force Usir[m, :, t] = initial[m, :] random = np.random.randn(N) force = np.dot(scov_model, random) Usir[m, :, t + 1] = Mnl.lorenz96(Usir[m, :, t], force, dt) if (t + 1 == tobs[mcn]): print tobs[mcn] sum = 0 for m in range(Nsir): diff = y[:, mcn] - np.dot(H, Usir[m, :, tobs[mcn]]) hulp = np.dot(pinv_obs, diff) weights[m] = 1. / 2 * np.dot(np.transpose(diff), hulp) sum = sum + weights[m] * weights[m] mcn = mcn + 1 Usir[:, :, t + 1], eff = resample(Usir[:, :, t + 1], weights) return Usir, eff
def sir(initial,Usir,MO,NM,scov_bg,scov_model,H,y,tobs,pinv_obs,F,dt): #Sizes Nsir = len(Usir[:,0,0]) N = len(Usir[0,:,0]) J = len(Usir[0,0,:])-1 weights = np.zeros(Nsir) eff = np.zeros(NM) mcn = 0 for t in range(J): for m in range(Nsir): if (t == 0): #random = np.random.randn(N) #force = np.dot(scov_bg,random) #Usir[m,:,t] = initial + force Usir[m,:,t] = initial[m,:] random = np.random.randn(N) force = np.dot(scov_model,random) Usir[m,:,t+1] = Mnl.lorenz96(Usir[m,:,t],force,dt) if (t+1 == tobs[mcn]): print tobs[mcn] sum = 0 for m in range(Nsir): diff = y[:,mcn]-np.dot(H,Usir[m,:,tobs[mcn]]) hulp = np.dot(pinv_obs,diff) weights[m] = 1./2*np.dot(np.transpose(diff),hulp) sum = sum + weights[m]*weights[m] mcn = mcn+1 Usir[:,:,t+1], eff = resample(Usir[:,:,t+1],weights) return Usir, eff
# Creating the truth run xhulp = np.zeros([N,2000]) xtrue = np.zeros([N,J+1]) force = np.zeros(N) #spin up F=8.17 xhulp[:,0] = F pert = 0.05 pospert = np.ceil(N/2.0)-1 xhulp[pospert,0] = F+pert spinup=1999 for j in range(spinup): force = np.zeros(N) xhulp[:,j+1] = mod.lorenz96(xhulp[:,j],force,dt) xtrue[:,0] = xhulp[:,spinup] for j in range(J): force = np.zeros(N) xtrue[:,j+1] = mod.lorenz96(xtrue[:,j],force,dt) print 'truth created' print xtrue.shape # Creating the observations #if (observations == 1): NM = J/ns # Select an observation operator
dx0 = np.random.rand(D)-0.5 #Changed to randn! It runned for both 10 and 20 variables ##dx0 = np.random.rand(D) #print 'dx0', dx0 x = np.zeros([D,N+1]) x[:,0] = xtrue[:,0] + dx0 #x[:,0] = xtrue[:,0] print 'x[:,0]', x[:,0] nTD = N + (M-1)*nTau #t = np.zeros([1,nTD]) datat = np.dot(dt,list(xrange(N+1))) for j in range(N): # try nTD force = np.zeros(D) #force = np.random.rand(D)-0.5 # For only rand for 10 or 20 variables it overflows at time 2!!!! xtrue[:,j+1] = mod.lorenz96(xtrue[:,j],force,dt) xtrue[:,1] = xtrue[:,0] # try to sort python problem for 0 beginning index x[:,1] = x[:,0] # try to sort python problem for 0 beginning index print 'truth created' y = np.zeros([L,N+1]) ### No noise for y (ok for seed=37) #y = np.dot(h,xtrue) ### Good noise values for y (for seed=37) ### (noises are centralized in zero) #y = np.dot(h,xtrue) + np.random.uniform(0,1.2680e-04,N+1)-6.34e-05 #y = np.dot(h,xtrue) + np.random.uniform(0,1.2680e-04,N+1)-9.34e-05 #(out of zero mean!) #y = np.dot(h,xtrue) + np.random.uniform(0,1.8680e-04,N+1)-9.34e-05 ### Noise that runs perfect until time step 1500 (for seed=37)
######xhulp[:,0] = F ## CHANGE HERE IF WE WANT TO VARY FORCING PARAMETERS AS TABLE 1????##### ######pert = 0.05 ######pospert = np.ceil(N/2.0)-1 ######xhulp[pospert,0] = F+pert ######spinup=1999 ######for j in range(spinup): ###### force = np.zeros(N) ###### xhulp[:,j+1] = mod.lorenz96(xhulp[:,j],force,dt) ### this line returns 1 column for the 20 variables at each loop #### ######xtrue[:,0] = xhulp[:,spinup] xtrue[:, 0] = np.random.rand(N) print 'xtrue', xtrue for j in range(J): #random = np.random.randn(N) #force = np.dot(scov_model,random) force = np.zeros(N) xtrue[:, j + 1] = mod.lorenz96(xtrue[:, j], force, dt) print 'truth created' ######print xtrue.shape # Adding 21st state variable ######forc = np.zeros([1,J+1]) ######print forc.shape ######forc[:,:] = F ######print forc ######xtrue = np.append(xtrue,forc, axis=0) #####print 'New xtrue', xtrue.shape #print xtrue[0,1] # Creating the observations #if (observations == 1): #####NM = J*tau #number of measurement times # (Increasing DM is equivalent to increasing the number of measurements!) NM = J / ns
max_pinv_rank = Nens ################### Creating truth ################################### xtrue = np.zeros([D,N+1]) #***xtrue[:,0] = np.random.rand(D) #print 'xtrue[:,0]', xtrue[:,0] ####### Start by spinning model in ########### xtest = np.zeros([D,1001]) xtest[:,0]=np.random.rand(D) #print '1st rand', xtest[:,0] for j in range(1000): force = np.zeros(D) xtest[:,j+1]=mod.lorenz96(xtest[:,j],force,dt) xtrue[:,0] = xtest[:,1000] print 'xtrue[:,0]', xtrue[:,0] ## Plot xtrue to understand initial conditions influences ## #plt.figure(1).suptitle('xtrue for seed='+str(r)+'') #plt.plot(xtrue[:,0],'g-') #plt.show() dx0 = np.random.rand(D)-0.5 #print 'dx0', dx0 ##dx0 = np.random.rand(D) x = np.zeros([D,N+1]) x[:,0] = xtrue[:,0] + dx0
#spin up F=8.17 ######xhulp[:,0] = F ######pert = 0.05 ######pospert = np.ceil(N/2.0)-1 ######xhulp[pospert,0] = F+pert ######spinup=1999 ######for j in range(spinup): ###### force = np.zeros(N) ###### xhulp[:,j+1] = mod.lorenz96(xhulp[:,j],force,dt) ######xtrue[:,0] = xhulp[:,spinup] xtrue[:,0] = np.random.rand(N) for j in range(J): force = np.zeros(N) xtrue[:,j+1] = mod.lorenz96(xtrue[:,j],force,dt) print 'truth created' print xtrue.shape # Creating the observations #if (observations == 1): NM = J/ns # Select an observation operator if obsgrid == 1: # Option 1: Observe all observed_vars = range(N) elif obsgrid == 2: # Option 2: Observe every other variable observed_vars = range(0,N,2)
#spin up F = 8.17 ######xhulp[:,0] = F ######pert = 0.05 ######pospert = np.ceil(N/2.0)-1 ######xhulp[pospert,0] = F+pert ######spinup=1999 ######for j in range(spinup): ###### force = np.zeros(N) ###### xhulp[:,j+1] = mod.lorenz96(xhulp[:,j],force,dt) ######xtrue[:,0] = xhulp[:,spinup] xtrue[:, 0] = np.random.rand(N) for j in range(J): force = np.zeros(N) xtrue[:, j + 1] = mod.lorenz96(xtrue[:, j], force, dt) print 'truth created' print xtrue.shape # Creating the observations #if (observations == 1): NM = J / ns # Select an observation operator if obsgrid == 1: # Option 1: Observe all observed_vars = range(N) elif obsgrid == 2: # Option 2: Observe every other variable observed_vars = range(0, N, 2) elif obsgrid == 3:
max_pinv_rank = M ################### Creating truth ################################### xtrue = np.zeros([D,N+1]) #xtrue[:,0] = np.random.rand(D) # so uniform on [0,1] #print 'xtrue[:,0]', xtrue[:,0] ##dx0 = np.random.rand(D) # Start by spinning model in. xtest = np.zeros([D,1001]) xtest[:,0]=np.random.rand(D) for j in range(1000): force = np.zeros(D) xtest[:,j+1]=mod.lorenz96(xtest[:,j],force,dt) xtrue[:,0] = xtest[:,1000] #x[:,0] = xtrue[:,0] x=np.zeros([D,N+1]) dx0 = np.random.rand(D)-0.5 x[:,0] = xtrue[:,0] + dx0 #nTD = N + (M-1)*nTau # total time steps needed #t = np.zeros([1,nTD]) datat = np.dot(dt,list(xrange(N+1))) for j in range(N): # try nTD force = np.zeros(D) #force = np.random.rand(D)-0.5 # For only rand for 10 or 20 variables it overflows at time 2!!!! xtrue[:,j+1] = mod.lorenz96(xtrue[:,j],force,dt)
def Pmatrix(x,Jac0): #################### Initial settings ################################ N = 10000 Obs = 100 dt = 0.01 #original value=0.01 D = 20 F=8.17 M = 40 ##################### Seeding for 20 variables####################### r=37 #for x[:,0] = xtrue[:,0] np.random.seed(r) #################### Constructing h (obs operator) ################## observed_vars = range(1) L = len(observed_vars) h = np.zeros([L,D]) for i in range(L): h[i,observed_vars[i]] = 1.0 xx = np.zeros([D,1]) Jac = np.zeros([D,D]) for i in range(D): Jac[i,i] = 1. #Jac0 = np.copy(Jac) run = 1 ################### Main loop ########################################## for n in range(1,run+1): xx = x #Jac = Jac0 P = {} P['00'] = Jac0 for s in range(1,M): idxs = s for m in range(1,M): ii = idxs - m iid = idxs + 1 id1 = str(0)+str(idxs) id2 = str(0)+str(idxs-1) id21 = str(m-1)+str(idxs) id3 = str(iid-1)+str(ii) id4 = str(iid-2)+str(ii) id5 = str(iid-1)+str(iid-1) id6 = str(iid-2)+str(iid-2) if ii >= 0: Jac3 = P[id4] # Calculating the first row of Ps if m == 1: Jac2 = P[id2] ######################### Jac2 = np.transpose(Jac2) ######################### # Calculating all elements in the upper part of the diagonal# Jacsize = D**2 Jacv2 = Jac2.reshape(Jacsize) Jacvec2 = Jacv2.reshape(Jacsize,1) Jac2 = mod.rk4_J3(Jacvec2,D,xx,dt) Jac2 = np.transpose(Jac2) P[id1] = Jac2 if m > 1: # Calculating all elements in the upper part of the diagonal# Jacsize = D**2 Jacv2 = Jac2.reshape(Jacsize) Jacvec2 = Jacv2.reshape(Jacsize,1) Jac2 = mod.rk4_J3(Jacvec2,D,xx,dt) P[id21] = Jac2 # Calculating all elements in the lower part of the diagonal# Jacv3 = Jac3.reshape(Jacsize) Jacvec3 = Jacv3.reshape(Jacsize,1) Jac3 = mod.rk4_J3(Jacvec3,D,xx,dt) P[id3] = Jac3 # Calculating all elements in the diagonal# Jacv4 = Jac2.reshape(Jacsize) Jacvec4 = Jacv4.reshape(Jacsize,1) Jac4 = mod.rk4_J3(Jacvec4,D,xx,dt) P[id5] = Jac4 if m == (M-1): random = np.zeros(D) xx = mod.lorenz96(xx,random,dt) return P
pinv_tol = (np.finfo(float).eps) max_pinv_rank = Nens ################### Creating truth ################################### xtrue = np.zeros([D, N + 1]) #***xtrue[:,0] = np.random.rand(D) #print 'xtrue[:,0]', xtrue[:,0] ####### Start by spinning model in ########### xtest = np.zeros([D, 1001]) xtest[:, 0] = np.random.rand(D) #print '1st rand', xtest[:,0] for j in range(1000): force = np.zeros(D) xtest[:, j + 1] = mod.lorenz96(xtest[:, j], force, dt) xtrue[:, 0] = xtest[:, 1000] print 'xtrue[:,0]', xtrue[:, 0] ## Plot xtrue to understand initial conditions influences ## #plt.figure(1).suptitle('xtrue for seed='+str(r)+'') #plt.plot(xtrue[:,0],'g-') #plt.show() dx0 = np.random.rand(D) - 0.5 #print 'dx0', dx0 ##dx0 = np.random.rand(D) x = np.zeros([D, N + 1]) x[:, 0] = xtrue[:, 0] + dx0
######xhulp[:,0] = F ######pert = 0.05 ######pospert = np.ceil(N/2.0)-1 ######xhulp[pospert,0] = F+pert ######spinup=1999 ######for j in range(spinup): ###### force = np.zeros(N) ###### xhulp[:,j+1] = mod.lorenz96(xhulp[:,j],force,dt) ######xtrue[:,0] = xhulp[:,spinup] xtrue[:,0] = np.random.rand(N) #####print 'xtrue', xtrue for j in range(J): #random = np.random.randn(N) #force = np.dot(scov_model,random) force = np.zeros(N) xtrue[:,j+1] = mod.lorenz96(xtrue[:,j],force,dt) print 'truth created' print xtrue.shape # Creating the observations #if (observations == 1): NM = J/ns # Select an observation operator if obsgrid == 1: # Option 1: Observe all observed_vars = range(N) elif obsgrid == 2: # Option 2: Observe every other variable observed_vars = range(0,N,2)
xtrue = np.zeros([D,N+1]) #xtrue[:,0] = np.random.rand(D) #Changed to randn! It runned for both 10 and 20 variables ####### Start by spinning model in ########### xtest = np.zeros([D,1001]) xtest[:,0]=np.random.rand(D) #print '1st rand', xtest[:,0] for j in range(1000): force = np.zeros(D) ##force = Q*np.ones(D) ########## ADDING Q NOISE ############## ###force = np.random.normal(0,Q,D) ########## ADDING NORMAL NOISE WITH VARIANCE=Q ############## ####force = np.random.normal(0,Q) ########## ADDING NORMAL NOISE WITH VARIANCE=Q ############## xtest[:,j+1]=mod.lorenz96(xtest[:,j],force,dt) xtrue[:,0] = xtest[:,1000] print 'xtrue[:,0]', xtrue[:,0] dx0 = np.random.rand(D)-0.5 #Changed to randn! It runned for both 10 and 20 variables ##dx0 = np.random.rand(D) x = np.zeros([D,N+1]) z = np.zeros([D,N+1]) w = np.zeros([D,N+1]) k = np.zeros([D,N+1]) x[:,0] = xtrue[:,0] #+ dx0 z[:,0] = x[:,0]
xtrue = np.zeros([N, J + 1]) #xtrueII = np.zeros([N,J+1]) force = np.zeros(N) #spin up F = 8.17 xhulp[:, 0] = F ##### CHANGE HERE IF WE WANT TO VARY FORCING PARAMETERS AS TABLE 1????####### pert = 0.05 pospert = np.ceil(N / 2.0) - 1 xhulp[pospert, 0] = F + pert spinup = 1999 for j in range(spinup): force = np.zeros(N) xhulp[:, j + 1] = mod.lorenz96( xhulp[:, j], force, dt ) ####### this line returns 1 column for the 20 variables at each loop ######## #print 'xhulp', xhulp xtrue[:, 0] = xhulp[:, spinup] #xtrueII[:,0] = xtrue[:,0] for j in range(J): #random = np.random.randn(N) #force = np.dot(scov_model,random) #xtrueII[:,j+1] = force force = np.zeros(N) xtrue[:, j + 1] = mod.lorenz96( xtrue[:, j], force, dt ) ####### THE WHOLE TRUE MATRIX IS CREATED #################################### #print 'xtrue', xtrue print 'truth created' print xtrue.shape
def ewpf(initial, Uew, MO, NM, scov_bg, scov_model, cov_model, pinv_model, H, y, tobs, cov_obs, pinv_obs, nudgeFac, F, dt): #Sizes New = len(Uew[:, 0, 0]) N = len(Uew[0, :, 0]) J = len(Uew[0, 0, :]) - 1 ns = J / NM #Factors retain = 5 epsilon = 0.001 / New gamma_u = 1e-2 gamma_n = 1e-5 #Arrays weights = np.zeros(New) # extraWeight = np.zeros(New) #additional weights due to mixture density wpp = np.zeros(New) #storing nudge weights c = np.zeros(New) #storing maximum weights eff = np.zeros(NM) #Matrices needed HQHT = np.dot(H, np.dot(cov_model, np.transpose(H))) pinv_QN = np.linalg.pinv(HQHT + cov_obs) kgain = np.dot(cov_model, np.dot(np.transpose(H), pinv_QN)) mcn = 0 for t in range(J): for m in range(New): if (t == 0): #random = np.random.randn(N) #force = np.dot(scov_bg,random) #Uew[m,:,t] = initial + force Uew[m, :, t] = initial[m, :] if (t + 1 == tobs[mcn]): force = 0. Uew[m, :, t + 1] = Mnl.lorenz96(Uew[m, :, t], force, dt) else: #nudge tau = (t - mcn * ns) / float(ns) diff = y[:, mcn] - np.dot(H, Uew[m, :, t]) help1 = np.dot(pinv_obs, diff) help2 = np.dot(np.transpose(H), help1) help3 = np.dot(cov_model, help2) nudge = nudgeFac * tau * help3 #random error random = np.random.randn(N) force = np.dot(scov_model, random) nudge = force + nudge Uew[m, :, t + 1] = Mnl.lorenz96(Uew[m, :, t], nudge, dt) weight = np.dot(nudge, np.dot(pinv_model, nudge)) - np.dot( force, np.dot(pinv_model, force)) wpp[m] = wpp[m] + 0.5 * weight #print wpp if (t + 1 == tobs[mcn]): print tobs[mcn] #Calculate weights for best fit to observations for each member for m in range(New): diff = y[:, mcn] - np.dot(H, Uew[m, :, tobs[mcn]]) c[m] = wpp[m] + 0.5 * np.dot(diff, np.dot(pinv_QN, diff)) ccsort = np.sort(c) #print ccsort cc = ccsort[(retain * New / 10) - 1] oldU = np.copy(Uew[:, :, tobs[mcn]]) for m in range(New): if (c[m] <= cc): diff = y[:, mcn] - np.dot(H, Uew[m, :, tobs[mcn]]) help = np.dot(H, np.dot(kgain, diff)) aaa = 0.5 * np.dot(diff, np.dot(pinv_obs, help)) bbb = 0.5 * np.dot(diff, np.dot(pinv_obs, diff)) - cc + wpp[m] alpha = 1 - np.sqrt(1. - bbb / aaa + 0.00000001) Uew[m, :, tobs[mcn]] = Uew[m, :, tobs[mcn]] + alpha * np.dot( kgain, diff) #Add random error from mixture density u = np.random.rand(1) factor = epsilon / (1 - epsilon) * (2 / np.pi)**(N / 2) * ( gamma_u**N / gamma_n) if (u < epsilon): random = gamma_n * np.random.randn(N) #print 'random', random addRandom = np.dot(scov_model, random) extraWeight[m] = 1. / (factor * np.exp( -(1. / (2 * gamma_n**2)) * np.dot(random, random))) else: random = 2 * gamma_u**(1. / 2) * (np.random.rand(N) - 0.5) #print 'random', random addRandom = np.dot(scov_model, random) extraWeight[m] = 1. / (1 + factor * np.exp( -(1. / (2 * gamma_n**2)) * np.dot(random, random))) Uew[m, :, tobs[mcn]] = Uew[m, :, tobs[mcn]] + addRandom #Calculate final weights for m in range(New): diff = y[:, mcn] - np.dot(H, Uew[m, :, tobs[mcn]]) xtest = Uew[m, :, tobs[mcn]] - oldU[m, :] help = 0.5 * np.dot(diff, np.dot( pinv_obs, diff)) + 0.5 * np.dot(xtest, np.dot(pinv_model, xtest)) weights[m] = help + wpp[m] - extraWeight[m] print weights mcn = mcn + 1 Uew[:, :, t + 1], eff = resample(Uew[:, :, t + 1], weights) print 'Uew', Uew wpp[:] = 0. return Uew, eff
def ewpf(initial,Uew,MO,NM,scov_bg,scov_model,cov_model,pinv_model,H,y,tobs,cov_obs,pinv_obs,nudgeFac,F,dt): #Sizes New = len(Uew[:,0,0]) N = len(Uew[0,:,0]) J = len(Uew[0,0,:])-1 ns = J/NM #Factors retain = 5 epsilon = 0.001/New gamma_u = 1e-2 gamma_n = 1e-5 #Arrays weights = np.zeros(New) # extraWeight = np.zeros(New) #additional weights due to mixture density wpp = np.zeros(New) #storing nudge weights c = np.zeros(New) #storing maximum weights eff = np.zeros(NM) #Matrices needed HQHT = np.dot(H,np.dot(cov_model,np.transpose(H))) pinv_QN = np.linalg.pinv(HQHT + cov_obs) kgain = np.dot(cov_model,np.dot(np.transpose(H),pinv_QN)) mcn = 0 for t in range(J): for m in range(New): if (t == 0): #random = np.random.randn(N) #force = np.dot(scov_bg,random) #Uew[m,:,t] = initial + force Uew[m,:,t] = initial[m,:] if(t+1 == tobs[mcn]): force = 0. Uew[m,:,t+1] = Mnl.lorenz96(Uew[m,:,t],force,dt) else: #nudge tau = (t-mcn*ns)/float(ns) diff = y[:,mcn]-np.dot(H,Uew[m,:,t]) help1 = np.dot(pinv_obs,diff) help2 = np.dot(np.transpose(H),help1) help3 = np.dot(cov_model,help2) nudge = nudgeFac*tau*help3 #random error random = np.random.randn(N) force = np.dot(scov_model,random) nudge = force + nudge Uew[m,:,t+1] = Mnl.lorenz96(Uew[m,:,t],nudge,dt) weight = np.dot(nudge,np.dot(pinv_model,nudge))-np.dot(force,np.dot(pinv_model,force)) wpp[m] = wpp[m] + 0.5*weight #print wpp if (t+1 == tobs[mcn]): print tobs[mcn] #Calculate weights for best fit to observations for each member for m in range(New): diff = y[:,mcn]-np.dot(H,Uew[m,:,tobs[mcn]]) c[m] = wpp[m] + 0.5*np.dot(diff,np.dot(pinv_QN,diff)) ccsort = np.sort(c) #print ccsort cc = ccsort[(retain*New/10)-1] oldU = np.copy(Uew[:,:,tobs[mcn]]) for m in range(New): if (c[m] <= cc): diff = y[:,mcn]-np.dot(H,Uew[m,:,tobs[mcn]]) help = np.dot(H,np.dot(kgain,diff)) aaa = 0.5 * np.dot(diff,np.dot(pinv_obs,help)) bbb = 0.5 * np.dot(diff,np.dot(pinv_obs,diff))- cc + wpp[m] alpha = 1 - np.sqrt(1. - bbb/aaa + 0.00000001) Uew[m,:,tobs[mcn]] = Uew[m,:,tobs[mcn]] + alpha*np.dot(kgain,diff) #Add random error from mixture density u=np.random.rand(1) factor = epsilon/(1-epsilon)*(2/np.pi)**(N/2)*(gamma_u**N/gamma_n) if (u<epsilon): random = gamma_n*np.random.randn(N) #print 'random', random addRandom = np.dot(scov_model,random) extraWeight[m] = 1./(factor*np.exp(-(1./(2*gamma_n**2))*np.dot(random,random))) else: random=2*gamma_u**(1./2)*(np.random.rand(N)-0.5) #print 'random', random addRandom = np.dot(scov_model,random) extraWeight[m] = 1./(1+factor*np.exp(-(1./(2*gamma_n**2))*np.dot(random,random))) Uew[m,:,tobs[mcn]] = Uew[m,:,tobs[mcn]] + addRandom #Calculate final weights for m in range(New): diff = y[:,mcn]-np.dot(H,Uew[m,:,tobs[mcn]]) xtest = Uew[m,:,tobs[mcn]]-oldU[m,:] help = 0.5*np.dot(diff,np.dot(pinv_obs,diff)) + 0.5*np.dot(xtest,np.dot(pinv_model,xtest)) weights[m] = help + wpp[m] - extraWeight[m] print weights mcn = mcn+1 Uew[:,:,t+1], eff = resample(Uew[:,:,t+1],weights) print 'Uew', Uew wpp[:]=0. return Uew, eff
dx0 = np.random.rand( D) - 0.5 #Changed to randn! It runned for both 10 and 20 variables ##dx0 = np.random.rand(D) x = np.zeros([D, N + 1]) x[:, 0] = xtrue[:, 0] + dx0 #x[:,0] = xtrue[:,0] print 'x[:,0]', x[:, 0] nTD = N + (M - 1) * nTau #t = np.zeros([1,nTD]) datat = np.dot(dt, list(xrange(N + 1))) for j in range(N): # try nTD force = np.zeros(D) #force = np.random.rand(D)-0.5 # For only rand for 10 or 20 variables it overflows at time 2!!!! xtrue[:, j + 1] = mod.lorenz96(xtrue[:, j], force, dt) xtrue[:, 1] = xtrue[:, 0] # try to sort python problem for 0 beginning index x[:, 1] = x[:, 0] # try to sort python problem for 0 beginning index print 'truth created' ################### Creating the obs ################################## y = np.zeros([L, N + 1]) ### No noise for y y = np.dot(h, xtrue) #y = np.dot(h,xtrue) + np.random.uniform(0,0.02,N+1)-0.01 #which gives the variance of 0.0001 #R = np.zeros([M, M]) #for i in range(M): # R[i,i] = 0.0001
######xhulp[:,0] = F ## CHANGE HERE IF WE WANT TO VARY FORCING PARAMETERS AS TABLE 1????##### ######pert = 0.05 ######pospert = np.ceil(N/2.0)-1 ######xhulp[pospert,0] = F+pert ######spinup=1999 ######for j in range(spinup): ###### force = np.zeros(N) ###### xhulp[:,j+1] = mod.lorenz96(xhulp[:,j],force,dt) ### this line returns 1 column for the 20 variables at each loop #### ######xtrue[:,0] = xhulp[:,spinup] xtrue[:,0] = np.random.rand(N) print 'xtrue', xtrue for j in range(J): #random = np.random.randn(N) #force = np.dot(scov_model,random) force = np.zeros(N) xtrue[:,j+1] = mod.lorenz96(xtrue[:,j],force,dt) print 'truth created' ######print xtrue.shape # Adding 21st state variable ######forc = np.zeros([1,J+1]) ######print forc.shape ######forc[:,:] = F ######print forc ######xtrue = np.append(xtrue,forc, axis=0) #####print 'New xtrue', xtrue.shape #print xtrue[0,1] # Creating the observations #if (observations == 1): #####NM = J*tau #number of measurement times # (Increasing DM is equivalent to increasing the number of measurements!)
######### Setting tolerance and maximum for rank calculations ######## pinv_tol = (np.finfo(float).eps ) #*max((M,D))#apparently same results as only 2.2204e-16 max_pinv_rank = 2 * L ################### Creating truth ################################### xtrue = np.zeros([D, N + 1]) #***xtrue[:,0] = np.random.rand(D) #Changed to randn! It runned for both 10 and 20 variables #print 'xtrue[:,0]', xtrue[:,0] ####### Start by spinning model in ########### xtest = np.zeros([D, 1001]) xtest[:, 0] = np.random.rand(D) for j in range(1000): force = np.zeros(D) xtest[:, j + 1] = mod.lorenz96(xtest[:, j], force, dt) xtrue[:, 0] = xtest[:, 1000] print 'xtrue[:,0]', xtrue[:, 0] ###### Plot xtrue to understand initial conditions influences #### #plt.figure(1).suptitle('xtrue for seed='+str(r)+'') #plt.plot(xtrue[:,0],'g-') #plt.show() dx0 = np.random.rand( D) - 0.5 #Changed to randn! It runned for both 10 and 20 variables ##dx0 = np.random.rand(D) x = np.zeros([D, N + 1]) x[:, 0] = xtrue[:, 0] + dx0
# Creating the truth run xhulp = np.zeros([N, 2000]) xtrue = np.zeros([N, J + 1]) force = np.zeros(N) #spin up F = 8.17 xhulp[:, 0] = F pert = 0.05 pospert = np.ceil(N / 2.0) - 1 xhulp[pospert, 0] = F + pert spinup = 1999 for j in range(spinup): force = np.zeros(N) xhulp[:, j + 1] = mod.lorenz96(xhulp[:, j], force, dt) xtrue[:, 0] = xhulp[:, spinup] for j in range(J): force = np.zeros(N) xtrue[:, j + 1] = mod.lorenz96(xtrue[:, j], force, dt) print 'truth created' print xtrue.shape # Creating the observations #if (observations == 1): NM = J / ns # Select an observation operator if obsgrid == 1:
# Creating the truth run xhulp = np.zeros([N,2000]) xtrue = np.zeros([N,J+1]) force = np.zeros(N) #spin up F=8.17 xhulp[:,0] = F ## CHANGE HERE IF WE WANT TO VARY FORCING PARAMETERS AS TABLE 1????#### pert = 0.05 pospert = np.ceil(N/2.0)-1 xhulp[pospert,0] = F+pert spinup=1999 for j in range(spinup): force = np.zeros(N) xhulp[:,j+1] = mod.lorenz96(xhulp[:,j],force,dt) ### this line returns 1 column for the 20 variables at each loop #### xtrue[:,0] = xhulp[:,spinup] #print 'xtrue', xtrue for j in range(J): #random = np.random.randn(N) #force = np.dot(scov_model,random) force = np.zeros(N) xtrue[:,j+1] = mod.lorenz96(xtrue[:,j],force,dt) print 'truth created' print xtrue.shape # Adding 21st state variable forc = np.zeros([1,J+1]) print forc.shape forc[:,:] = F print forc xtrue = np.append(xtrue,forc, axis=0)
D) - 0.5 #Changed to randn! It runned for both 10 and 20 variables ##dx0 = np.random.rand(D) #print 'dx0', dx0 x = np.zeros([D, N + 1]) x[:, 0] = xtrue[:, 0] + dx0 #x[:,0] = xtrue[:,0] print 'x[:,0]', x[:, 0] nTD = N + (M - 1) * nTau #t = np.zeros([1,nTD]) datat = np.dot(dt, list(xrange(N + 1))) for j in range(N): # try nTD force = np.zeros(D) #force = np.random.rand(D)-0.5 # For only rand for 10 or 20 variables it overflows at time 2!!!! xtrue[:, j + 1] = mod.lorenz96(xtrue[:, j], force, dt) xtrue[:, 1] = xtrue[:, 0] # try to sort python problem for 0 beginning index x[:, 1] = x[:, 0] # try to sort python problem for 0 beginning index print 'truth created' y = np.zeros([L, N + 1]) ### No noise for y (ok for seed=37) #y = np.dot(h,xtrue) ### Good noise values for y (for seed=37) ### (noises are centralized in zero) #y = np.dot(h,xtrue) + np.random.uniform(0,1.2680e-04,N+1)-6.34e-05 #y = np.dot(h,xtrue) + np.random.uniform(0,1.2680e-04,N+1)-9.34e-05 #(out of zero mean!) #y = np.dot(h,xtrue) + np.random.uniform(0,1.8680e-04,N+1)-9.34e-05 ### Noise that runs perfect until time step 1500 (for seed=37)
x = np.zeros([D,fc+1]) x[:,0] = xtrue[:,0] + dx0 #x[:,0] = xtrue[:,0] print 'x[:,0]', x[:,0] nTD = N + (M-1)*nTau #t = np.zeros([1,nTD]) datat = np.dot(dt,list(xrange(N+1))) for j in range(fc): # try nTD force = np.zeros(D) #force = np.random.rand(D)-0.5 # For only rand for 10 or 20 variables it overflows at time 2!!!! xtrue[:,j+1] = mod.lorenz96(xtrue[:,j],force,dt) xtrue[:,1] = xtrue[:,0] # try to sort python problem for 0 beginning index x[:,1] = x[:,0] # try to sort python problem for 0 beginning index print 'truth created' ################################## Creating the observations ################################### y = np.zeros([L,N]) #### No noise for y (ok for seed=37) #y = np.dot(h,xtrue[:,:N]) #print 'y', y.shape #### Good noise values for y (for seed=37) y = np.dot(h,xtrue[:,:N]) + np.random.uniform(0,1.2680e-04,N)-6.34e-05 #y = np.dot(h,xtrue[:,:N]) + np.random.uniform(0,1.2680e-04,N)-9.34e-05 #(out of zero mean! so tiny it's almost zero?) #y = np.dot(h,xtrue[:,:N]) + np.random.uniform(0,1.8680e-04,N)-9.34e-05
def Pmatrix(x, Jac0): #################### Initial settings ################################ N = 10000 Obs = 100 dt = 0.01 #original value=0.01 D = 20 F = 8.17 M = 40 ##################### Seeding for 20 variables####################### r = 37 #for x[:,0] = xtrue[:,0] np.random.seed(r) #################### Constructing h (obs operator) ################## observed_vars = range(1) L = len(observed_vars) h = np.zeros([L, D]) for i in range(L): h[i, observed_vars[i]] = 1.0 xx = np.zeros([D, 1]) Jac = np.zeros([D, D]) for i in range(D): Jac[i, i] = 1. #Jac0 = np.copy(Jac) run = 1 ################### Main loop ########################################## for n in range(1, run + 1): xx = x #Jac = Jac0 P = {} P['00'] = Jac0 for s in range(1, M): idxs = s for m in range(1, M): ii = idxs - m iid = idxs + 1 id1 = str(0) + str(idxs) id2 = str(0) + str(idxs - 1) id21 = str(m - 1) + str(idxs) id3 = str(iid - 1) + str(ii) id4 = str(iid - 2) + str(ii) id5 = str(iid - 1) + str(iid - 1) id6 = str(iid - 2) + str(iid - 2) if ii >= 0: Jac3 = P[id4] # Calculating the first row of Ps if m == 1: Jac2 = P[id2] ######################### Jac2 = np.transpose(Jac2) ######################### # Calculating all elements in the upper part of the diagonal# Jacsize = D**2 Jacv2 = Jac2.reshape(Jacsize) Jacvec2 = Jacv2.reshape(Jacsize, 1) Jac2 = mod.rk4_J3(Jacvec2, D, xx, dt) Jac2 = np.transpose(Jac2) P[id1] = Jac2 if m > 1: # Calculating all elements in the upper part of the diagonal# Jacsize = D**2 Jacv2 = Jac2.reshape(Jacsize) Jacvec2 = Jacv2.reshape(Jacsize, 1) Jac2 = mod.rk4_J3(Jacvec2, D, xx, dt) P[id21] = Jac2 # Calculating all elements in the lower part of the diagonal# Jacv3 = Jac3.reshape(Jacsize) Jacvec3 = Jacv3.reshape(Jacsize, 1) Jac3 = mod.rk4_J3(Jacvec3, D, xx, dt) P[id3] = Jac3 # Calculating all elements in the diagonal# Jacv4 = Jac2.reshape(Jacsize) Jacvec4 = Jacv4.reshape(Jacsize, 1) Jac4 = mod.rk4_J3(Jacvec4, D, xx, dt) P[id5] = Jac4 if m == (M - 1): random = np.zeros(D) xx = mod.lorenz96(xx, random, dt) return P