Simulazione della Propagazione dell’Onda utilizzando il Metodo delle Differenze Finite

1. Equazione delle Onde

L’equazione delle onde unidimensionale è una seconda equazione differenziale parziale (PDE) data da:

\(
\frac{{\partial^2 u}}{{\partial t^2}} = c^2 \nabla^2 u
\)

dove \( u \) è l’ampiezza dell’onda, \( t \) è il tempo, \( c \) è la velocità della propagazione dell’onda e \( \nabla^2 \) è l’operatore laplaciano. In due dimensioni, l’operatore laplaciano \( \nabla^2 \) diventa:

\(
\nabla^2 u = \frac{{\partial^2 u}}{{\partial x^2}} + \frac{{\partial^2 u}}{{\partial y^2}}
\)

2. Metodo delle Differenze Finite

Per risolvere questa equazione, utilizziamo il metodo delle differenze finite. La griglia è composta da nodi puntiformi separati da \( \Delta x \) nello spazio e \( \Delta t \) nel tempo. Applichiamo differenze finite centrate per approssimare le derivate seconde nello spazio e nel tempo:

\(
\nabla^2 u \approx \frac{{u^n_{i+1, j} + u^n_{i, j+1} – 4u^n_{i,j} + u^n_{i-1, j} + u^n_{i, j-1}}}{{\Delta x^2}}
\)

Dove \( u^n_{i,j} \) rappresenta l’ampiezza dell’onda al nodo \( (i, j) \) al tempo \( n \).

3. Condizioni Iniziali e al Contorno

Nel codice, utilizziamo una griglia quadrata \( N \times N \) con \( N = 256 \). La condizione iniziale è \( u = 0 \) su tutta la griglia. Le condizioni al contorno sono:

1. \( u = 0 \) sui bordi della griglia.
2. \( u \) è fissato a 0 in una “barriera” posta all’interno della griglia.
3. \( u = \sin(20\pi t) \cdot \sin^2(\pi x) \) lungo il bordo superiore della griglia.

4. Commenti sul Codice Python

# Importazione delle librerie
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image

def main():
    # Parametri di simulazione
    N = 256                 # Dimensione della griglia
    boxsize = 1.            # Dimensione del dominio
    c = 1.                  # Velocità dell'onda
    t = 0                   # Tempo iniziale
    tEnd = 2.               # Tempo finale
    plotRealTime = True     # Opzione per il plotting in tempo reale

    # Inizializzazione della mesh e dei parametri temporali e spaziali
    dx = boxsize / N        # Spaziatura della griglia
    dt = (np.sqrt(2)/2) * dx / c  # Passo temporale
    aX = 0                  # Indice asse X
    aY = 1                  # Indice asse Y
    R = -1                  # Rotazione a destra
    L = 1                   # Rotazione a sinistra
    fac = dt**2 * c**2 / dx**2  # Fattore comune nella formula delle differenze finite

    # Altri dettagli iniziali
    # ...

    while t < tEnd:
        # Calcolo del laplaciano
        # ...

        # Aggiornamento di U usando il metodo delle differenze finite
        # ...

        # Applicazione delle condizioni al contorno
        # ...

        # Plot e salvataggio delle immagini
        # ...

    return 0

if __name__ == "__main__":
    main()

Nel codice, l’array U rappresenta l’ampiezza dell’onda \( u \) su ogni punto della griglia. Utilizziamo un ciclo while per avanzare la simulazione nel tempo fino a tEnd.

Nota:

• Per conservare le informazioni sul colore nell’animazione GIF, utilizziamo la mappa dei colori di Matplotlib (cmap) per convertire i dati normalizzati in un array RGBA. Poi, creiamo un’immagine PIL RGBA da questo array.

Questo approccio fornisce un metodo numerico per simulare la propagazione delle onde in un dominio bidimensionale soggetto a varie condizioni iniziali e al contorno.