Exemplo n.º 1
0
    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
Exemplo n.º 2
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)
Exemplo n.º 3
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
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)
Exemplo n.º 4
0
#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
Exemplo n.º 5
0
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
Exemplo n.º 6
0
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