Ejercicio: 2Eva_IT2010_T3 EDP elíptica, Placa no rectangular

la fórmula a resolver, siendo f(x,y)=20

\frac{\delta^2 u}{\delta x^2} + \frac{\delta^2 u}{\delta y^2} = f \frac{\delta^2 u}{\delta x^2} + \frac{\delta^2 u}{\delta y^2} = 20

Siendo las condiciones de frontera en los bordes marcados:

Se convierte a forma discreta la ecuación

\frac{u_{i+1,j}-2u_{i,j}+u_{i-1,j}}{\Delta x^2} + \frac{u_{i,j+1} -2u_{i,j}+u_{i,j-1}}{\Delta y^2} = 20 u_{i+1,j}-2u_{i,j}+u_{i-1,j} + \frac{\Delta x^2}{\Delta y^2} \Big( u_{i,j+1} -2u_{i,j}+u_{i,j-1} \Big) = 20 \Delta x^2

siendo λ = 1, al tener la malla en cuadrícula Δx=Δy

u_{i+1,j}-4u_{i,j}+u_{i-1,j} + u_{i,j+1}+u_{i,j-1} = 20 \Delta x^2

despejando u[i,j]

u_{i,j} =\frac{1}{4}\Big(u_{i+1,j}+u_{i-1,j} + u_{i,j+1}+u_{i,j-1} - 20 \Delta x^2 \Big)

Para el ejercicio, se debe usar las fronteras para los valores de cálculo que se puede hacer de dos formas:
1. Por posición del valor en la malla [i,j]
2. Por valor xi,yj que es la forma usada cuando la función es contínua.

1. Por posición del valor en la malla

Se busca la posición de la esquina derecha ubicada en xi = 0 y yj=1.5 y se la ubica como variable 'desde' como referencia para ubicar los valores de las fronteras usando los índices i, j.

# valores en fronteras
# busca poscición de esquina izquierda
desde = -1 
for j in range(0,m,1):
    if ((yj[j]-1.5)<tolera):
        desde = j
# llena los datos de bordes de placa
for j  in range(0,m,1):
    if (yj[j]>=1):
        u[j-desde,j] = Ta
    u[n-1,j] = Tb(xi[n-1],yj[j])
for i in range(0,n,1):
    if (xi[i]>=1):
        u[i,m-1]=Td
    u[i,desde-i] = Tc(xi[i],yj[i])
# valor inicial de iteración

2. Por valor x_i, y_j

Se establecen las ecuaciones que forman la frontera:

ymin = lambda x,y: 1.5-(1.5/1.5)*x
ymax = lambda x,y: 1.5+(1/1)*x

que se usan como condición para hacer el cálculo en cada nodo

if ((yj[j]-yjmin)>tolera and (yj[j]-yjmax)<-tolera):
                u[i,j] = (u[i-1,j]+u[i+1,j]+u[i,j-1]+u[i,j+1]-20*(dx**2))/4

Para minimizar errores por redondeo o truncamiento al seleccionar los puntos, la referencia hacia cero se toma como "tolerancia"; en lugar de más que cero o menos que cero.

Con lo que se obtiene el resultado mostrado en la gráfica aumentando la resolución con Δx=Δy=0.05:

converge =  1
xi=
[0.   0.05 0.1  0.15 0.2  0.25 0.3  0.35 0.4  0.45 0.5  0.55 0.6  0.65
 0.7  0.75 0.8  0.85 0.9  0.95 1.   1.05 1.1  1.15 1.2  1.25 1.3  1.35
 1.4  1.45 1.5 ]
yj=
[0.   0.05 0.1  0.15 0.2  0.25 0.3  0.35 0.4  0.45 0.5  0.55 0.6  0.65
 0.7  0.75 0.8  0.85 0.9  0.95 1.   1.05 1.1  1.15 1.2  1.25 1.3  1.35
 1.4  1.45 1.5  1.55 1.6  1.65 1.7  1.75 1.8  1.85 1.9  1.95 2.   2.05
 2.1  2.15 2.2  2.25 2.3  2.35 2.4  2.45 2.5 ]
matriz u
[[  0.     0.     0.   ...   0.     0.     0.  ]
 [  0.     0.     0.   ...   0.     0.     0.  ]
 [  0.     0.     0.   ...   0.     0.     0.  ]
 ...
 [  0.     0.     6.67 ...  96.1   98.03 100.  ]
 [  0.     3.33   5.31 ...  96.03  98.   100.  ]
 [  0.     2.     4.   ...  96.    98.   100.  ]]
>>>

---

Algoritmo en Python

# Ecuaciones Diferenciales Parciales
# Elipticas. Método iterativo para placa NO rectangular
import numpy as np

# INGRESO
# Condiciones iniciales en los bordes
Ta = 100
Tb = lambda x,y:(100/2.5)*y
Tc = lambda x,y: 100-(100/1.5)*x
Td = 100
# dimensiones de la placa no rectangular
x0 = 0
xn = 1.5
y0 = 0
yn = 2.5
ymin = lambda x,y: 1.5-(1.5/1.5)*x
ymax = lambda x,y: 1.5+(1/1)*x
# discretiza, supone dx=dy
dx = 0.05 
dy = 0.05 
maxitera = 100
tolera = 0.0001

# PROCEDIMIENTO
xi = np.arange(x0,xn+dx,dx)
yj = np.arange(y0,yn+dy,dy)
n = len(xi)
m = len(yj)
# Matriz u
u = np.zeros(shape=(n,m),dtype = float)

# valores en fronteras
# busca posición de esquina izquierda
desde = -1 
for j in range(0,m,1):
    if ((yj[j]-1.5)<tolera): desde = j 

# llena los datos de bordes de placa 

for j in range(0,m,1): if (yj[j]>=1):
        u[j-desde,j] = Ta
    u[n-1,j] = Tb(xi[n-1],yj[j])
for i in range(0,n,1):
    if (xi[i]>=1):
        u[i,m-1]=Td
    u[i,desde-i] = Tc(xi[i],yj[i])
# valor inicial de iteración
# se usan los valores cero

# iterar puntos interiores
itera = 0
converge = 0
while not(itera>=maxitera and converge==1):
    itera = itera + 10000
    nueva = np.copy(u)
    for i in range(1,n-1):
        for j in range(1,m-1):
            yjmin = ymin(xi[i],yj[j])
            yjmax = ymax(xi[i],yj[j])
            if ((yj[j]-yjmin)>tolera and (yj[j]-yjmax)<-tolera):
                u[i,j] = (u[i-1,j]+u[i+1,j]+u[i,j-1]+u[i,j+1]-20*(dx**2))/4
    diferencia = nueva-u
    erroru = np.linalg.norm(np.abs(diferencia))

    if (erroru<tolera):
        converge=1

# SALIDA
np.set_printoptions(precision=2)
print('converge = ', converge)
print('xi=')
print(xi)
print('yj=')
print(yj)
print('matriz u')
print(u)

Para incorporar la gráfica en forma de superficie.

# Gráfica
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

X, Y = np.meshgrid(xi, yj)
U = np.transpose(u) # ajuste de índices fila es x
figura = plt.figure()
ax = Axes3D(figura)
ax.plot_surface(X, Y, U, rstride=1, cstride=1, cmap=cm.Reds)
plt.title('EDP elíptica')
plt.xlabel('x')
plt.ylabel('y')
plt.show()

Ejercicio: 3Eva_IIT2010_T4 EDO con Taylor

\frac{\delta y}{\delta x} = \frac{y^3}{1-2xy^2} y(0) = 1, 0 \leq x \leq 1

escrita en forma simplificada

y' = \frac{y^3}{1-2xy^2}

tomando como referencia Taylor de 2 términos más el término de error O(h²)

y_{i+1} = y_i +\frac{h}{1!}y'_i + \frac{h^2}{2!}y''_i

Se usa hasta el segundo término para el algoritmo.

y_{i+1} = y_i +\frac{h}{1!}

Con lo que se puede realizar el algoritmo

estimado[xi,yi]
[[0.  1. ]
 [0.2 1.2 ]
 [0.4 2.01509434]
 [0.6 1.28727044]
 [0.8 0.85567954]
 [1.  0.12504631]]

Algoritmo en Python

# 3Eva_IIT2010_T4 EDO con Taylor
# estima la solución 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)
        x = x+h
        estimado[i] = [x,y]
    return(estimado)

# PROGRAMA PRUEBA
# 3Eva_IIT2010_T4 EDO con Taylor

# INGRESO.
# d1y = y' = f, d2y = y'' = f'
d1y = lambda x,y: (y**3)/(1-2*x*(y**2))
x0 = 0
y0 = 1
h = 0.2
muestras = 5

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

# SALIDA
print('estimado[xi,yi]')
print(puntos)

# Gráfica
import matplotlib.pyplot as plt
plt.plot(xi[0],yi[0],'o', color='r', label ='[x0,y0]')
plt.plot(xi[1:],yi[1:],'o', color='g', label ='y estimada')
plt.title('EDO: Solución con Taylor 2 términos')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid()
plt.show()

Nota: Revisar los resultados no lineales con los valores de h=0.02

Ejercicio: 3Eva_IT2010_T2 EDO problema con valor inicial dy/dx

Ecuación del problema:

(2y^2 + 4x^2)\delta x -xy \delta y =0

se despeja dy/dx:

(2y^2 + 4x^2)\delta x = xy \delta y \frac{\delta y}{\delta x} =\frac{2y^2 + 4x^2}{xy}

con valores iniciales de x₀ = 1, y₀=-2 , h=0.2 e intervalo [1,2]

Usando Runge-Kutta de 2do Orden

Iteración 1

K_1= h\frac{\delta y}{\delta x}(1,-2) =(0.2)\frac{2(-2)^2 + 4(1)^2}{(1)(-2)}= -1.2 K_2= h\frac{\delta y}{\delta x}(1+0.2,-2+(-1.2)) =(0.2)\frac{2(-2-1.2)^2 + 4(1+0.2)^2}{(1+0.2)(-2-1.2)}= -1.3667 y_1 = -2 + \frac{-1.2-1.3667}{2} = -3.2833 x_1 = x_0 + h = 1 + 0.2 = 1.2 error = O(h^3) = O(0.2^3) = 0.008

Iteración 2

K_1= h\frac{\delta y}{\delta x}(1.2,-3.2833) =(0.2)\frac{2(-3.2833)^2 + 4(1.2)^2}{(1.2)(-3.2833)}= -1.3868 K_2= h\frac{\delta y}{\delta x}(1.2+0.2,-3.2833+(-1.3868)) =(0.2)\frac{2(-3.2833+(-1.3868))^2 + 4(1.2+0.2)^2}{(1.2+0.2)(-3.2833+(-1.3868))}= -1.5742 y_2 = -3.2833 + \frac{-1.3868-1.5742}{2} = -4.7638 x_2 = x_1 + h = 1.2 + 0.2 = 1.4

Iteración 3

K_1= h\frac{\delta y}{\delta x}(1.4,-4.7638) =(0.2)\frac{2(-4.76383)^2 + 4(1.4)^2}{(1.4)(-4.7638)}= -1.5962 K_2= h\frac{\delta y}{\delta x}(1.4+0.2,-4.7638+(-1.5962)) =(0.2)\frac{2(-4.7638+(-1.5962))^2 + 4(1.4+0.2)^2}{(1.4+0.2)(-4.7638+(-1.5962))}= -1.7913 y_3 = -4.7638 + \frac{-1.5962-1.7913}{2} = -6.4576 x_3 = x_2 + h = 1.4 + 0.2 = 1.6

con lo que usando el algoritmo se obtiene la tabla y gráfica:

 [xi,       yi,       K1,     K2     ]
[[  1.      -2.       0.       0.    ]
 [  1.2     -3.2833  -1.2     -1.3667]
 [  1.4     -4.7638  -1.3868  -1.5742]
 [  1.6     -6.4576  -1.5962  -1.7913]
 [  1.8     -8.3698  -1.8126  -2.0119]
 [  2.     -10.5029  -2.032   -2.2342]

Algoritmo en Python

# 3Eva_IT2010_T2 EDO
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
d1y = lambda x,y : (2*(y**2)+4*(x**2))/(x*y)
x0 = 1
y0 = -2
h = 0.2
a = 1
b = 2

# PROCEDIMIENTO
muestras = int((b -a)/h)+1
tabla = np.zeros(shape=(muestras,4),dtype=float)

i = 0
xi = x0
yi = y0
tabla[i,:] = [xi,yi,0,0]

i = i+1
while not(i>=muestras):
    K1 = h* d1y(xi,yi)
    K2 = h* d1y(xi+h,yi+K1)
    yi = yi + (K1+K2)/2
    xi = xi +h
    tabla[i,:] = [xi,yi,K1,K2]
    i = i+1
# vector para gráfica
xg = tabla[:,0]
yg = tabla[:,1]

# SALIDA
# muestra 4 decimales
np.set_printoptions(precision=4)
print(' [xi, yi, K1, K2]')
print(tabla)

# Gráfica
plt.plot(xg,yg)
plt.xlabel('xi')
plt.ylabel('yi')
plt.grid()
plt.show()

Tarea: Realizar con Runge Kutta de 4to Orden

Ejercicio: 3Eva_IT2010_T1 Envase cilíndrico

Se conoce que el volumen del cilindro es 1000 cm³
que se calcula como:

Volumen = area_{base} . altura = \pi r^2 h \pi r^2 h = 1000 h = \frac{1000}{\pi r^2}

con lo que la altura queda en función del radio, pues el volumen es una constante.

Para conocer el área de la hoja de material para el envase se conoce que las tapas cilíndricas deben ser 0.25 mas que el radio para sellar el recipiente

Area de una tapa circular:

Area_{tapa} = \pi (r+ 0.25)^2

para la hoja lateral:

Area_{lateral} = base * altura = (2 \pi r + 0.25) h

que en función del radio, usando la fórmula para h(r) se convierte en:

Area_{lateral} = (2 \pi r + 0.25) \frac{1000}{\pi r^2}

por lo que el total de material de hoja a usar corresponde a dos tapas circulares y una hoja lateral.

Area total = 2 \pi (r+ 0.25)^2 + (2 \pi r + 0.25) \frac{1000}{\pi r^2}

---

la gráfica permite observar el comportamiento entre el área de la hoja necesaria para fabricar el envase y el radio de las tapas circulares.

El objetivo es encontrar el área mínima para consumir menos material. Con la fórmula mostrada se puede aplicar uno de los métodos para encontrar raíces a partir de la derivada de la fórmula.

Tarea: Encontrar el valor requerido para r con la tolerancia indicada para el examen.

---

Instrucciones para la gráfica:

# 3Eva_IT2010_T1 Envase cilíndrico
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
a = 0.5
b = 20
muestras = 51

Area = lambda r: (2*np.pi)*(r+0.25)**2 +(2*np.pi*r+0.25)*1000/(np.pi*(r**2))

# PROCEDIMIENTO
ri = np.linspace(a,b,muestras)
Areai = Area(ri)

# SALIDA
plt.plot(ri,Areai)
plt.xlabel('r (cm)')
plt.ylabel('Area (cm2)')
plt.title('Area hoja para material cilindro')
plt.show()