8.0, 0.0, 30.0 ]) # Condiciones iniciales para el spin-up del nature run (no cambiar) da_exp[ 'numtrans'] = 600 # Tiempo de spin-up para generar el nature run (no cambiar) #------------------------------------------------------------ # Configuracion del sistema de asimilacion #------------------------------------------------------------ da_exp['R0'] = 2.0 # Varianza del error de las observaciones. da_exp['bst'] = 8 # Cantidad de pasos de tiempo entre 2 asimilaciones. da_exp['forecast_length'] = 20 # Plazo de pronostico (debe ser al menos 1) da_exp['nvars'] = 3 # Numero de variables en el modelo de Lorenz (no tocar) #Obtengo el numero de observaciones (lo obtengo directamente del forward operator) da_exp['nobs'] = np.shape(forward_operator(np.array([0, 0, 0])))[0] #Definimos una matriz de error de las observaciones da_exp['R'] = da_exp['R0'] * np.identity( da_exp['nobs']) #En esta formulacion asumimos que los errores #en diferentes observaciones son todos iguales y #Creamos un vector de bias para las observaciones. da_exp['obs_bias'] = np.zeros( da_exp['nobs']) #que no estan correlacionados entre si. da_exp['P_from_file'] = False #Si vamos a leer la matriz P de un archivo. da_exp[ 'P_to_file'] = True #Si vamos a estimar y guardar la matriz P a partir de los pronosticos. #P=np.array([[0.6 , 0.5 , 0.0 ],[0.5 , 0.6 , 0.0 ],[0.0 , 0.0 , 1.0 ]]) P = None
p = np.array([a, r, b]) dt = 0.01 # Paso de tiempo para la integracion del modelo de Lorenz x0 = np.array([ 8.0, 0.0, 30.0 ]) # Condiciones iniciales para el spin-up del nature run (no cambiar) numtrans = 600 # Tiempo de spin-up para generar el nature run (no cambiar) #------------------------------------------------------------ # Configuracion del sistema de asimilacion #------------------------------------------------------------ dx0 = 1.0 * np.array([5.0, 5.0, 5.0]) # Error inicial de la estimacion. R0 = 8.0 # Varianza del error de las observaciones. nvars = 3 EnsSize = 30 #Numero de miembros en el ensamble. nobs = np.size(forward_operator(np.array([0, 0, 0]))) #Definimos una matriz de error de las observaciones R = R0 * np.identity(nobs) #En esta formulacion asumimos que los errores #en diferentes observaciones son todos iguales y P0 = 10.0 * np.array([[0.6, 0.5, 0.0], [0.5, 0.6, 0.0], [0.0, 0.0, 1.0]]) lam = 40.0 x = np.copy(x0) for i in range(numtrans): x = model.forward_model(x, p, dt) # Integramos la simulacion verdad # El resultado es almacenado en un array de numpy "state" con dimension (numstep,3)
b = 8.0/3.0 # standard L63 8.0/3.0 p=np.array([a,r,b]) dt=0.01 # Paso de tiempo para la integracion del modelo de Lorenz x0=np.array([ 8.0 , 0.0 , 30.0 ]) # Condiciones iniciales para el spin-up del nature run (no cambiar) numtrans=600 # Tiempo de spin-up para generar el nature run (no cambiar) #------------------------------------------------------------ # Configuracion del sistema de asimilacion #------------------------------------------------------------ dx0 = 1.0*np.array([ 5.0 , 5.0 , 5.0 ]) # Error inicial de la estimacion. R0=8.0 # Varianza del error de las observaciones. nvars=3 EnsSize=30 #Numero de miembros en el ensamble. nobs=np.size(forward_operator(np.array([0,0,0]))) #Definimos una matriz de error de las observaciones R=R0*np.identity(nobs) #En esta formulacion asumimos que los errores #en diferentes observaciones son todos iguales y P0=10.0*np.array([[0.6 , 0.5 , 0.0 ],[0.5 , 0.6 , 0.0 ],[0.0 , 0.0 , 1.0 ]]) lam = 40.0 x=np.copy(x0) for i in range(numtrans) : x = model.forward_model( x , p , dt ) # Integramos la simulacion verdad # El resultado es almacenado en un array de numpy "state" con dimension (numstep,3)
#Importamos todos los modulos que van a ser usados en esta notebook import numpy as np import scipy as sc from lorenz_63 import lorenz63 as model #Import the model (fortran routines) import Lorenz_63_DA as da import matplotlib.pyplot as plt import pickle as pkl from lorenz_63 import lorenz63 as model #Import the model (fortran routines) #Seleccionar aqui el operador de las observaciones que se desea usar. from Lorenz_63_ObsOperator import forward_operator_full as forward_operator from Lorenz_63_ObsOperator import forward_operator_full_tl as forward_operator_tl #Obtengo el numero de observaciones (lo obtengo directamente del forward operator) nobs=np.size(forward_operator(np.array([0,0,0]))) #------------------------------------------------------------ # Especificamos los parametros que usara el modelo #------------------------------------------------------------ a = 10.0 # standard L63 10.0 r = 28.0 # standard L63 28.0 b = 8.0/3.0 # standard L63 8.0/3.0 p=np.array([a,r,b]) dt=0.01 # Paso de tiempo para la integracion del modelo de Lorenz numtrans=1000 bst=32
import numpy as np import scipy as sc from lorenz_63 import lorenz63 as model #Import the model (fortran routines) import Lorenz_63_DA as da import matplotlib.pyplot as plt import pickle as pkl from lorenz_63 import lorenz63 as model #Import the model (fortran routines) #Seleccionar aqui el operador de las observaciones que se desea usar. from Lorenz_63_ObsOperator import forward_operator_logaritmic as forward_operator from Lorenz_63_ObsOperator import forward_operator_logaritmic_ens as forward_operator_ens from Lorenz_63_ObsOperator import forward_operator_logaritmic_tl as forward_operator_tl #Obtengo el numero de observaciones (lo obtengo directamente del forward operator) nobs=np.size(forward_operator(np.array([0,0,0]))) #------------------------------------------------------------ # Especificamos los parametros que usara el modelo #------------------------------------------------------------ a = 10.0 # standard L63 10.0 r = 28.0 # standard L63 28.0 b = 8.0/3.0 # standard L63 8.0/3.0 p=np.array([a,r,b]) dt=0.01 # Paso de tiempo para la integracion del modelo de Lorenz numtrans=1000 bst=32 EnsSize=10 nvars=3
import numpy as np import scipy as sc from lorenz_63 import lorenz63 as model #Import the model (fortran routines) import Lorenz_63_DA as da import matplotlib.pyplot as plt import pickle as pkl from lorenz_63 import lorenz63 as model #Import the model (fortran routines) #Seleccionar aqui el operador de las observaciones que se desea usar. from Lorenz_63_ObsOperator import forward_operator_nonlinearsum as forward_operator from Lorenz_63_ObsOperator import forward_operator_nonlinearsum_ens as forward_operator_ens from Lorenz_63_ObsOperator import forward_operator_nonlinearsum_tl as forward_operator_tl #Obtengo el numero de observaciones (lo obtengo directamente del forward operator) nobs = np.size(forward_operator(np.array([0, 0, 0]))) #------------------------------------------------------------ # Especificamos los parametros que usara el modelo #------------------------------------------------------------ a = 10.0 # standard L63 10.0 r = 28.0 # standard L63 28.0 b = 8.0 / 3.0 # standard L63 8.0/3.0 p = np.array([a, r, b]) dt = 0.01 # Paso de tiempo para la integracion del modelo de Lorenz numtrans = 1000 bst = 32 EnsSize = 30 nvars = 3