Tarea 3 - Métodos Numéricos - MEC301

Fecha de entrega: 20 de noviembre, 2023

Nombre:

Instrucciones.

Complete este archivo con sus respuestas.

Una vez completado, guarde el archivo como: "tarea3_apellido_nombre.ipynb". (Todo en minusculas)
Adjunte el archivo "tarea3_apellido_nombre.ipynb" al buzón de entregas de webcurso

Item (a) (b) (c) (d) (e) total

problema 1

problema 2 - - -

problema 3 - - -

problema 4 - - -

Nota Final - - - - -

Problema 1 (3.0 puntos)

La ecuación gobernante que describe la evolución de la posición x 1 y x 2 de dos carros de masas m 1 y m 2 conectados por un sistema de
resortes, como indica la figura, es:

d 2x 1 dx 1
m1
dt 2
( ) (
= − k1 x1 − L1 + k2 x2 − x1 − w1 − L2 − c1 ) dt
d 2x dx 2
m2
dt 2
2
(
= − k2 x2 − x1 − w1 − L2 − c2 ) dt

donde k 1 = k 2 = 5 N / m son las constantes de rigidez de los resortes, c 1 = c 2 = 0.05 kg / s son coeficientes de amortiguación por fricción,
m 1 = m 2 = 2 kg son las masas, w 1 = w 2 = 5 m son los anchos de cada carro, y L 1 = L 2 = 2 m son los largos de los resortes en equilibrio.

Para las condiciones iniciales:

x 1(0) = L 1, x 2(0) = L 1 + w 1 + L 2 + 6, x 1′ (0) = 0, x 2′ (0) = 0

(a) 0.8 pts Utilice el método de punto medio explícito para determinar la evolución de x 1(t) y x 2(t) en intervalo t ∈ [0, 5] min. Grafique
su solución para Δt = 0.2 s y 0.1 s. Compare ambos resultados y comente sobre la estabilidad del método.

En ambos gráficos considere:

Línea roja con etiqueta carro 1 en la leyenda para la gráfica de x 1(t)

Línea azul con etiqueta carro 2 en la leyenda para la gráfica de x 2(t)
Etiqueta en los ejes "x" e "y"

d→y →
Respuesta Transformamos el sistema EDO de 2do orden a un sistema EDO de 1er orden, de la forma = F(t, →
y ), con:
dt
Respuesta Transformamos el sistema EDO de 2do orden a un sistema EDO de 1er orden, de la forma , con:
dt

{} { }
v1
x1
k1 k2 c1

→
v1
→ →
−
m1 (x 1 )
− L1 +
m1 (x 2 )
− x1 − w1 − L2 − v
m1 1
y= , F(t, y ) =
x2 v2
v2 k2 c2
−
m2 (x 2 − x1 − w1 − L2 − ) v
m2 2

# importamos librerias
import numpy as np
import matplotlib.pyplot as plt

# Definimos parámetros de operación

m1 = m2 = 2 # masa de los carros (kg)
k1_s = k2_s = 5 # constante de rigidez de los resortes (N/m)
c1 = c2 = 0.05 # coeficientes de amortiguación (kg/s)
w1 = w2 = 5 # Ancho de los carros (m)
L1 = L2 = 2 # largo de los resortes en equilibrio (m)

# Definimos función F(t,y)

def F(t,y):
''' Función de sistema EDO 1er orden con:
- y[0] = x1, y[1] = v1
- y[2] = x2, y[3] = v2
'''
# asignamos nuevas variables para hacer el código legible con las ecuacines gobernantes
x1, v1 = y[0], y[1]
x2, v2 = y[2], y[3]

# Create a temporary array to store the derivatives

dydt = np.zeros(y.shape)

dydt[0] = v1
dydt[1] = - k1_s/m1*(x1 - L1) + k2_s/m1*(x2 - x1 - w1 - L2) - c1/m1*v1
dydt[2] = v2
dydt[3] = - k2_s/m2*(x2 - x1 - w1 - L2) - c2/m2*v2

return dydt

# Condicion incial
y0 = np.array([L1, 0, L1 + w1 + L2 + 6, 0])

# Definimos intervalo de tiempo

t0, tf = 0, 300

Resultados para Δt = 0.2 s

h = 0.2 # paso de tiempo

t = np.arange(t0,tf+h,h)

# arreglo vacío para y

y = np.zeros((len(y0), len(t)))
y[:,0] = y0

# Resolvemos por el método de punto medio explícito

for i in range(len(t) - 1):

k1 = F(t[i], y[:,i]) # predictor

k2 = F(t[i] + h/2, y[:,i] + k1*h/2) # corrector
y[:,i+1] = y[:,i] + k2*h

# Graficamos la solución
plt.plot(t,y[0,:],'-r',label = 'carro 1')
plt.plot(t,y[2,:],'-b',label = 'carro 2')

plt.title('Solución por método del punto medio explícito ($\Delta t = %.1f~\mathrm{s}$)' % h)

plt.xlabel('tiempo, $t$ (s)')
plt.ylabel('Posición, $x$ (m)')
plt.legend()
plt.show()
Resultados para Δt = 0.1 s

h = 0.1 # paso de tiempo

t = np.arange(t0,tf+h,h)

# arreglo vacío para y

y = np.zeros((len(y0), len(t)))
y[:,0] = y0

# Resolvemos por el método de punto medio implícito

for i in range(len(t) - 1):

k1 = F(t[i], y[:,i]) # predictor

k2 = F(t[i] + h/2, y[:,i] + k1*h/2) # corrector
y[:,i+1] = y[:,i] + k2*h

# Graficamos la solución
plt.plot(t,y[0,:],'-r',label = 'carro 1')
plt.plot(t,y[2,:],'-b',label = 'carro 2')

plt.title('Solución por método del punto medio explícito ($\Delta t = %.1f~\mathrm{s}$)' % h)

plt.xlabel('tiempo, $t$ (s)')
plt.ylabel('Posición, $x$ (m)')
plt.legend()
plt.show()

Analisis Al comparar ambos resultados vemos que Δt = 0.2 s genera problemas de estabilidad en la solución. El método, así, es
condicionalmente estable.

(b) 0.8 pts Repita el análisis en (a) ahora utilizando punto medio implícito. Grafique la solución siguiendo las instrucciones en (a).
Nuevamente, considere Δt = 0.2 s y 0.1 s y comente sobre la estabilidad del método.

# importación de librerías y funciones

from scipy.optimize import fsolve

Resultados para Δt = 0.2 s

# Definimos intervalo de tiempo

h = 0.2 # paso de tiempo
t = np.arange(t0,tf+h,h)

# arreglo vacío para y

y = np.zeros((len(y0), len(t)))
y[:,0] = np.array([3,1,6,0])

# Resolvemos por el método de punto medio implícito

for i in range(len(t) - 1):
# Guardamos valores conocidos
ti, ti1, yi = t[i], t[i+1], y[:,i]

# Definimos la función objetivo para la búsqueda de raices

k1 = lambda ti1, yi1: F(ti1, yi1)
k2 = lambda ti1, yi1: F(ti1 + h/2, yi1 + k1(ti1,yi1)*h/2)
f_implicit = lambda yi1: yi1 - (yi + k2(ti1,yi1)*h)

# Buscamos la raiz de forma iterativa con valor inicial y0

ysol = fsolve(f_implicit, x0 = yi)

y[:,i+1] = ysol # Guardamos el valor para la siguiente iteración

# Graficamos la solución
plt.plot(t,y[0,:],'-r',label = 'carro 1')
plt.plot(t,y[2,:],'-b',label = 'carro 2')

plt.title('Solución por método del punto medio implícito ($\Delta t = %.1f~\mathrm{s}$)' % h)

plt.xlabel('tiempo, $t$ (s)')
plt.ylabel('Posición, $x$ (m)')
plt.legend()
plt.show()

Resultados para Δt = 0.1 s

# Definimos intervalo de tiempo

h = 0.1 # paso de tiempo
t = np.arange(t0,tf+h,h)

# arreglo vacío para y

y = np.zeros((len(y0), len(t)))
y[:,0] = np.array([3,1,6,0])

# Resolvemos por el método de punto medio implícito

for i in range(len(t) - 1):
 # Guardamos valores conocidos
ti, ti1, yi = t[i], t[i+1], y[:,i]

# Definimos la función objetivo para la búsqueda de raices

k1 = lambda ti1, yi1: F(ti1, yi1)
k2 = lambda ti1, yi1: F(ti1 + h/2, yi1 + k1(ti1,yi1)*h/2)
f_implicit = lambda yi1: yi1 - (yi + k2(ti1,yi1)*h)

# Buscamos la raiz de forma iterativa con valor inicial y0

ysol = fsolve(f_implicit, x0 = yi)

y[:,i+1] = ysol # Guardamos el valor para la siguiente iteración

# Graficamos la solución
plt.plot(t,y[0,:],'-r',label = 'carro 1')
plt.plot(t,y[2,:],'-b',label = 'carro 2')

plt.title('Solución por método del punto medio implícito ($\Delta t = %.1f~\mathrm{s}$)' % h)

plt.xlabel('tiempo, $t$ (s)')
plt.ylabel('Posición, $x$ (m)')
plt.legend()
plt.show()

Análisis de resultados Vemos que el método se comporta de forma estable para ambos casos. Sin embargo, la solución es distinta en
cada caso, y difere del resultado obtenido con el método explícito.

(c) 0.8 pts Determine la solución de x 1(t) y x 2(t) mediante solve_ivp y los métodos:

Runge-Kutta 4(5) explícito.

Runge-Kutta implícito de orden 5
Método multipaso implícito

Para cada método, (1) grafique la solución siguiendo las instrucciones en (a); (2) determine el número de subintervalos n definido por el
método en el intervalo de estudio; (3) determine el valor medio de Δt definido por el método.

Finalmente, compare sus resultados y comente en términos de: eficiencia para determinar el valor en t f = 5 min, utilización de recursos
computacionales (utilice %time para determinar tiempo de CPU), y grado de resolución temporal para caracterizar los valores
instantáneos de x 1(t) y x 2(t). Justifique sus afirmaciones en base a los contenidos del curso.

from scipy.integrate import solve_ivp

Método RK45 explícito

%time sol = solve_ivp(F,t_span = (t0, tf), y0 = y0, method = 'RK45')

# Graficamos la solución
plt.plot(sol.t,sol.y[0,:],'-r',label = 'carro 1')
plt.plot(sol.t,sol.y[2,:],'-b',label = 'carro 2')

plt.title('Solución por método RK45')

plt.xlabel('tiempo, $t$ (s)')
plt.ylabel('Posición, $x$ (m)')
plt.legend()
plt.show()

CPU times: user 30.7 ms, sys: 20.6 ms, total: 51.3 ms
Wall time: 34.2 ms

print('número de subintervalos: %i' % sol.t.shape)

print('Valor Dt medio: %.3f' % np.mean(np.diff(sol.t)))

número de subintervalos: 798

Valor Dt medio: 0.376

Método Radau implícito

%time sol = solve_ivp(F,t_span = (t0, tf), y0 = y0, method = 'Radau')

# Graficamos la solución
plt.plot(sol.t,sol.y[0,:],'-r',label = 'carro 1')
plt.plot(sol.t,sol.y[2,:],'-b',label = 'carro 2')

plt.title('Solución por método RK45')

plt.xlabel('tiempo, $t$ (s)')
plt.ylabel('Posición, $x$ (m)')
plt.legend()
plt.show()

CPU times: user 187 ms, sys: 4.45 ms, total: 192 ms
Wall time: 183 ms

print('número de subintervalos: %i' % sol.t.shape)

print('Valor Dt medio: %.3f' % np.mean(np.diff(sol.t)))
número de subintervalos: 1499
Valor Dt medio: 0.200

Método BDF implícito

%time sol = solve_ivp(F,t_span = (t0, tf), y0 = y0, method = 'BDF')

# Graficamos la solución
plt.plot(sol.t,sol.y[0,:],'-r',label = 'carro 1')
plt.plot(sol.t,sol.y[2,:],'-b',label = 'carro 2')

plt.title('Solución por método RK45')

plt.xlabel('tiempo, $t$ (s)')
plt.ylabel('Posición, $x$ (m)')
plt.legend()
plt.show()

CPU times: user 200 ms, sys: 7.55 ms, total: 208 ms
Wall time: 197 ms

print('número de subintervalos: %i' % sol.t.shape)

print('Valor Dt medio: %.3f' % np.mean(np.diff(sol.t)))

número de subintervalos: 3011

Valor Dt medio: 0.100

Análisis de resultados. En resumen tenemos:

¯
Método| Δt (s) | n | CPU time| |:-:|:-:|:-:|:-:| | RK45 |0.376|798|42.1 ms| | Radau |0.200|1499|195 ms| | BDF |0.100|3011|212 ms|

¯
Eficiencia para determinar t f: El método más eficiente es RK45 con un Δt mayor y un número de subintervalos n menor que los
otros dos métodos (requiere menor cantidad de pasos para determinar t f). Este resultado también nos habla sobre la convergencia
de cada método. En el caso de RK45 , la convergencia aparenta ser mejor que en los otros dos métodos, ya que se requiere de un
Δt medio mayor.
Recursos computacionales: En este caso el método más demandante es BDF . Esto es propio de los métodos implícitos que
requieren resolver ecuaciones no lineales en cada paso. Más aún, en los métodos multipaso, tenemos que resolver sistemas de
ecuaciones con un grán número de incognitas en cada iteración, lo que justifica el mayor tiempo de CPU en comparación con
Radau , que es un método implícito de paso simple. RK45 , por otro lado, requiere menor cantidad de recursos al ser un método
explícito de paso simple.
Nivel de resolución: Notamos que el valor instantáneo oscila rápidamente. Así, una buena resolución requiere de valores altos de
¯
n y valores pequeños de Δt. En este sentido, el método con mejor resolución es BDF .

(d) 0.6 pts Asumiento sus resultados en (c) como exáctos, comente respecto a la precisión del método de punto medio en sus versiones
explícito (a) e implícito (b). En su análisis, evalúe el impacto de utilizar un Δt fijo, vs Δt variable. Considere un análisis qualitativo,
basado únicamente en los resultados observados en los gráficos.

Respuesta

En términos de precisión, a simple vista podemos notar que el método explícito se aproxima mejor a la solución exacta que el método
implícito. Esto es particularmente relevante, considerando que el método implícito es más estable, lo que podría traducirse como mejor
confiabilidad para resolver el problema. El ejemplo evidencia un punto importante en los métodos de soluciones de problemas de valor
inicial: "estabilidad no implica presición".

Por otro lado, para mejorar la precisión en ambos casos, notamos que debemos reducir el valor de Δt aún por debajo de los valores
medios utilizados por solve_ivp . Esta es una de las desventajas de utilizar Δt fijos. Si analizamos las respuestas instantáneas,
notamos que hay puntos que requieren mayor resolución que otros. El Δt variable es própio de los métodos adaptativos, permitiendo un
menor número de pasos para evaluar la evolución de la solución.

Problema 2 (3.0 puntos)

En la figura (izquierda) se muestra un disipador de calor de CPU basado aletas de clavija. Cada aleta (figura derecha), tiene una sección
circular, y un perfil cónico truncado de largo L. La distribución de temperatura a lo largo del eje axial x de la aleta está dada por la
ecuación:

Ecuación diferencial

d
dx [ ]
kA x
dT
dx
= p xh(T − T ∞) + p xσε(T 4 − T ∞)
4

Condiciones de borde

−k
dT
dx | x=0 = q 0″ , −k
dT
dx | x=L [
= h T(L) − T ∞ ]
donde q 0″ = 0.2 W / mm 2 es el flujo de calor a disipar por cada aleta, h = 200 W / m 2 K es el coeficiente convectivo,
σ = 5.67037 × 10 − 8 W / m 2 K 4 es la constante de Steffan-Boltzmann, ε = 0.9 es la emisividad de la aleta, k = 237 W / m K es la
conductividad térmica de la aleta, T_\infty = 25°C es la temperatura ambiente; A_x = \pi D_x^2/4 y p_x = \pi D_x son, respectivamente, el
área transversal y el perímetro de la aleta, con D_x = D_0 + (D_L - D_0)\frac{x}{L}. Las dimensiones de la aleta son: D_0 =
3~\mathrm{mm}, D_L = 1~\mathrm{mm} y L = 2~\mathrm{cm}.

(a) 1.0 pts Determine la distribución de temperaturas en la aleta mediante el método del disparo. En su solución, indique el
procedimiento para determinar el intervalo de búsqueda de la solución (similar a lo visto en clases). Finalmente, grafique la distribución
de temperatura considerando:
 Eje y con Temperatura en grados Celcius
Eje x con posición de la aleta en mm.

Respuesta Convertimos el problema a una EDO con valor inicial de la forma: \frac{d\vec{y}}{dt} = \vec{F}(t,\vec{y}), donde:

\begin{equation*} \vec{y} = \left\{\begin{matrix} T \\ Q \end{matrix}\right\}, \quad \vec{F}(t,\vec{y}) = \left\{\begin{matrix} - \frac{Q}{kA_x} \\ -

p_xh(T - T_\infty) - p_x\sigma \varepsilon(T^4 - T_\infty^4) \end{matrix}\right\} \end{equation*}
notar que en este sistema consideramos Q = - kA_x\frac{dT}{dx}

y las condiciones iniciales son: \begin{equation*} \vec{y}(0) = \left{\begin{matrix} T(0) \ Q(0)

\end{matrix}\right}
\left{\begin{matrix} T_0 \\ q_0''A_0 \end{matrix}\right} \end{equation*}

variamos T_0 hasta que se cumpla la condición: Q(L) = hA_L\left[T(L) - T_\infty\right]

# Importamos las librerías requeridas

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp

# Definimos constantes del problema

q0 = 2.0E+5 # Flujo de calor por aleta (W/m^2)
h = 200 # Coeficiente convectivo (W/m2-K)
S = 5.67037E-8 # Constante de Steffan-Boltzmann (W/m^2-K^4)
eps = 0.9 # Emisividad de la aleta
k = 237 # Conductividad térmica de la aleta (W/m-K)
Too = 25+273 # Temperatura ambiente (K)
D0, DL = 3E-3, 1E-3 # Diámetros en los extremos de la aleta (m)
L = 20E-3 # Largo de la aleta (m)
D = lambda x: D0 + (DL - D0)*x/L # Diámetro de la aleta según x (m)
A = lambda x: np.pi*D(x)**2/4 # Sección transversal de la aleta según x (m)
p = lambda x: np.pi*D(x) # Perímetro de la aleta según x (m)

# Ecuación gobernante dy/dt = F(t,y)

def F(t,y):
T, Q = y[0], y[1]
dydt = np.zeros(y.shape)

dydt[0] = - Q/(k*A(t))
dydt[1] = - p(t)*h*(T - Too) - p(t)*S*eps*(T**4 - Too**4)
return dydt

# Probamos dos valores para Ta en condición inicial

for Ta in [400, 300]:
sol = solve_ivp(F, t_span = [0,L], y0 = [Ta, q0*A(0)])
T = sol.y[0]
Q = sol.y[1]

print('Condición de borde para T0 = %.1fK: %.5f' % (Ta, Q[-1] - h*A(L)*(T[-1] - Too)))

Condición de borde para T0 = 400.0K: -1.25718

Condición de borde para T0 = 300.0K: 1.70837

from scipy.optimize import root_scalar

# Declaramos la función objetivo para encontrar T(x = L) - Tb, dado "za"

def fobjective(Ta):
sol = solve_ivp(F,t_span = [0,L], y0 = [Ta, q0*A(0)]) # solución de la odo con VI
T = sol.y[0] # distribución de temperaturas en la barra
Q = sol.y[1] # distribución de calor en la barra
return Q[-1] - h*A(L)*(T[-1] - Too) # retornamos T(x = L) - Tb

# Buscamos la raiz de fobjective(Ta)

Ta_sol = root_scalar(fobjective, bracket = [400, 300]).root
print('El valor de qa es: %.1f K' % Ta_sol)

El valor de qa es: 358.1 K

fig, ax = plt.subplots(figsize=(5,3))

x_range = np.linspace(0,L,100) # rango de valores para evaluar T(x)

sol = solve_ivp(F,t_span = [0,L], t_eval = x_range, y0 = [Ta_sol, q0*A(0)])

ax.plot(sol.t*1E3,sol.y[0] - 273,'r')

ax.set_xlabel('Posicion en la aleta, $x$ (mm)')

ax.set_ylabel('Temperatura en la aleta, $T$ (°C)')
plt.show()
(b) 1.0 pts Determine la distribución de temperaturas en la aleta mediante el método de diferencias finitas. Utilice esquemas de orden
O(h^2) para los nodos centrales y condiciones de borde, e implemente su solución en un código para un número de nodos, N,
igualmente espaciados. Finalmente, grafique la distribución de temperatura para N = 20 considerando:

Eje y con Temperatura en grados Celcius

Eje x con posición de la aleta en mm.

Respuesta Para discretizar, primero desarrollamos la ecuación diferencial de los nodos centrales:

\begin{equation*} kA_x\frac{d^2T}{dx^2} + kA_x'\frac{dT}{dx} = p_xh(T - T_\infty) + p_x\sigma \varepsilon(T^4 - T_\infty^4)

\end{equation*}
donde A_x' = \frac{dA_x}{dx} = \frac{dA_x}{dD_x}\frac{dD_x}{dx} = \frac{\pi D_x}{2}\frac{D_L - D_0}{L}.

Luego, discretizamos utilizando esquemas de diferencias centrales de orden O(h^2):

\begin{equation*} kA_x(x_i)\frac{T_{i+1}- 2T_{i} + T_{i-1}}{\Delta x^2} + kA_x'(x_i)\frac{T_{i+1} - T_{i-1}}{2\Delta x} = p_x(x_i)h(T_i -

T_\infty) + p_x(x_i)\sigma \varepsilon(T_i^4 - T_\infty^4) \end{equation*}

Reordenando los términos, tenemos: \begin{equation*} aT_{i+1}

bT{i} + c T{i}^4
dT_{i-1}
f = 0 \end{equation*}

donde: \begin{align*} a &= 2kA_x(x_i) + kA_x'(x_i)\Delta x\\ b &= - \left[4kA_x(x_i) + 2\left(\Delta x\right)^2p_x(x_i)h\right]\\ c &= -
2\left(\Delta x\right)^2p_x(x_i)\sigma\varepsilon \\ d &= 2kA_x(x_i) - kA_x'(x_i)\Delta x\\ f &= \left[2\left(\Delta
x\right)^2p_x(x_i)h\right]T_{\infty} + 2\left(\Delta x\right)^2p_x(x_i)\sigma\varepsilon T_{\infty}^4 \end{align*}

Para las conciondes de borde: \begin{eqnarray*} -k\frac{dT}{dx}\Bigg|_{x = 0} &=& q0'',\quad - k\frac{dT}{dx}\Bigg|{x = L} &=& h\left[T(L) -
T\infty\right] \ -k\frac{- T{2} + 4T{1}- 3T{0}}{2\Delta x} &=& q0'',\quad -k\frac{3T{n} - 4T{n-1} + T{n-2}}{2\Delta x} &=& h\left[Tn -
T\infty\right] \

T{2} + 4T{1}- 3T_{0} + 2\Delta x \frac{q0}{k}''&=& 0,\quad \left(3 + 2\Delta x\frac{ h}{k}\right)T{n} - 4T{n-1} + T{n-2} - 2\Delta x\frac{h}
{k}T_\infty&=& 0 \end{eqnarray*}

Con esto tenemos un sistemas de ecuaciones no lineal, que implementamos en python para encontrar la distribución de
temperaturas:

# Importamos librerías requeridas

from numpy.linalg import solve

# Definimos función dA/dx

dAdx = lambda x: np.pi*D(x)/2*(DL - D0)/L

# Código genérico para barra 1D con diferencias finitas

N = 20 # número de nodos
dx = L/(N - 1) # espaciamiento entre nodos
n = N - 1 # nodo final
x = np.linspace(0,L,N) # Posición de los nodos

def fsystem(T):

lin_eq = np.zeros(N)
for i in range(N):

# condiciones de borde
#------------------------------------------------------------------
if i == 0: # Condicion de borde x = 0
lin_eq[0] = - T[2] + 4*T[1] - 3*T[0] + 2*dx*q0/k
 continue
if i == n: # convección en el extremo derecho
lin_eq[n] = (3 + 2*dx*h/k)*T[n] - 4*T[n-1] + T[n-2] - 2*dx*h/k*Too
continue

# nodos interiores
#------------------------------------------------------------------
# Valor de constantes
a = 2*k*A(x[i]) + k*dAdx(x[i])*dx
b = - (4*k*A(x[i]) + 2*dx**2*p(x[i])*h)
c = - 2*dx**2*p(x[i])*S*eps
d = 2*k*A(x[i]) - k*dAdx(x[i])*dx
f = (2*dx**2*p(x[i])*h)*Too + 2*dx**2*p(x[i])*S*eps*Too**4

# Ecuación para nodos interiores

lin_eq[i] = a*T[i+1] + b*T[i] + c*T[i]**4 + d*T[i-1] + f

return lin_eq

Resolvemos el sistema

from scipy.optimize import fsolve

# condicionamos la variable inicial para la iteración

Tinc = np.ones(N)*Too

# Solución del sistema no lineal

T = fsolve(fsystem, x0 = Tinc)

Graficamos nuetra solución

fig, ax = plt.subplots(figsize=(5,3))
ax.plot(x*1E3,T - 273,':xr')

ax.set_xlabel('Posicion de la barra, $x$ (m)')

ax.set_ylabel('Temperatura en la barra, $T$ (°C)')
plt.show()

(c) 1.0 pts Determine la distribución de temperaturas en la aleta mediante colocación con solve_bvp . Grafique la distribución de
temperatura, considerando:

Eje y con Temperatura en grados Celcius

Eje x con posición de la aleta en mm.

En un gráfico alineado a la derecha, grafique la tasa de pérdida de calor lineal:

\begin{equation*} \frac{dQ}{dx} = \frac{d}{dx}\left(- kA_x\frac{dT}{dx}\right), \end{equation*}

en unidades \mathrm{W/mm}. En su gráfico considere:

Eje y con \frac{dQ}{dx} en \mathrm{W/mm}.

Eje x con posición de la aleta en mm.

Nota: Para mostrar dos gráficos alineados en una fila utilizar el comando matplotlib.pyplot.subplots(1,2) . Por
ejemplo, para mostrar dos gráficos y vs x , y z vs x :

import matplotlib.pyplot as plt

fig, ax = plt.subplots(1,2) # número de ejes en la figura (1 fila, 2 columnas)

fig.set_size_inches(12, 4) # tamaño de la figura
plt.rcParams['font.size'] = '10' # tamaño de fuente

ax[0].plot(x, y) # gráfica a la izquierda

ax[1].plot(x, z) # gráfica a la derecha
 Convertimos a un sistema \frac{d\vec{y}}{dx} = \vec{F}(x,\vec{y}), donde: \begin{equation*} \vec{y} = \left{\begin{matrix} T \\ Q
\end{matrix}\right}, \quad \vec{F}(x,\vec{y}) = \left{\begin{matrix}

\frac{Q}{kA_x} \ - pxh(T - T\infty) - px\sigma \varepsilon(T^4 - T\infty^4) \end{matrix}\right} \end{equation*}

notar que en este sistema consideramos Q = - kA_x\frac{dT}{dx}

y las condiciones de borde son: \begin{equation*} Q(0) = q_0''A_0,\quad Q(L) = hA_L\left[T(L) - T_\infty\right] \end{equation*}

from scipy.integrate import solve_bvp

def F(x,y):
T, Q = y[0], y[1]
dydx = np.zeros(y.shape)

dydx[0] = - Q/(k*A(x))
dydx[1] = - p(x)*h*(T - Too) - p(x)*S*eps*(T**4 - Too**4)
return dydx

def bc(ya,yb):
Ta, Qa = ya[0], ya[1]
Tb, Qb = yb[0], yb[1]
return [Qa - q0*A(0),
Qb - h*A(L)*(Tb - Too)]

N = 10 # Número de nodos de colocación

x_init = np.linspace(0,L,N) # nodos de colocación
y_init = np.zeros((2, len(x_init))) # Valores iniciales en nodos de colocación

# Solución de la EDO pvf

out = solve_bvp(F, bc, x_init, y_init)

# Graficamos la solución
fig, ax = plt.subplots(1,2)
fig.set_size_inches(11, 3)

x = np.linspace(0,L,100)*1E3
T = out.sol(x*1E-3)[0]
dQdx = out.sol(x*1E-3,1)[1]

ax[0].plot(x,T - 273,'-r')
ax[1].plot(x, - dQdx/1E3,'-b')

ax[0].set_xlabel('Posición, $x$ (mm)')

ax[0].set_ylabel('Temperatura, $T$, (°C)')
ax[1].set_xlabel('Posición, $x$ (mm)')
ax[1].set_ylabel('$dQ/dx$, ($\mathrm{W/mm}$)')
plt.show()

Loading [MathJax]/jax/element/mml/optable/Latin1Supplement.js