s2Eva_IT2012_T2 Modelo de clima

Ejercicio: 2Eva_IT2012_T2 Modelo de clima

Se deja de tarea realizar las tres primeras iteraciones en papel.

Se presenta el resultado usando el algoritmo de segundo grado como una variante a la respuesta usada como ejemplo.

 [ ti, xi, yi, zi]
[[ 0.0000e+00  1.0000e+01  7.0000e+00  7.0000e+00]
 [ 2.5000e-03  9.9323e+00  7.5033e+00  7.1335e+00]
 [ 5.0000e-03  9.8786e+00  7.9988e+00  7.2774e+00]
 ...
 [ 2.4995e+01 -8.4276e+00 -2.7491e+00  3.3021e+01]
 [ 2.4998e+01 -8.2860e+00 -2.6392e+00  3.2858e+01]
 [ 2.5000e+01 -8.1453e+00 -2.5346e+00  3.2692e+01]]

Algoritmo en Python

# 2Eva_IT2012_T2 Modelo de clima
# MATG1013 Análisis Numérico
import numpy as np
import matplotlib.pyplot as plt

def rungekutta2_fg(f,g,j,t0,x0,y0,z0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,4),dtype=float)
    # incluye el punto [t0,x0,y0,z0]
    estimado[0] = [t0,x0,y0,z0]
    ti = t0
    xi = x0
    yi = y0
    zi = z0
    for i in range(1,tamano,1):
        K1x = h * f(ti,xi,yi,zi)
        K1y = h * g(ti,xi,yi,zi)
        K1z = h * j(ti,xi,yi,zi)
        
        K2x = h * f(ti+h,xi + K1x, yi + K1y, zi + K1z)
        K2y = h * g(ti+h,xi + K1x, yi + K1y, zi + K1z)
        K2z = h * j(ti+h,xi + K1x, yi + K1y, zi + K1z)
        
        xi = xi + (K1x+K2x)/2
        yi = yi + (K1y+K2y)/2
        zi = zi + (K1z+K2z)/2
        ti = ti + h
        
        estimado[i] = [ti,xi,yi,zi]
    return(estimado)


#INGRESO
to = 0
xo = 10
yo = 7
zo = 7
f = lambda t,x,y,z: 10*(y-x)
g = lambda t,x,y,z: x*(28-z) - y
j = lambda t,x,y,z: -(8/3)*z + (x*y)
h = 0.0025
muestras = 10000

#PROCEDIMIENTO
#Rugen-Kutta 2_orden
tabla = rungekutta2_fg(f,g,j,to,xo,yo,zo,h,muestras)

#SALIDA
np.set_printoptions(precision=4)
print(' [ ti, xi, yi, zi]')
print(tabla)

# Gráfica
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot(tabla[:,1], tabla[:,2], tabla[:,3])
plt.show()

s2Eva_IIT2011_T3 EDP Parabólica, explícito

Ejercicio: 2Eva_IIT2011_T3 EDP Parabólica, explícito

La ecuación a resolver es:

\frac{\delta u}{\delta t} - \frac{\delta^2 u}{\delta x^2} =2

Como el método requerido es explícito se usan las diferencias divididas:

\frac{d^2 u}{dx^2} = \frac{u_{i+1,j} - 2 u_{i,j} + u_{i-1,j}}{(\Delta x)^2} \frac{du}{dt} = \frac{u_{i,j+1} - u_{i,j} }{\Delta t}

Reordenando la ecuación al modelo realizado en clase:

\frac{\delta^2 u}{\delta x^2} = \frac{\delta u}{\delta t} - 2 \frac{u_{i+1,j} - 2 u_{i,j} + u_{i-1,j}}{(\Delta x)^2} = \frac{u_{i,j+1} - u_{i,j} }{\Delta t} - 2

multiplicando cada lado por Δt

\frac{\Delta t}{(\Delta x)^2} \Big[u_{i+1,j} - 2 u_{i,j} + u_{i-1,j} \Big]= u_{i,j+1} - u_{i,j} - 2\Delta t

Se establece el valor de

\lambda = \frac{\Delta t}{(\Delta x)^2} \lambda u_{i+1,j} - 2 \lambda u_{i,j} + \lambda u_{i-1,j} = u_{i,j+1} - u_{i,j} - 2\Delta t

obteniendo la ecuación general, ordenada por índices de izquierda a derecha:

\lambda u_{i-1,j} +(1- 2 \lambda)u_{i,j} + \lambda u_{i+1,j} + 2\Delta t = u_{i,j+1}

con valores de:

λ = Δt/(Δx)2 = (0.04)/(0.25)2 = 0.64
P = λ = 0.64
Q = (1-2λ) = -0.28
R = λ = 0.64
0.64 u_{i-1,j} - 0.28 u_{i,j} + 0.64 u_{i+1,j} + 0.08 = u_{i,j+1}

Se realizan 3 iteraciones:

i= 1, j=0

u_{1,1} = 0.64 u_{0,0} -0.28u_{1,0}+0.64 u_{2,0}+0.08 u_{1,1} = 0.64 [\sin(\pi*0)+0*(1-0)]- 0.28[\sin(\pi*0.25)+0.25*(1-0.25)] +0.64[\sin(\pi*0.5)+ 0.5*(1-0.5)]+0.08

u[1,1] =0.89

i = 2, j=0

0.64 u_{1,0} - 0.28 u_{2,0} + 0.64 u_{3,0} + 0.08 = u_{2,1}

u[1,0] = 1.25

i = 3, j=0

0.64 u_{2,0} - 0.28 u_{3,0} + 0.64 u_{4,0} + 0.08 = u_{3,1}

u[3,1] = 0.89


Algoritmo en Python

con los valores y ecuación del problema

# EDP parabólicas d2u/dx2  = K du/dt
# método explícito, usando diferencias finitas
# Referencia: Chapra 30.2 p.888 pdf.912
#       Rodriguez 10.2 p.406
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
# Valores de frontera
Ta = 0
Tb = 0
T0 = lambda x: np.sin(np.pi*x)+x*(1-x)
# longitud en x
a = 0
b = 1
# Constante K
K = 1
# Tamaño de paso
dx = 0.1
dt = dx/10/2
# iteraciones en tiempo
n = 50

# PROCEDIMIENTO
# iteraciones en longitud
xi = np.arange(a,b+dx,dx)
m = len(xi)
ultimox = m-1

# Resultados en tabla u[x,t]
u = np.zeros(shape=(m,n), dtype=float)

# valores iniciales de u[:,j]
j=0
ultimot = n-1
u[0,j]= Ta
u[1:ultimox,j] = T0(xi[1:ultimox])
u[ultimox,j] = Tb

# factores P,Q,R
lamb = dt/(K*dx**2)
P = lamb
Q = 1 - 2*lamb
R = lamb

# Calcula U para cada tiempo + dt
j = 0
while not(j>=ultimot):
    u[0,j+1] = Ta
    for i in range(1,ultimox,1):
        u[i,j+1] = P*u[i-1,j] + Q*u[i,j] + R*u[i+1,j]+2*dt
    u[m-1,j+1] = Tb
    j=j+1

# SALIDA
print('Tabla de resultados')
np.set_printoptions(precision=2)
print(u)

# Gráfica
salto = int(n/10)
if (salto == 0):
    salto = 1
for j in range(0,n,salto):
    vector = u[:,j]
    plt.plot(xi,vector)
    plt.plot(xi,vector, '.r')
plt.xlabel('x[i]')
plt.ylabel('t[j]')
plt.title('Solución EDP parabólica')
plt.show()

s2Eva_IT2015_T2 Deflexión de mástil

Ejercicio: 2Eva_IT2015_T2 Deflexión de mástil

\frac{\delta ^2 y}{\delta x^2} = \frac{f}{2EI} (L-x)^2 x= 0, y = 0, \frac{\delta y}{\delta x} = 0

Ecuación en forma estandarizada:

y'' = \frac{f}{2EI} (L-x)^2

Sistema de ecuaciones

y' = z = f(x,y,z) z' = \frac{f}{2EI} (L-x)^2 = g(x,y,z)

siendo:

\frac{f}{2EI} =\frac{60}{2(1.25 \times 10 ^{-8}) (0.05)} = 4.8 \times 10^{-6}

El mástil mide L=30 m y se requieren 30 intervalos, entonces h = 30/30 = 1.

Usando muestras = tramos +1 = 31

Se plantea una solución usando Runge Kutta de 2do Orden

f(x,y,z) = z g(x,y,z) = (4.8 \times 10^{-6})(30-x)^2

Desarrollo analítico

Las iteraciones se realizan para llenar los datos de la tabla,

tabla de resultados
i xi yi zi
0 0 0 0
1 1 0.00216 0.00417
2 2 0.00835 0.00807
3 3 tarea

iteración 1

i = 0 ; x0= 0; y0 = 0; z0 = 0

K_{1y} = h f(x_0,y_0, z_0)= 1(0) = 0

 

K_{1z} = h g(x_0,y_0, z_0) = = 1(4.8 \times 10^{-6})(30-0)^2 = 0.00432 K_{2y} = h f(x_0+h,y_0+K_{1y}, z_0+K_{1z}) = = 1(0+0.00432) = 0.00432 K_{2z} = h g(x_0+h,y_0+K_{1y}, z_0+K_{1z}) = = 1(4.8 \times 10^{-6})(30-(0+1))^2 = 0.00403 y_1 = y_0 + \frac{K_{1y}+K_{2y}}{2} = = 0 + \frac{0+0.00432}{2} = 0.00216 z_1 = z_0 + \frac{K_{1z}+K_{2z}}{2} = = 0 + \frac{0.00432+0.00403}{2} = 0.00417

iteración 2

i = 2 ; x1= 1; y1 = 0.00216; z1 = 0.00417

K_{1y} = h f(x_1,y_1, z_1)= 1(0.00417) = 0.00417 K_{1z} = h g(x_1,y_1, z_1) = = 1(4.8 \times 10^{-6})(30-1)^2 = 0.00403 K_{2y} = h f(x_1+h,y_1+K_{1y}, z_1+K_{1z}) = = 1(0.00417+0.00403) = 0.00821 K_{2z} = h g(x_1+h,y_1+K_{1y}, z_1+K_{1z}) = = 1(4.8 \times 10^{-6})(30-(1+1))^2 = 0.00376 y_2 = y_1 + \frac{K_{1y}+K_{2y}}{2} = = 0.00216 + \frac{0.00417+0.00821}{2} = 0.00835 z_2 = z_2 + \frac{K_{1z}+K_{2z}}{2} = = 0.00417 + \frac{0.00403+0.00376}{2} = 0.00807

iteración 3
i = 2; x2= 2; y2 = 0.00835; z2 = 0.00807
tarea

Para facilitar los cálculos se propone usa el algoritmo en Python, como se describe en la siguiente sección.


Algoritmo en Python

Al usar el algoritmo se puede comparar los resultados entre Runge-Kutta de 2do orden y de 4to Orden.

De los resultados se presenta la siguiente gráfica

Observe en la gráfica la diferencia de escalas entre los ejes.

Runge Kutta 2do Orden
 [x, y, z]
[[  0.00000000e+00   0.00000000e+00   0.00000000e+00]
 [  1.00000000e+00   2.16000000e-03   4.17840000e-03]
 [  2.00000000e+00   8.35680000e-03   8.07840000e-03]
 [  3.00000000e+00   1.83168000e-02   1.17096000e-02]
 [  4.00000000e+00   3.17760000e-02   1.50816000e-02]
 [  5.00000000e+00   4.84800000e-02   1.82040000e-02]
 ...
 [  2.90000000e+01   9.29856000e-01   4.32216000e-02]
 [  3.00000000e+01   9.73080000e-01   4.32240000e-02]
 [  3.10000000e+01   1.01630400e+00   4.32264000e-02]]
Runge Kutta 4do Orden
 [x, y, z]
[[  0.00000000e+00   0.00000000e+00   0.00000000e+00]
 [  1.00000000e+00   2.11240000e-03   4.17760000e-03]
 [  2.00000000e+00   8.26240000e-03   8.07680000e-03]
 [  3.00000000e+00   1.81764000e-02   1.17072000e-02]
 [  4.00000000e+00   3.15904000e-02   1.50784000e-02]
 [  5.00000000e+00   4.82500000e-02   1.82000000e-02]
 ...
 [  2.90000000e+01   9.28800400e-01   4.31984000e-02]
 [  3.00000000e+01   9.72000000e-01   4.32000000e-02]
 [  3.10000000e+01   1.01520040e+00   4.32016000e-02]]
>>> 

Las instrucciones en Python obtener los resultados:

# 2Eva_IT2015_T2 Deflexión de mástil
# solución propuesta: edelros@espol.edu.ec
import numpy as np

def rungekutta2fg(fx,gx,x0,y0,z0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,3),dtype=float)
    # incluye el punto [x0,y0]
    estimado[0] = [x0,y0,z0]
    xi = x0
    yi = y0
    zi = z0
    for i in range(1,tamano,1):
        K1y = h * fx(xi,yi,zi)
        K1z = h * gx(xi,yi,zi)
        
        K2y = h * fx(xi+h, yi + K1y, zi + K1z)
        K2z = h * gx(xi+h, yi + K1y, zi + K1z)

        yi = yi + (K1y+K2y)/2
        zi = zi + (K1z+K2z)/2
        xi = xi + h
        
        estimado[i] = [xi,yi,zi]
    return(estimado)

def rungekutta4fg(fx,gx,x0,y0,z0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,3),dtype=float)
    # incluye el punto [x0,y0]
    estimado[0] = [x0,y0,z0]
    xi = x0
    yi = y0
    zi = z0
    for i in range(1,tamano,1):
        K1y = h * fx(xi,yi,zi)
        K1z = h * gx(xi,yi,zi)
        
        K2y = h * fx(xi+h/2, yi + K1y/2, zi + K1z/2)
        K2z = h * gx(xi+h/2, yi + K1y/2, zi + K1z/2)
        
        K3y = h * fx(xi+h/2, yi + K2y/2, zi + K2z/2)
        K3z = h * gx(xi+h/2, yi + K2y/2, zi + K2z/2)

        K4y = h * fx(xi+h, yi + K3y, zi + K3z)
        K4z = h * gx(xi+h, yi + K3y, zi + K3z)

        yi = yi + (K1y+2*K2y+2*K3y+K4y)/6
        zi = zi + (K1z+2*K2z+2*K3z+K4z)/6
        xi = xi + h
        
        estimado[i] = [xi,yi,zi]
    return(estimado)

# INGRESO
f = 60
L = 30
E = 1.25e8
I = 0.05
x0 = 0
y0 = 0
z0 = 0
tramos = 30

fx = lambda x,y,z: z
gx = lambda x,y,z: (f/(2*E*I))*(L-x)**2

# PROCEDIMIENTO
muestras = tramos + 1
h = L/tramos
tabla2 = rungekutta2fg(fx,gx,x0,y0,z0,h,muestras)
xi2 = tabla2[:,0]
yi2 = tabla2[:,1]
zi2 = tabla2[:,2]

tabla4 = rungekutta4fg(fx,gx,x0,y0,z0,h,muestras)
xi4 = tabla4[:,0]
yi4 = tabla4[:,1]
zi4 = tabla4[:,2]

# SALIDA
print('Runge Kutta 2do Orden')
print(' [x, y, z]')
print(tabla2)
print('Runge Kutta 4do Orden')
print(' [x, y, z]')
print(tabla4)

# GRAFICA
import matplotlib.pyplot as plt
plt.plot(xi2,yi2, label='Runge-Kutta 2do Orden')
plt.plot(xi4,yi4, label='Runge-Kutta 4do Orden')
plt.title('Deflexión de mástil')
plt.xlabel('x')
plt.ylabel('y: deflexión')
plt.legend()
plt.grid()
plt.show()

s2Eva_IT2012_T3_MN EDO Taylor 2 Contaminación de estanque

Ejercicio: 2Eva_IT2012_T3_MN EDO Taylor 2 Contaminación de estanque

La ecuación a resolver con Taylor es:

s'- \frac{26s}{200-t} - \frac{5}{2} = 0

Para lo que se plantea usar la primera derivada:

s'= \frac{26s}{200-t}+\frac{5}{2}

con valores iniciales de s(0) = 0, h=0.1

La fórmula de Taylor para tres términos es:

s_{i+1}= s_{i}+s'_{i}h + \frac{s''_{i}}{2}h^2 + error

Para el desarrollo se compara la solución con dos términos, tres términos y Runge Kutta.

1. Solución con dos términos de Taylor

Iteraciones

i = 0, t0 = 0, s(0)=0

s'_{0}= \frac{26s_{0}}{200-t_{0}}+\frac{5}{2} = \frac{26(0)}{200-0}+\frac{5}{2} = \frac{5}{2} s_{1}= s_{0}+s'_{0}h = 0+ \frac{5}{2}*0.1= 0.25

t1 =  t0+h = 0+0.1 = 0.1

i=1


s'_{1}= \frac{26s_{1}}{200-t_{1}}+\frac{5}{2} = \frac{26(0.25)}{200-0.1}+\frac{5}{2} = 2.5325 s_{2}= s_{1}+s'_{1}h = 0.25 + (2.5325)*0.1 = 0.5032

t2 =  t1+h = 0.1+0.1 = 0.2

i=2,

resolver como tarea


2. Resolviendo con Python

estimado
 [xi,yi Taylor,yi Runge-Kutta, diferencias]
[[ 0.0  0.0000e+00  0.0000e+00  0.0000e+00]
 [ 0.1  2.5000e-01  2.5163e-01 -1.6258e-03]
 [ 0.2  5.0325e-01  5.0655e-01 -3.2957e-03]
 [ 0.3  7.5980e-01  7.6481e-01 -5.0106e-03]
 [ 0.4  1.0197e+00  1.0265e+00 -6.7714e-03]
 [ 0.5  1.2830e+00  1.2916e+00 -8.5792e-03]
 [ 0.6  1.5497e+00  1.5601e+00 -1.0435e-02]
 [ 0.7  1.8199e+00  1.8322e+00 -1.2339e-02]
 [ 0.8  2.0936e+00  2.1079e+00 -1.4294e-02]
 [ 0.9  2.3710e+00  2.3873e+00 -1.6299e-02]
 [ 1.0  2.6519e+00  2.6703e+00 -1.8357e-02]
 [ 1.1  2.9366e+00  2.9570e+00 -2.0467e-02]
 [ 1.2  3.2250e+00  3.2476e+00 -2.2632e-02]
 [ 1.3  3.5171e+00  3.5420e+00 -2.4853e-02]
 [ 1.4  3.8132e+00  3.8403e+00 -2.7129e-02]
 [ 1.5  4.1131e+00  4.1426e+00 -2.9464e-02]
 [ 1.6  4.4170e+00  4.4488e+00 -3.1857e-02]
 [ 1.7  4.7248e+00  4.7592e+00 -3.4310e-02]
 [ 1.8  5.0368e+00  5.0736e+00 -3.6825e-02]
 [ 1.9  5.3529e+00  5.3923e+00 -3.9402e-02]
 [ 2.0  5.6731e+00  5.7152e+00 -4.2043e-02]]
error en rango:  0.04204310894163932


2. Algoritmo en Python

# EDO. Método de Taylor 3 términos 
# estima la solucion para muestras espaciadas h en eje x
# valores iniciales x0,y0
# entrega arreglo [[x,y]]
import numpy as np

def edo_taylor2t(d1y,x0,y0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,2),dtype=float)
    # incluye el punto [x0,y0]
    estimado[0] = [x0,y0]
    x = x0
    y = y0
    for i in range(1,tamano,1):
        y = y + h*d1y(x,y) # + ((h**2)/2)*d2y(x,y)
        x = x+h
        estimado[i] = [x,y]
    return(estimado)

def rungekutta2(d1y,x0,y0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,2),dtype=float)
    # incluye el punto [x0,y0]
    estimado[0] = [x0,y0]
    xi = x0
    yi = y0
    for i in range(1,tamano,1):
        K1 = h * d1y(xi,yi)
        K2 = h * d1y(xi+h, yi + K1)

        yi = yi + (K1+K2)/2
        xi = xi + h
        
        estimado[i] = [xi,yi]
    return(estimado)

# PROGRAMA PRUEBA
# 2Eva_IIT2016_T3_MN EDO Taylor 2, Tanque de agua

# INGRESO.
# d1y = y' = f, d2y = y'' = f'
d1y = lambda x,y: 26*y/(200-x)+5/2
x0 = 0
y0 = 0
h = 0.1
muestras = 20

# PROCEDIMIENTO
puntos = edo_taylor2t(d1y,x0,y0,h,muestras)
xi = puntos[:,0]
yi = puntos[:,1]

# Con Runge Kutta
puntosRK2 = rungekutta2(d1y,x0,y0,h,muestras)
xiRK2 = puntosRK2[:,0]
yiRK2 = puntosRK2[:,1]

# diferencias
diferencias = yi-yiRK2
error = np.max(np.abs(diferencias))
tabla = np.copy(puntos)
tabla = np.concatenate((puntos,np.transpose([yiRK2]),
                        np.transpose([diferencias])),
                       axis = 1)

# SALIDA
np.set_printoptions(precision=4)
print('estimado[xi,yi Taylor,yi Runge-Kutta, diferencias]')
print(tabla)
print('error en rango: ', error)

# Gráfica
import matplotlib.pyplot as plt
plt.plot(xi[0],yi[0],'o',
         color='r', label ='[x0,y0]')
plt.plot(xi[0:],yi[0:],'-',
         color='g',
         label ='y Taylor 2 términos')
plt.plot(xiRK2[0:],yiRK2[0:],'-',
         color='blue',
         label ='y Runge-Kutta 2Orden')
plt.axhline(y0/2)
plt.title('EDO: Taylor 2T vs Runge=Kutta 2Orden')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid()
plt.show()

Usando Taylor con 3 términos

estimado
 [xi,        yi,        d1yi,      d2yi      ]
[[0.         0.         2.5        0.325     ]
 [0.1        0.251625   2.53272761 0.32958302]
 [0.2        0.50654568 2.56591685 0.33423301]
 [0.3        0.76480853 2.59957447 0.33895098]
 [0.4        1.02646073 2.63370731 0.34373796]
 [0.5        1.29155015 2.66832233 0.348595  ]
 [0.6        1.56012536 2.70342658 0.35352316]
 [0.7        1.83223563 2.73902723 0.35852351]
 [0.8        2.10793097 2.77513155 0.36359715]
 [0.9        2.38726211 2.81174694 0.36874519]
 [1.         2.67028053 2.84888087 0.37396876]
 [1.1        2.95703846 2.88654098 0.37926901]
 [1.2        3.24758891 2.92473497 0.3846471 ]
 [1.3        3.54198564 2.96347069 0.39010422]
 [1.4        3.84028323 3.00275611 0.39564157]
 [1.5        4.14253705 3.04259931 0.40126036]
 [1.6        4.44880328 3.08300849 0.40696184]
 [1.7        4.75913894 3.12399199 0.41274727]
 [1.8        5.07360187 3.16555827 0.41861793]
 [1.9        5.39225079 3.2077159  0.42457511]
 [2.         5.71514526 0.         0.        ]]