Reading Time: 12 minutes

Points à retenir clés

  • Les idées de projets organisés couvrent les niveaux débutants, intermédiaires et avancés, en mettant l’accent sur la simulation et la science informatique.
  • Les niveaux de difficulté reflètent les conditions préalables, la complexité des mathématiques et l’investissement en temps attendu.
  • Des modèles de code sont inclus pour chaque projet afin que les étudiants puissent commencer à construire rapidement.
  • Les résultats d’apprentissage montrent ce que chaque projet enseigne.
  • Une feuille de route des compétences aux projets aide les élèves à choisir un projet en fonction de leurs connaissances actuelles.

Les projets d’étudiants en sciences informatiques et en simulation sont ceux où la théorie rencontre enfin le code. Vous pouvez apprendre des méthodes de volume fini, des équations aux dérivées partielles et des lois de conservation dans les conférences, mais les équations sur un tableau blanc n’enseignent pas à quoi ressemble l’écriture d’un solveur à partir de zéro.

Si vous voulez comprendre comment les méthodes numériques se traduisent par des simulations de travail, choisissez un projet et commencez à construire.

Ce guide organise des idées de projets pratiques inspirées de cours de physique informatique universitaires, de projets scientifiques open source et de référentiels entre pairs. Chaque projet utilise Python et construit vers quelque chose que les étudiants peuvent inclure dans un portfolio.

Niveaux de difficulté du projet expliqués

Avant de choisir un projet, il est utile de comprendre ce que signifie chaque niveau en termes d’effort.

Niveau Les prérequis Heure prévue Que vas tu faire?
Débutant Principes de base de Python, NumPy, Matplotlib 2 à 4 semaines Résolvez des ODE ou des PDE simples avec des méthodes explicites et visualisez les résultats
Intermédiaire Analyse numérique, algèbre linéaire, fond ODE/PDE 4 à 8 semaines Implémentez des solveurs, gérez les conditions aux limites et comparez la précision
Avancée Méthodes numériques avancées, calcul parallèle ou formation en physique spécialisée 8 à 16 semaines Créez des simulations multi-physiques, optimisez les performances ou comparez avec les résultats de la littérature

Le tableau n’est pas un classement. C’est un outil de correspondance. Choisissez un niveau qui correspond à votre préparation actuelle, puis montez vers le haut une fois que vous êtes à l’aise.

Feuille de route des compétences aux projets

La feuille de route ci-dessous montre quels concepts mathématiques et de programmation correspondent aux projets.

┌─────────────────┬─────────────────────────────────────────────────────────┐
│ 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      │
└─────────────────┴─────────────────────────────────────────────────────────┘

Projets débutants

Ces projets introduisent des concepts de simulation de base sans écraser les mathématiques ou la configuration complexe. Ils sont conçus pour fonctionner sur un ordinateur portable sans matériel spécial.

1. Solveur d’équations de chaleur sur une grille

Difficulté : Débutant
Durée : 2 à 3 semaines

Ce que vous simulez : la chaleur se répandant à travers une plaque métallique, une tige ou une pièce. L’équation de la chaleur 1D ou 2D est un premier projet classique en EDP numériques car il est conceptuellement simple et enseigne les grands concepts utilisés plus tard.

Modèle mathématique :

∂T/∂t = α ∇²T

Ici, α est la diffusivité thermique, T est la température et ∇² est le laplacien spatial.

Pile Python : NumPy, Matplotlib

Modèle de code :

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()

Résultats d’apprentissage :

  • Comprendre la stabilité explicite et implicite.
  • Implémentation des conditions limites.
  • Visualisation des champs diffusifs.
  • Raisonnement de base sur la stabilité de style LFC.

Pourquoi ce projet : L’équation de la chaleur est le « monde bonjour » de la simulation. Chaque projet ultérieur impliquant la diffusion, les ondes ou la modélisation des champs de phase s’appuie sur des modèles numériques similaires.

Extensions suggérées :

  • Passez à un schéma entièrement implicite ou à un crank-Nicolson et comparez la stabilité.
  • Ajoutez un terme source tel qu’un élément chauffant.
  • Exportez les résultats vers CSV pour analyse.

2. Modèle de propagation épidémique de monsieur

Difficulté : Débutant
Durée : 2 à 3 semaines

Ce que vous simulerez : le modèle compartimenté classique de la propagation de la maladie : sensible, infectieuse et récupérée. Ce modèle capture les courbes épidémiques, l’immunité collective et le nombre de reproduction de base sans grille spatiale.

Modèle mathématique :

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

Ici, β est le taux de transmission, γ est le taux de récupération et N = S + I + R est la population.

Pile Python : NumPy, SciPy, Matplotlib

Modèle de code :

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()

Résultats d’apprentissage :

  • Résolution des systèmes d’ODE.
  • Comprendre R₀ = β/γ.
  • Interprétation des pics épidémiques et du comportement de taille finale.
  • Tracer le comportement du plan phase-plan tel qu’une population infectieuse par rapport à une population sensible.

Pourquoi ce projet : il a une pertinence dans le monde réel avec une complexité minimale. Le modèle est assez simple à comprendre mais suffisamment riche pour soutenir des expériences significatives.

Extensions suggérées :

  • Ajoutez une structure d’âge avec plusieurs compartiments.
  • Inclure la vaccination comme paramètre dépendant du temps.
  • Comparez les solveurs Euler, RK4 et Scipy Ode.

3. Équation d’onde sur une chaîne

Difficulté : Débutant
Durée : 3 à 4 semaines

Ce que vous simulez : une corde vibrante, une membrane de tambour ou une onde sonore. L’équation d’onde introduit la propagation, la réflexion et les ondes stationnaires.

Modèle mathématique :

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

Les conditions aux limites peuvent être fixes, gratuites ou mixtes.

Pile Python : NumPy, Matplotlib

Modèle de code :

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()

Résultats d’apprentissage :

  • Pas de temps de différence finie pour les PDE du second ordre.
  • Analyse de l’état et de la stabilité de la LFC.
  • Réflexion des vagues et ondes stationnaires.
  • Visualisation avec animation ou instantanés temporels.

Extensions suggérées :

  • Essayez différentes conditions initiales telles qu’un paquet d’ondes gaussiennes.
  • ajouter des limites réfléchissantes ou absorbantes.
  • Comparez la solution numérique avec une solution analytique.

Projets intermédiaires

Ces projets nécessitent une expérience plus solide en analyse numérique, en algèbre linéaire ou en physique. Le code implique des solveurs itératifs, des méthodes adaptatives ou des modèles plus complexes.

4. Itération de Jacobi et Krylov pour les systèmes linéaires

Difficulté : Intermédiaire
Durée : 4 à 6 semaines

Ce que vous simulerez : des solutions itératives à Ax = b en utilisant Jacobi, Gauss-Seidel et Conjugate Gradient. C’est l’épine dorsale de nombreux solveurs PDE.

Modèle mathématique :

Ax = b

Ici, A est généralement clairsemé, et pour de nombreux problèmes de style diffusion, il est symétrique positif-défini.

Pile Python : NumPy, SciPy, Matplotlib

Modèle de code :

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}")

Résultats d’apprentissage :

  • Représentation et opérations de la matrice clairsemée.
  • Analyse de convergence du solveur itératif.
  • Comparaison de Jacobi, Gauss-Seidel et gradient conjugué.
  • Concepts de base de préconditionnement.

Pourquoi ce projet : chaque solveur PDE utilise des systèmes linéaires clairsemés en interne. La compréhension des méthodes itératives au niveau du code aide à démystifier des outils tels que Fipy, Fenics et OpenFoam.

Extensions suggérées :

  • Ajoutez un préconditionneur diagonal.
  • Comparez les taux de convergence sur les grilles 2D et 3D.
  • Mettre en œuvre un cycle multigrille simple.

5. Dynamique moléculaire avec le potentiel de Lennard-Jones

Difficulté : Intermédiaire
Durée : 4 à 8 semaines

Ce que vous allez simuler : un gaz ou un liquide de particules interagissant à travers le potentiel de Lennard-Jones. Ce projet démontre le cycle complet du modèle physique à l’intégration numérique, à l’analyse des données et à la visualisation.

Modèle mathématique :

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

Les méthodes d’intégration typiques incluent les schémas de Velocity Verlet ou LeapFrog.

Pile Python : NumPy, Matplotlib, h5py

Modèle de code :

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

Résultats d’apprentissage :

  • Intégration numérique à base de particules.
  • Conditions aux limites périodiques.
  • Suivi de conservation de l’énergie.
  • Fonctions de distribution radiale.

Pourquoi ce projet : Molecular Dynamics est une passerelle vers le calcul scientifique haute performance. Une fois que vous comprenez les particules de Lennard-Jones, vous pouvez passer à des potentiels complexes, à grossissement ou à un GPU accéléré.

Extensions suggérées :

  • Passez à l’accélération GPU avec cupy ou numba.
  • Étudiez les transitions de phase en faisant varier la température.
  • Calculez la conductivité thermique avec les relations Green-Kubo.

6. Modèle Ising pour le magnétisme 2D

Difficulté : Intermédiaire
Durée : 4 à 6 semaines

Ce que vous simulerez : Le modèle Ising est l’un des modèles les plus simples de magnétisme et l’un des problèmes les plus étudiés en physique statistique. Il montre comment les règles locales peuvent produire des transitions de phase macroscopiques.

Modèle mathématique :

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

Pile Python : NumPy, Matplotlib, SciPy

Modèle de code :

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

Résultats d’apprentissage :

  • Méthodes de Monte Carlo et algorithme de Metropolis.
  • Transitions de phase et phénomènes critiques.
  • Heuristique de minimisation énergétique.
  • Visualisation des modèles émergents.

Pourquoi ce projet : Le modèle Ising relie la physique statistique, les méthodes de calcul et l’apprentissage automatique. Il a également un comportement de référence connu, ce qui rend possible la validation.

Extensions suggérées :

  • Calculez la capacité thermique et la sensibilité à proximité de la température critique.
  • Étudiez différentes géométries de réseau.
  • Implémentez l’algorithme de cluster Wolff ou Swendsen-Wang.

Projets avancés

Ces projets nécessitent une expérience en matière de méthodes numériques plus solides, une expérience de calcul parallèle ou une connaissance de la physique spécialisée. Ils conviennent aux travaux de niveau de thèse ou de synthèse.

7. Solveur de diffusion basé sur Fipy

Difficulté : Avancé
Durée : 8 à 12 semaines

Ce que vous allez simuler : un problème de diffusion réaliste à l’aide de Fipy. Cela relie les concepts PDE et la discrétisation des volumes finis à des logiciels scientifiques de qualité de production.

Modèle mathématique :

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

Il s’agit d’une équation de diffusion avec des termes sources et des conditions aux limites telles que Dirichlet, Neumann ou Robin.

Pile Python : FiPy, NumPy, Matplotlib

Modèle de code :

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)

Résultats d’apprentissage :

  • Discrétisation en volume fini avec Fipy.
  • Gestion des conditions aux limites de Dirichlet, Neumann et Robin.
  • Études de qualité et de convergence de maillage.
  • Connecter des solutions analytiques aux résultats numériques.

Pourquoi ce projet : si vous souhaitez travailler dans la science informatique de manière professionnelle, il est précieux de savoir comment utiliser et étendre un code de volume fini comme Fipy. Ce projet combine la configuration du maillage, la formulation des termes, la configuration du solveur et le post-traitement.

Extensions suggérées :

  • Ajoutez des termes de réaction pour les systèmes de réaction-diffusion ou les schémas de Turing.
  • Comparez les résultats de Fipy avec les solutions de référence analytiques.
  • Parallèlement avec le support MPI de Fipy.

8. Monte Carlo pour le prix des options

Difficulté : Avancé
Durée : 6 à 10 semaines

Ce que vous allez simuler : les méthodes de Monte Carlo dans la finance, y compris la tarification des options européennes et américaines en utilisant des trajectoires de cours simulées. Cela relie la science informatique avec les mathématiques appliquées et la finance quantitative.

Modèle mathématique :

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

Pile Python : NumPy, pandas, Matplotlib, scipy.stats

Modèle de code :

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

Résultats d’apprentissage :

  • Simulation stochastique et génération de trajectoires.
  • Analyse de convergence avec la taille de l’échantillon.
  • Les techniques de réduction de la variance telles que les variables antithétiques et les variables de contrôle.
  • Tarification des options américaines avec les méthodes de Monte Carlo des moindres carrés.

Pourquoi ce projet : Les méthodes de Monte Carlo fonctionnent dans des contextes de grande dimension, ce qui les rend utiles dans la finance, la science des matériaux, la théorie des champs quantiques et la quantification de l’incertitude.

Extensions suggérées :

  • Implémentez l’algorithme Longstaff-Schwartz pour les options américaines.
  • Étudiez les Grecs tels que Delta, Gamma et Vega.
  • Comparez les résultats avec la solution analytique de Black-Scholes.

9. Solidification et simulation de champ de phase

Difficulté : Avancé
Durée : 12 à 16 semaines

Ce que vous allez simuler : La méthode du champ de phase est largement utilisée dans la science des matériaux informatiques pour l’évolution de la microstructure, y compris la croissance des grains, la solidification dendritique et la formation de précipités.

Modèle mathématique :

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

Ici, φ est le champ de phase, Γ est la mobilité, et F(φ) est le potentiel de double puits.

Pile Python : FiPy, NumPy, Matplotlib

Modèle de code :

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)

Résultats d’apprentissage :

  • Formulation en champ de phase et potentiel de double puits.
  • Largeur de l’interface et paramètres de mobilité.
  • couplage avec des équations de diffusion.
  • Comparaison avec des solutions de solidification analytique ou des repères de la littérature.

Pourquoi ce projet : La simulation en champ de phase est utilisée dans la recherche sur les sciences des matériaux dans le monde. Il relie la microstructure, la thermodynamique et les méthodes numériques.

Extensions suggérées :

  • Associez le champ de phase à la diffusion pour les modèles de piégeage de solutés.
  • Étudiez les modèles de croissance dendritique dans différentes conditions de sous-refroidissement.
  • Comparez les résultats avec les micrographies expérimentales de la littérature.

Comment choisir votre projet

Tous les projets ne conviennent pas à tous les étudiants. Utilisez le cadre ci-dessous pour choisir un point de départ réaliste.

Faites correspondre votre arrière-plan

vous savez actuellement Projet de démarrage recommandé
Principes de base de Python, pas de fond numérique Équation de chaleur
Python Plus Analyse numérique d’introduction Modèle de monsieur ou équation d’onde
Course ODE/PDE et algèbre linéaire Itération de Jacobi ou dynamique moléculaire
Mécanique statistique ou mathématiques avancées Modèle d’accès
Objectifs de recherche ou de thèse Diffusion FIPY ou simulation en champ de phase

Ce qui compte le plus

  1. Prérequis mathématiques. Ne passez pas à la simulation en champ de phase si vous n’avez pas encore résolu un PDE numériquement.
  2. Confort de programmation. Si vous êtes nouveau sur Python, commencez par l’équation de la chaleur et construisez à partir de là.
  3. horizon temporel. Un projet de semestre a besoin d’une portée claire. Choisissez quelque chose qui peut produire un résultat significatif en 4 à 8 semaines.
  4. objectifs de carrière. La science des matériaux pointe vers le champ de phase ou la dynamique moléculaire. Financer des points vers Monte-Carlo. Les logiciels de recherche pointent vers FIPY ou des solveurs itératifs.

erreurs courantes que font les élèves

  1. Choisir un projet trop ambitieux. Un solveur de champ de phase 3D complet en quatre semaines n’est pas réaliste. Mettez-le jusqu’à 2D avec des paramètres simples.
  2. Sauter la comparaison de solutions analytiques. Toujours comparer les résultats numériques à une solution connue lorsque cela est possible.
  3. Ignorer la condition LFC. De nombreuses simulations pour débutants échouent car le pas de temps est trop important.
  4. N’utilisez pas le contrôle de version. Git n’est pas facultatif pour un projet sérieux. Engagez-vous régulièrement afin de vous remettre des erreurs.

Que faut-il sauter ?

Tous les projets informatiques ne sont pas également utiles pour la simulation d’apprentissage. Évitez-les sauf si vous avez une raison spécifique.

  • Simulations génériques de « Hello World ». Si un projet n’implique pas une PDE, une loi de conservation, un solveur numérique ou un modèle stochastique, il ne s’agit peut-être pas d’un projet de science informatique.
  • Projets qui nécessitent du matériel spécial au départ. Ne commencez pas avec la dynamique moléculaire du GPU si vous n’avez pas construit la dynamique moléculaire du CPU en premier.
  • Couplage multi-physique trop complexe. Commencez par des solveurs à une seule physique. Le couplage multi-physique est un sujet de recherche, et non un premier projet étudiant idéal.

Où trouver le code de référence

Plusieurs cours universitaires et projets open source fournissent des références utiles :

Utilisez ces ressources comme points de départ, et non comme points de terminaison. L’apprentissage réel se produit lorsque vous écrivez et déboguez vous-même le code.

Réflexions finales

La différence entre la lecture des méthodes numériques et la rédaction d’une simulation est énorme. Vous pouvez lire de nombreux manuels de PDE et ne pas comprendre ce qui se passe lorsqu’une équation de diffusion est discrétisée avec un pas de temps trop volumineux.

Choisissez un projet, commencez à coder et itérez. Quelques semaines de débogage peuvent enseigner plus de mois de conférences passives.

Si vous avez besoin d’aide pour résoudre un problème de simulation spécifique, comme le choix du bon solveur, le débogage d’une instabilité numérique ou la mise à l’échelle du code à plusieurs processeurs, envisagez de demander à quelqu’un de l’expérience. Un bon soutien peut vous aider à éviter les pièges courants tout en faisant le travail vous-même.