Proyectos Prácticos: Desarrollo de proyectos utilizando pensamiento computacional
Proyectos Prácticos: Desarrollo de proyectos utilizando pensamiento computacional
Proyectos Prácticos: Desarrollo de proyectos utilizando
pensamiento computacional
El Pensamiento Computacional es una forma sistemática de abordar problemas que se puede aplicar a cualquier disciplina, y Python es una excelente herramienta para implementar soluciones computacionales. Aquí te describo una guía paso a paso:Modelar una reacción química en un reactor para optimizar la producción.
Fase 1: Descomposición del Problema
- Identificación del Problema : Supongamos que queremos modelar una reacción química en un reactor para optimizar la producción.
- División en Subproblemas : Descompón el problema general en subproblemas más pequeños. Por ejemplo:
- Calcular las mediciones iniciales
- Aplicar la cinética de la reacción.
- Modelar el flujo de calor
Fase 2: Reconocimiento de Patrones
- Identificar Variables : En Ingeniería Química, variables como la concentración, la temperatura y la presión son comunes.
- Ecuaciones : Las ecuaciones de balance de masa y energía son patrones comunes.
Fase 3: Abstracción
- Modelo Matemático : Desarrolla un modelo matemático que describe la reacción y su dinámica.
Fase 4: Diseño del Algoritmo
- Selección de Métodos Numéricos : Decida qué métodos numéricos son apropiados para resolver las ecuaciones. Por ejemplo, métodos de Runge-Kutta para ecuaciones diferenciales.
Implementación en Python
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint
# Definir la función que contiene las ecuaciones
def modelo_reactor(variables, t):
A, B = variables
k1 = 0.1 # constante de velocidad de reacción
dA_dt = -k1 * A
dB_dt = k1 * A
return [dA_dt, dB_dt]
# Condiciones iniciales
A0 = 1.0
B0 = 0.0
iniciales = [A0, B0]
# Tiempo de simulación
tiempo = np.linspace(0, 10, 100)
# Resolver ecuaciones
resultados = odeint(modelo_reactor, iniciales, tiempo)
# Graficar resultados
plt.figure()
plt.plot(tiempo, resultados[:, 0], label='[A]')
plt.plot(tiempo, resultados[:, 1], label='[B]')
plt.legend()
plt.xlabel('Tiempo')
plt.ylabel('Concentración')
plt.title('Modelo de reactor')
plt.show()
Este es un ejemplo muy simplificado, pero sirve para ilustrar el proceso de resolución de problemas usando Pensamiento Computacional y Python en el ámbito de la Ingeniería Química. A partir de aquí, podría agregar más complejidad, como múltiples reacciones, catalizadores o incluso sistemas de control para optimizar el proceso.
Simular el comportamiento de una columna de destilación binaria
Fase 1: Descomposición del Problema
- Identificación del Problema : Modelar el comportamiento de una columna de destilación para separar dos componentes.
- División en Subproblemas :
- Modelar el equilibrio líquido-vapor de los componentes.
- Simular el equilibrio de masa y energía en cada plato de la columna.
- Evaluar la eficiencia de la separación.
- Modelar el equilibrio líquido-vapor de los componentes.
- Simular el equilibrio de masa y energía en cada plato de la columna.
- Evaluar la eficiencia de la separación.
Fase 2: Reconocimiento de Patrones
- Clave de variables : Concentraciones de los componentes, temperatura, presión.
- Ecuaciones y Principios : Ley de Raoult para equilibrio líquido-vapor, equilibrios de materia y energía.
Fase 3: Abstracción
- Modelo Matemático : Utilizar modelos de equilibrio y balanzas de masa y energía para describir el sistema.
Fase 4: Diseño del Algoritmo
- Selección de Métodos y Estructuras : Utilizar un enfoque iterativo para calcular la composición en cada plato de la columna.
Implementación en Python
import numpy as np
import matplotlib.pyplot as plt
# Función para el equilibrio líquido-vapor (Ley de Raoult simplificada)
def equilibrio(x, P, A, B):
# Presiones de vapor (Antoine Equation)
P_A = 10 ** (A - B / (x + 273.15))
P_B = 10 ** (A - B / ((1 - x) + 273.15))
y = x * P_A / P
return y
# Parámetros de la columna
num_platos = 10
P = 1.013 # Presión atmosférica en bar
A, B = 8.07131, 1730.63 # Parámetros de Antoine para el agua
# Composición inicial
x_feed = 0.4 # Composición de alimentación
platos_x = np.zeros(num_platos)
platos_y = np.zeros(num_platos)
platos_x[0] = x_feed
# Simulación de la columna
for i in range(1, num_platos):
platos_y[i - 1] = equilibrio(platos_x[i - 1], P, A, B)
platos_x[i] = platos_y[i - 1] # Este modelo asume equilibrio total
# Graficar resultados
plt.figure()
plt.plot(platos_x, label='Líquido (x)')
plt.plot(platos_y, label='Vapor (y)')
plt.xlabel('Número de Plato')
plt.ylabel('Composición')
plt.title('Composición en cada plato de una columna de destilación')
plt.legend()
plt.show()
Análisis y modelado de una reacción química simple, utilizando datos experimentales para determinar la constante de velocidad de la reacción.
Paso 1: Definición del Problema
Imaginemos que queremos determinar la constante de velocidad de una reacción química de primer orden a partir de datos experimentales.
Paso 2: Pensamiento Computacional
Descomposición : Dividimos el problema en partes manejables:
- Leer datos experimentales.
- Graficar los datos para visualizarlos.
- Elegir un modelo cinematográfico adecuado.
- Ajustar el modelo a los datos para encontrar la constante de velocidad.
Reconocimiento de Patrones : Identificamos que se trata de una reacción de primer orden, lo que implica una relación logarítmica entre la concentración y el tiempo.
Abstracción : Nos concentramos en los aspectos esenciales: los datos de concentración y tiempo, y la ley de velocidad para una reacción de primer orden.
Algoritmos : Definimos los pasos para resolver el problema:
- Importar y leer datos.
- Aplique un algoritmo de ajuste no lineal.
- Graficar los resultados para comparar los datos experimentales con el modelo.
Paso 3: Implementación en Python
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
# Supongamos que estos son nuestros datos experimentales
tiempo = np.array([0, 1, 2, 3, 4, 5]) # tiempo en minutos
concentracion = np.array([1.0, 0.8, 0.6, 0.5, 0.3, 0.2]) # concentración en mol/L
# Modelo de reacción de primer orden
def modelo_primer_orden(t, k):
return concentracion[0] * np.exp(-k * t)
# Ajuste de los datos al modelo
parametros_optimizados, covarianza = curve_fit(modelo_primer_orden, tiempo, concentracion)
# Extracción de la constante de velocidad
k = parametros_optimizados[0]
# Crear datos del modelo para la gráfica
t_modelo = np.linspace(0, 5, 100)
concentracion_modelo = modelo_primer_orden(t_modelo, k)
# Gráfica de los datos
plt.figure()
plt.scatter(tiempo, concentracion, label='Datos Experimentales')
plt.plot(t_modelo, concentracion_modelo, label='Modelo Ajustado', color='red')
plt.xlabel('Tiempo (minutos)')
plt.ylabel('Concentración (mol/L)')
plt.title('Ajuste de Datos a Modelo de Primer Orden')
plt.legend()
plt.show()
Este código realiza lo siguiente:
- Definir un conjunto de datos experimentales de tiempo y concentración.
- Implementa una función que representa el modelo de reacción de primer orden.
- Ajusta este modelo a los datos experimentales usando
curve_fit. - Gráfica los resultados para mostrar cómo el modelo se ajusta a los datos experimentales.
Este proceso ilustra cómo aplicar el Pensamiento Computacional y Python para resolver un problema típico en Ingeniería Química.