Reading Time: 12 minutes

Comida clave

  • Las ideas de proyectos curados cubren los niveles principiantes, intermedios y avanzados, con un enfoque en la simulación y la ciencia computacional.
  • Los niveles de dificultad reflejan los requisitos previos, la complejidad de las matemáticas y la inversión de tiempo esperada.
  • Se incluyen plantillas de código para cada proyecto para que los estudiantes puedan comenzar a construir rápidamente.
  • Los resultados del aprendizaje muestran lo que enseña cada proyecto.
  • Una hoja de ruta de habilidades para proyectos ayuda a los estudiantes a elegir un proyecto basado en su conocimiento actual.

Los proyectos estudiantiles en ciencia computacional y simulación son donde la teoría finalmente se encuentra con el código. Puede aprender métodos de volumen finito, ecuaciones diferenciales parciales y leyes de conservación en las conferencias, pero las ecuaciones en una pizarra blanca no enseñan cómo se siente escribir un solucionador desde cero.

Si desea comprender cómo se traducen los métodos numéricos en simulaciones de trabajo, elija un proyecto y comience a construir.

Esta guía selecciona ideas prácticas de proyectos inspiradas en cursos universitarios de física computacional, proyectos científicos de código abierto y repositorios de pares. Cada proyecto usa Python y construye hacia algo que los estudiantes pueden incluir en una cartera.

Explicar los niveles de dificultad del proyecto

Antes de elegir un proyecto, ayuda a entender lo que significa cada nivel en términos de esfuerzo.

Nivel requisitos previos tiempo esperado Qué harás
Principiante Conceptos básicos de Python, numpy, matplotlib 2-4 semanas Resuelva odas o PDE simples con métodos explícitos y visualice resultados
Intermedio Análisis numérico, álgebra lineal, ODE/PDE Antecedentes 4–8 semanas Implementar solucionadores, manejar condiciones de contorno y comparar precisión
Avanzado Métodos numéricos avanzados, computación paralela o antecedentes de física especializada 8-16 semanas Construya simulaciones multifísicas, optimice el rendimiento o compare con los resultados de la literatura

La tabla no es una clasificación. Es una herramienta de emparejamiento. Elija un nivel que coincida con su preparación actual, luego muévase hacia arriba una vez que se sienta cómodo.

Hoja de ruta de habilidades a proyectos

La hoja de ruta a continuación muestra qué conceptos matemáticos y de programación se asignan a qué proyectos.

┌─────────────────┬─────────────────────────────────────────────────────────┐
│ Skill / Concept │ Projects That Use It                                    │
├─────────────────┼─────────────────────────────────────────────────────────┤
│ Python basics   │ Heat equation solver, SIR epidemic model, Lennard-Jones │
│ NumPy arrays    │ Wave propagation, diffusion on grid                     │
│ ODE solvers     │ SIR model, projectile with drag, Lotka-Volterra         │
│ PDE basics      │ Heat equation, wave equation, diffusion                 │
│ Linear algebra  │ Jacobi iteration, eigenvalue problems, Krylov methods   │
│ Monte Carlo     │ Ising model, radioactive decay, option pricing          │
│ FFT / spectral  │ Wave propagation, turbulence, spectral methods          │
│ Parallelism     │ MPI diffusion solver, GPU molecular dynamics            │
│ Phase-field     │ Solidification, fracture mechanics, grain boundary      │
└─────────────────┴─────────────────────────────────────────────────────────┘

Proyectos principiantes

Estos proyectos introducen conceptos de simulación centrales sin abrumar las matemáticas o la configuración compleja. Están diseñados para funcionar en una computadora portátil sin hardware especial.

1. Solucionador de ecuaciones de calor en una cuadrícula

Dificultad: Principiante
Tiempo: 2-3 semanas

Lo que va a simular: el calor se extiende a través de una placa de metal, una varilla o una habitación. La ecuación de calor 1D o 2D es un primer proyecto clásico en PDES numéricos porque es conceptualmente simple y enseña los principales conceptos utilizados más adelante.

Modelo de matemáticas:

∂T/∂t = α ∇²T

Aquí, α es difusividad térmica, T es temperatura y ∇² es el laplaciano espacial.

Pila de Python: NumPy, Matplotlib

Plantilla de código:

import numpy as np
import matplotlib.pyplot as plt

def heat_solver(alpha, L, dt, steps):
    """Solve the 1D heat equation with explicit finite differences."""
    dx = L / 50
    x = np.linspace(0, L, 51)
    T = np.zeros_like(x)
    T[20:31] = 1.0  # initial hot strip
    
    history = [T.copy()]
    
    for step in range(steps):
        T_new = T.copy()
        for i in range(1, len(T) - 1):
            T_new[i] = T[i] + dt * alpha / dx**2 * (
                T[i + 1] - 2 * T[i] + T[i - 1]
            )
        T = T_new
        history.append(T.copy())
    
    return x, np.array(history)

x, history = heat_solver(alpha=1.0, L=1.0, dt=0.0001, steps=1000)

plt.imshow(history, aspect="auto", extent=[0, 1, 1000, 0])
plt.xlabel("Position")
plt.ylabel("Time step")
plt.colorbar(label="Temperature")
plt.show()

Resultados de aprendizaje:

  • Comprender la estabilidad explícita e implícita.
  • Implementación de condiciones de contorno.
  • Visualización de campos difusivos.
  • Razonamiento básico de estabilidad de estilo CFL.

Por qué este proyecto: La ecuación del calor es el «hola mundo» de la simulación. Cada proyecto posterior que involucra difusión, ondas o modelado de campo de fase se basa en patrones numéricos similares.

Extensiones sugeridas:

  • Cambie a un esquema completamente implícito o manivela-Nicolson y compare la estabilidad.
  • Agregue un término fuente, como un elemento calefactor.
  • Exportar resultados a CSV para su análisis.

2. Modelo de propagación epidémica SIR

Dificultad: Principiante
Tiempo: 2-3 semanas

Lo que vas a simular: El modelo compartimental clásico de diseminación de la enfermedad: susceptible, infecciosa y recuperada. Este modelo captura curvas epidémicas, inmunidad de rebaño y el número básico de reproducción sin una cuadrícula espacial.

Modelo de matemáticas:

dS/dt = -βSI/N
dI/dt = βSI/N - γI
dR/dt = γI

Aquí, β es la tasa de transmisión, γ es la tasa de recuperación y N = S + I + R es la población.

Pila de Python: NumPy, SciPy, Matplotlib

Plantilla de código:

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

def sir_model(y, t, beta, gamma):
    S, I, R = y
    N = S + I + R
    dS = -beta * S * I / N
    dI = beta * S * I / N - gamma * I
    dR = gamma * I
    return [dS, dI, dR]

beta, gamma = 0.5, 0.1
y0 = [990, 10, 0]
t = np.linspace(0, 100, 100)

solution = odeint(sir_model, y0, t, args=(beta, gamma))

plt.plot(t, solution)
plt.legend(["Susceptible", "Infectious", "Recovered"])
plt.xlabel("Time")
plt.ylabel("Population")
plt.show()

Resultados de aprendizaje:

  • Resolución de sistemas de ODE.
  • Entendiendo R₀ = β/γ.
  • Interpretación de picos epidémicos y comportamiento de tamaño final.
  • Trazar el comportamiento de plano de fase como la población infecciosa versus susceptible.

Por qué este proyecto: tiene relevancia en el mundo real con una complejidad mínima. El modelo es lo suficientemente simple como para entenderlo pero lo suficientemente rico como para respaldar experimentos significativos.

Extensiones sugeridas:

  • Agregue estructura de edad con múltiples compartimentos.
  • Incluya la vacunación como un parámetro dependiente del tiempo.
  • Compare Euler, RK4 y solucionadores de oda Scipy.

3. Ecuación de onda en una cadena

Dificultad: Principiante
Tiempo: 3-4 semanas

Lo que va a simular: una cuerda vibrante, una membrana de tambor o una onda sonora. La ecuación de onda introduce la propagación, la reflexión y las ondas estacionarias.

Modelo de matemáticas:

∂²u/∂t² = c² ∇²u

Las condiciones de contorno pueden ser fijas, libres o mixtas.

Pila de Python: NumPy, Matplotlib

Plantilla de código:

import numpy as np
import matplotlib.pyplot as plt

c, L = 1.0, 1.0
dx = L / 100
x = np.linspace(0, L, 101)
dt = 0.001
steps = 5000

u = np.zeros((101, steps))
u[:, 0] = np.sin(np.pi * x / L)

# First step approximation
u[:, 1] = u[:, 0]

for n in range(1, steps - 1):
    for i in range(1, 100):
        u[i, n + 1] = (
            2 * u[i, n]
            - u[i, n - 1]
            + (c * dt / dx)**2 * (u[i + 1, n] - 2 * u[i, n] + u[i - 1, n])
        )

plt.plot(x, u[:, 1000])
plt.xlabel("Position")
plt.ylabel("Displacement")
plt.show()

Resultados de aprendizaje:

  • Diferencia finita Pasos de tiempo para PDES de segundo orden.
  • Análisis de condición y estabilidad de CFL.
  • Reflejo de onda y ondas estacionarias.
  • Visualización con animación o instantáneas de tiempo.

Extensiones sugeridas:

  • Pruebe diferentes condiciones iniciales, como un paquete de onda gaussiana.
  • agregar límites reflectantes o absorbentes.
  • Compare la solución numérica con una solución analítica.

Proyectos intermedios

Estos proyectos requieren una formación más sólida en análisis numérico, álgebra lineal o física. El código involucra solucionadores iterativos, métodos adaptativos o modelos más complejos.

4. Iteración Jacobi y Krylov para sistemas lineales

Dificultad: Intermedio
Tiempo: 4–6 semanas

Lo que va a simular: soluciones iterativas a Ax = b usando jacobi, gauss-seidel y gradiente conjugado. Esta es la columna vertebral de muchos solucionadores de PDE.

Modelo de matemáticas:

Ax = b

Aquí, A suele ser escaso, y para muchos problemas de estilo de difusión es simétrico positivo.

Pila de Python: NumPy, SciPy, Matplotlib

Plantilla de código:

import numpy as np
import scipy.sparse as sp
import scipy.sparse.linalg as spla

def create_1d_laplacian_matrix(n, dx):
    """Create a 1D Laplacian matrix."""
    main = 2.0 * np.ones(n)
    off = -1.0 * np.ones(n - 1)
    return sp.diags([off, main, off], [-1, 0, 1], format="csr") / dx**2

n = 100
dx = 0.01
A = create_1d_laplacian_matrix(n, dx)
b = np.ones(n)

# Jacobi iteration
x_jac = np.zeros(n)
D = A.diagonal()

for iteration in range(100):
    r = b - A @ x_jac
    x_jac = x_jac + r / D

# Compare with direct sparse solve
x_direct = spla.spsolve(A, b)
error = np.linalg.norm(x_direct - x_jac)

print(f"Jacobi error after 100 iterations: {error:.3e}")

Resultados de aprendizaje:

  • Representación y operaciones de matriz escasa.
  • Análisis de convergencia de solucionador iterativo.
  • Comparación de Jacobi, Gauss-Seidel y gradiente conjugado.
  • Conceptos básicos de preacondicionamiento.

Por qué este proyecto: cada solucionador de PDE utiliza sistemas lineales escasos internamente. Comprender los métodos iterativos a nivel de código ayuda a desmitificar las herramientas como Fipy, Fenics y OpenFoam.

Extensiones sugeridas:

  • Agregue un preacondicionador diagonal.
  • Compare las tasas de convergencia en cuadrículas 2D y 3D.
  • Implementar un ciclo simple multigrid.

5. Dinámica molecular con potencial de Lennard-Jones

Dificultad: Intermedio
Tiempo: 4–8 semanas

Lo que simularás: un gas o líquido de partículas que interactúan a través del potencial de Lennard-Jones. Este proyecto demuestra el ciclo completo desde el modelo de física hasta la integración numérica, el análisis de datos y la visualización.

Modelo de matemáticas:

V(r) = 4ε[(σ/r)¹² - (σ/r)⁶]
F = -∇V(r)

Los métodos de integración típicos incluyen esquemas de velocidad verlet o salto.

Pila de Python: NumPy, Matplotlib, h5py

Plantilla de código:

import numpy as np

def lj_force(pos_i, pos_j, sigma=1.0, epsilon=1.0):
    """Compute Lennard-Jones force between two particles."""
    r_vec = pos_j - pos_i
    r = np.linalg.norm(r_vec)
    
    if r == 0:
        return np.zeros_like(r_vec)
    
    inv_r = sigma / r
    force_mag = 24 * epsilon * (2 * inv_r**12 - inv_r**6) / r
    return force_mag * (r_vec / r)

def compute_forces(positions):
    n = len(positions)
    forces = np.zeros_like(positions)
    
    for i in range(n):
        for j in range(i + 1, n):
            f = lj_force(positions[i], positions[j])
            forces[i] += f
            forces[j] -= f
    
    return forces

Resultados de aprendizaje:

  • Integración numérica basada en partículas.
  • condiciones de contorno periódicas.
  • Seguimiento de la conservación de energía.
  • Funciones de distribución radial.

Por qué este proyecto: Molecular Dynamics es una puerta de entrada a la computación científica de alto rendimiento. Una vez que comprenda las partículas de Lennard-Jones, puede pasar a potenciales complejos, granulado grueso o MD acelerado por GPU.

Extensiones sugeridas:

  • Cambie a la aceleración de GPU con cupy o numba.
  • Estudia las transiciones de fase variando la temperatura.
  • Calcule la conductividad térmica con relaciones verde-kubo.

6. Modelo Ising para el magnetismo 2D

Dificultad: Intermedio
Tiempo: 4–6 semanas

Lo que vas a simular: El modelo Ising es uno de los modelos más simples de magnetismo y uno de los problemas más estudiados en física estadística. Muestra cómo las reglas locales pueden producir transiciones de fase macroscópicas.

Modelo de matemáticas:

H = -J Σᵢⱼ sᵢsⱼ - h Σᵢ sᵢ
P(ΔE) = exp(-ΔE/kT)

Pila de Python: NumPy, Matplotlib, SciPy

Plantilla de código:

import numpy as np

def metropolis_step(grid, T):
    """Single Metropolis sweep on a 2D Ising grid."""
    L = grid.shape[0]
    
    for i in range(L):
        for j in range(L):
            site = grid[i, j]
            neighbors = (
                grid[(i - 1) % L, j]
                + grid[(i + 1) % L, j]
                + grid[i, (j - 1) % L]
                + grid[i, (j + 1) % L]
            )
            dE = 2 * site * neighbors
            
            if dE < 0 or np.random.rand() < np.exp(-dE / T):
                grid[i, j] = -site
    
    return grid

Resultados de aprendizaje:

  • Métodos de Monte Carlo y el algoritmo de Metropolis.
  • Transiciones de fase y fenómenos críticos.
  • Heurísticas de minimización de energía.
  • Visualización de patrones emergentes.

Por qué este proyecto: El modelo Ising conecta la física estadística, los métodos computacionales y el aprendizaje automático. También tiene un comportamiento de referencia conocido, lo que hace posible la validación.

Extensiones sugeridas:

  • Calcule la capacidad calorífica y la susceptibilidad cerca de la temperatura crítica.
  • Estudia diferentes geometrías de celosía.
  • Implemente el algoritmo de clúster Wolff o Swendsen-Wang.

Proyectos avanzados

Estos proyectos requieren de antecedentes de métodos numéricos más sólidos, experiencia informática paralela o conocimientos de física especializados. Son adecuados para trabajos a nivel de tesis o proyectos finales.

7. Solucionador de difusión a base de FIPY

Dificultad: Avanzado
Tiempo: 8-12 semanas

Lo que vas a simular: un problema de difusión realista usando Fipy. Esto conecta los conceptos de PDE y la discretización del volumen finito con el software científico de calidad de producción.

Modelo de matemáticas:

∂c/∂t = ∇·(D∇c) + S

Esta es una ecuación de difusión con términos de origen y condiciones de contorno como Dirichlet, Neumann o condiciones de Robin.

Pila de Python: FiPy, NumPy, Matplotlib

Plantilla de código:

from fipy import Grid2D, CellVariable, DiffusionTerm

mesh = Grid2D(nx=50, ny=50, dx=0.1, dy=0.1)

c = CellVariable(mesh=mesh, name="concentration", value=0.0)
c.constrain(1.0, mesh.facesLeft)

eq = DiffusionTerm(coeff=1.0) == 0

# Solve to steady state
eq.solve(var=c)

Resultados de aprendizaje:

  • Discretización de volumen finito con Fipy.
  • Manejo de condiciones de contorno de Dirichlet, Neumann y Robin.
  • Estudios de calidad y convergencia de malla.
  • Conexión de soluciones analíticas a resultados numéricos.

Por qué este proyecto: Si desea trabajar profesionalmente en la ciencia computacional, saber cómo usar y extender un código de volumen finito como Fipy es valioso. Este proyecto combina la configuración de malla, la formulación de términos, la configuración del solucionador y el procesamiento posterior.

Extensiones sugeridas:

  • Agregue términos de reacción para sistemas de reacción-difusión o patrones de turing.
  • Compare los resultados de Fipy con las soluciones analíticas de referencia.
  • Paralelice con el soporte MPI de Fipy.

8. Monte Carlo para precios de opciones

Dificultad: Avanzado
Tiempo: 6-10 semanas

Lo que va a simular: Métodos de Monte Carlo en Finanzas, incluyendo precios de opciones europeas y americanas utilizando rutas de precios de acciones simuladas. Esto une la ciencia computacional con matemáticas aplicadas y finanzas cuantitativas.

Modelo de matemáticas:

dS = μS dt + σS dW
V = e^(-rT) E[max(S-K, 0)]

Pila de Python: NumPy, pandas, Matplotlib, scipy.stats

Plantilla de código:

import numpy as np

def monte_carlo_option(S0, K, r, sigma, T, num_paths=10000):
    """Price a European call option using Monte Carlo."""
    z = np.random.randn(num_paths)
    S_final = S0 * np.exp(
        (r - 0.5 * sigma**2) * T + sigma * np.sqrt(T) * z
    )
    
    payoffs = np.maximum(S_final - K, 0)
    price = np.exp(-r * T) * np.mean(payoffs)
    stderr = np.exp(-r * T) * np.std(payoffs) / np.sqrt(num_paths)
    
    return price, stderr

Resultados de aprendizaje:

  • Simulación estocástica y generación de rutas.
  • Análisis de convergencia con tamaño de muestra.
  • Técnicas de reducción de varianza, como variadas antitéticas y variadas de control.
  • Precios de opciones americanas con métodos de Monte Carlo de mínimos cuadrados.

Por qué este proyecto: los métodos de Monte Carlo funcionan en entornos de alta dimensión, lo que los hace útiles en finanzas, ciencia de materiales, teoría cuántica de campos y cuantificación de la incertidumbre.

Extensiones sugeridas:

  • Implemente el algoritmo Longstaff-Schwartz para opciones americanas.
  • Estudia griegos como Delta, Gamma y Vega.
  • Compare los resultados con la solución analítica de Black-Scholes.

9. Solidificación y simulación de campo de fase

Dificultad: Avanzado
Tiempo: 12-16 semanas

Lo que va a simular: El método de campo de fase se usa ampliamente en la ciencia de materiales computacionales para la evolución de la microestructura, incluido el crecimiento de granos, la solidificación dendrítica y la formación de precipitados.

Modelo de matemáticas:

∂φ/∂t = -Γ [φ(1-φ)² + F'(φ) + λ∇φ·∇φ]

Aquí, φ es el campo de fase, Γ es movilidad y F(φ) es el potencial de doble pozo.

Pila de Python: FiPy, NumPy, Matplotlib

Plantilla de código:

from fipy import Grid2D, CellVariable, TransientTerm, DiffusionTerm

mesh = Grid2D(nx=100, ny=100, dx=1.0, dy=1.0)

phi = CellVariable(mesh=mesh, name="phase_field", value=0.0)

# Example starter equation structure:
# TransientTerm == diffusion + source-like phase evolution term
eq = TransientTerm(var=phi) == DiffusionTerm(coeff=1.0, var=phi)

for step in range(100):
    eq.solve(var=phi, dt=0.01)

Resultados de aprendizaje:

  • Formulación de campo de fase y potenciales de doble pozo.
  • Parámetros de ancho de interfaz y movilidad.
  • Acoplamiento con ecuaciones de difusión.
  • Comparación con soluciones de solidificación analítica o referencias bibliográficas.

Por qué este proyecto: La simulación de campo de fase se utiliza en la investigación de la ciencia de materiales en todo el mundo. Conecta la microestructura, la termodinámica y los métodos numéricos.

Extensiones sugeridas:

  • Acople el campo de fase con difusión para modelos de captura de solutos.
  • Estudie los patrones de crecimiento dendrítico bajo diferentes condiciones de subenfriamiento.
  • Compare los resultados con las micrografías experimentales de la literatura.

Cómo elegir tu proyecto

No todos los proyectos son adecuados para todos los estudiantes. Utilice el marco a continuación para elegir un punto de partida realista.

Haga coincidir su fondo

actualmente sabes Proyecto de inicio recomendado
Conceptos básicos de Python, sin antecedentes numéricos ecuación de calor
Python Plus Análisis numérico introductorio modelo de señor o ecuación de onda
Curso ODE/PDE y álgebra lineal Iteración Jacobi o dinámica molecular
Mecánica estadística o matemáticas avanzadas modelo
Objetivos de investigación o tesis Difusión Fipy o simulación de campo de fase

lo que más importa

  1. Prerrequisitos matemáticos. No salte a la simulación de campo de fase si aún no ha resuelto una PDE numéricamente.
  2. comodidad de programación. Si es nuevo en Python, comience con la ecuación de calor y construya desde allí.
  3. Horizonte de tiempo. Un proyecto de semestre necesita un alcance claro. Elija algo que pueda producir un resultado significativo en 4 a 8 semanas.
  4. objetivos de carrera. La ciencia de los materiales apunta hacia la dinámica de campo o de fase. Puntos financieros hacia Monte Carlo. El software de investigación apunta hacia solucionadores fibrosos o iterativos.

Errores comunes que cometen los estudiantes

  1. Elegir un proyecto que es demasiado ambicioso. Un solucionador de campo de fase 3D completo en cuatro semanas no es realista. Apúnquelo a 2D con parámetros simples.
  2. Omitir la comparación de soluciones analíticas. Siempre compare los resultados numéricos con una solución conocida cuando sea posible.
  3. ignorando la condición CFL. Muchas simulaciones para principiantes fallan porque el paso de tiempo es demasiado grande.
  4. No usar el control de versiones. Git no es opcional para un proyecto serio. Comprométete regularmente para que puedas recuperarte de los errores.

¿Qué debes saltarte?

No todos los proyectos computacionales son igualmente útiles para la simulación de aprendizaje. Evítelos a menos que tenga una razón específica.

  • Simulaciones genéricas de «hola mundo». Si un proyecto no involucra una PDE, una ley de conservación, un solucionador numérico o un modelo estocástico, puede que no sea un proyecto de ciencia computacional.
  • Proyectos que requieren hardware especial al principio. No comience con GPU Molecular Dynamics si no ha creado primero la dinámica molecular de la CPU.
  • Acoplamiento multifísico demasiado complejo. Comience con solucionadores de una sola física. El acoplamiento multifísico es un tema de investigación, no un proyecto de primer estudiante ideal.

Dónde encontrar el código de referencia

Varios cursos universitarios y proyectos de código abierto brindan implementaciones de referencia útiles:

Utilice estos recursos como puntos de partida, no como puntos finales. El verdadero aprendizaje ocurre cuando escribes y depuras el código tú mismo.

Pensamientos finales

La diferencia entre leer sobre métodos numéricos y escribir una simulación es enorme. Puede leer muchos libros de texto de PDE y aún no entender lo que sucede cuando una ecuación de difusión se discretiza con un paso de tiempo que es demasiado grande.

Elija un proyecto, comience a codificar e itera. Unas pocas semanas de depuración pueden enseñar más de meses de conferencias pasivas.

Si necesita ayuda con un problema de simulación específico, como elegir el solucionador correcto, depurar una inestabilidad numérica o escalar código en varios procesadores, considere preguntar a alguien con experiencia. Un buen apoyo puede ayudarlo a evitar las trampas comunes mientras sigue haciendo el trabajo usted mismo.