Laboratorio di trattamento numerico dei dati sperimentali

Transcript

1 Laboratorio di trattamento numerico dei dati sperimentali Maurizio Tomasi turno A2 Giovedì 21 Dicembre 2017

2 Risoluzione di equazioni differenziali

3 Esercizi 10.0 e 10.1 Nell'esercizio 10.0 si deve risolvere col metodo di Eulero l'equazione riscritto come mx (t) = kx(t), x (t) = ω x(t), che rappresenta il moto di un oscillatore armonico. L'esercizio successivo 10.1 è identico, ma chiede di usare il metodo di Runge Kutta. 0 2

4 Sistemi di ordine n > 1 Il problema mx (t) = ω x(t), ha come incognita la funzione x : R R, e coinvolge una derivata seconda: x (t). Può essere però riscritto come un sistema di equazioni contenenti solo derivate prime: x (t) = v(t), { v (t) = ω x(t)

5 Sistemi di ordine n > 1 A questo punto, la scrittura può essere condensata nella forma dove ora y : R R : 2 x (t) = v(t), { v (t) = ω x(t). y = f(t, y), y = ( x(t), f =. v(t) ) (x(t) v(t) ) ( v(t) ω x(t) )

6 Approssimazione numerica della soluzione L'equazione y = f(t, y), rappresenta una equazione differenziale e non un sistema di primo grado anziché di secondo, ma abbiamo visto che corrisponde in realtà ad una equazione di secondo grado o a un sistema di equazioni di primo grado. Vediamo ora come approssimare la soluzione

7 Metodo di Eulero esercizio 10.0 Data l'equazione differenziale e una condizione iniziale y = f(t, y), { y(0) =y 0, il metodo di Eulero approssima la soluzione all'istante t + δt partendo dalla soluzione all'istante t = t : y(t + δt) y(t ) + δt y (t ) = y(t ) + δt f (t, y)

8 Svolgimento esplicito dei calcoli Partiamo dall'istante t = 0, per cui abbiamo la condizione iniziale y(0) =y 0 = ( 0 ), v 0 con v = 1 m/s. Il metodo di Eulero fornisce quindi 0 l'approssimazione y(0 + δt) =y + δt f(0, y) = 0 = ( 0 ) + δt ( v 0 = v 0 ω 0 =. ( δt v 0 v 0 ) 0 2 )

9 Confronto con la soluzione analitica Vediamo come si confronta questo con la soluzione nota x(t) = sin ω t. Se supponiamo δt piccolo, affinché ω δt 1, allora v 0 x(0 + δt) = sin( ω 0 δt) v0δt, ω 0 v 0 0 ω 0 che è esattamente la soluzione del metodo di Eulero. Per quanto riguarda la velocità, la soluzione analitica è ẋ (δt) = v cos ω δt v, ancora corrispondente alla soluzione di Eulero. 0

10 Calcolo esplicito Usando come parametri abbiamo che v = 1 m/s, ω = 1 Hz, δt = 10 s, 0 0 y(0) = ( 0, y(0 + δt) =. 1 m/s ) (10 2 m 1 m/s ) 2

11 Verifica dei calcoli nel codice Potete inserire una verifica esplicita della correttezza dei vostri calcoli nel codice, scrivendo un test: void assert_close(double x, double y) { assert(std::fabs(x y) < 1e 7); } int main() { double deltat = 1e 2; //... for (int step = 0; step < N; ++step) { if (step == 0) { assert_close(solution[0], 0.0); assert_close(solution[1], 1.0); } else if (step == 1) { assert_close(solution[0], 1e 2); assert_close(solution[1], 1.0); } } // Update "solution" using Euler's method

12 Metodo di Runge Kutta RK È una generalizzazione del metodo di Eulero, che può essere potenzialmente complicata da digerire! Se per Eulero l'incremento da y(t 0) a y(t 0 + δt) era δt f( t 0, y(t 0 )), in questo caso è k 1+ 2k 2+ 2k 3+k4 δt, 6 dove i quattro vettori k sono definiti come j k 1 k 2 k 3 k 4 = f( t 0, y(t 0 )), δt δt = f ( t 0 +, y(t 0) + k 1), 2 2 δt δt = f ( t 0 +, y(t 0) + k 2), 2 2 = f ( t 0 + δt, y(t 0 ) + δtk 3 ).

13 Metodo RK e metodo di Eulero Notate che se si cambia la definizione dei k, ponendo k =k =k j tutti uguali a k, si ottiene esattamente la soluzione di Eulero. 1

14 Applicazione di RK all'esercizio 10.1 La dipendenza di f dal tempo t che si vede nelle formule della slide precedente non è utile in questo esercizio, perché la forza in gioco è F (t) = ω x(t), che non dipende dal tempo in modo esplicito. 0 2 La dipendenza della forza F (t) dal tempo che è causata dalla presenza del termine x(t) non conta: nel calcolo di δt δt k 2 = f ( t 0 +, y(t 0) + k1) 2 2 il valore di x(t) va calcolato in t = t, non in t = t + δt/2, perché fa riferimento il termine y(t ). 0 0 Il termine temporale sarà fondamentale nell'esercizio 10.4, dove si dovrà risolvere l'equazione di un oscillatore forzato. 0

15 Sviluppo dei calcoli per il metodo RK Mostriamo con un conto esplicito come calcolare il primo step dell'integrazione RK per il problema dell'oscillatore esercizio Nel nostro caso la funzione f ha la proprietà di essere lineare, quindi rappresentabile tramite una matrice A: Vale infatti che A = ( ω 0 0 ) f(y) = A y = ( =. ω 0 0 ) (x(t) v(t) ) ( v(t) ω x(t) 0 2 ) L'effetto di A è analogo a una derivata: trasforma una coppia posizione velocità in una coppia velocità accelerazione.

16 Calcoli analitici con Python Possiamo usare Python per svolgere i calcoli simbolici del metodo RK usando il pacchetto sympy. Se avete installato Miniconda, installatelo con conda install sympy ed avviate jupyterqtconsole. Digitate questi comandi: from sympy import * init_printing() # Define a few "symbols": variables which do not have a # definite numerical value. Strings are LaTeX representation deltat = Symbol(r'\delta t', real=true) omega0 = Symbol(r'\omega_0', real=true) v0 = Symbol('v_0', real=true) # Initial condition y0 = Matrix([[0], [v0]]) # Matrix representing the «f» operator A = Matrix([[0, 1], [ omega0**2, 0]])

17 Sviluppo dei calcoli per il metodo RK Consideriamo quindi un passo h e calcoliamo il valore di y all'istante t = h partendo da y y(t = 0). Servono innanzitutto le quattro quantità k, k, k, k ; partiamo dalla prima: 0 k 1 = f t, y(t ) = ( 0 0 ) = A y

18 Calcolo di k 1 Usiamo sympy per fare questo calcolo: digitate nella finestra «Jupyter QtConsole» k1 = y0 k1 # Print the result in Python il prodotto tra matrici si effettua col Python risponderà scrivendo una formula LaTeX: che corrisponde a k. Se volete il sorgente LaTeX della formula, eseguite print(latex(k1)) 1 ( v 0 0 ),

19 Calcolo di k 2 δt δt k 2 = f ( t 0 +, y(t 0) + k 1) = 2 2 δt = A ( y 0 + k 1). 2 Usiamo ancora sympy : k2 = (y0 + deltat * k1 / 2) k2 v 0 ( δt ω v )

20 Calcolo di k 3 δt δt k 3 = f ( t 0 +, y(t 0) + k 2) = 2 2 δt = A ( y 0 + k 2). 2 I conti diventano sempre più complessi: k3 = (y0 + deltat * k2 / 2) k3 1 v0 ( 1 δt 2 ω ) δt ω0 2 v0 2

21 Calcolo di k 4 k 4 = f ( t 0 + δt, y(t 0 ) + δtk 3 ) = = A ( y 0 + δtk3) k4 = (y0 + deltat * k3) k4 δt 2 v 0 ( 1 ω o 2 ) 2 δt ωo 2 δt 2 v0 ( 1 ωo 2 ) 4

22 Calcolo dell'incremento Valutiamo ora il termine da sommare a y(t 0) per ottenere y(t + δt): 0 incr = deltat / 6 * (k1 + 2 * (k2 + k3) + k4) incr.simplify() incr δt 2 δtv 0 ( 1 ω o 2 ) 6 ω2 o v 0 δt 2 δt 2 ( 1 ωo 2 ) 2 12

23

24 Verifica del risultato 1/2 Possiamo renderci conto della bontà del risultato se calcoliamo lo sviluppo di Taylor intorno a t = 0 della soluzione analitica v 0 0 ω 0 x(t) = sin ω t. series(v0 / omega0 * sin(omega0 * deltat), deltat) 2 4 ω δtv o v 0 3 ω 0 δt + o v 0 5 δt + O ( δt 6 ) I primi due termini corrispondono esattamente al valore di incr[0] termine della posizione che abbiamo ricavato con sympy. L'errore di RK in questo caso è quindi dell'ordine di δt. 4

25 Verifica del risultato 2/2 Facciamo ora lo stesso con la velocità: v(t) = (t) = v cos ω t. ẋ 0 0 series(diff(v0 / omega0 * sin(omega0 * deltat), deltat), deltat) 2 4 ω v o v 0 2 ω 0 δt + o v 0 4 δt + O ( δt 6 ) 2 24 Questo corrisponde a v più il valore di incr[1] termine della velocità. Notate che la discrepanza rispetto alla soluzione analitica stavolta è dell'ordine di δt. 0 6

26 Semplificare il risultato Possiamo sostituire i simboli usati nel calcolo con i valori dati nel testo dell'esercizio 10.1: δt = 10 s, ω = 1 s, v = 1 m/s. (y0 + incr).subs([(deltat, 1e 2), (omega0, 1), (v0, 1)]) La sostituzione restituisce il valore di y(0 + δt) step n = 1 della simulazione : 2 ( )

27 Verificare l'implementazione di RK Come prima è importante scrivere un test all'inizio del codice in cui si verifichi che si stiano facendo i calcoli in modo corretto: int main() { double deltat = 1e 2; //... for (int step = 0; step < N; ++step) { if (step == 0) { assert_close(solution[0], 0.0); assert_close(solution[1], 1.0); } else if (step == 1) { assert_close(solution[0], ); assert_close(solution[1], ); } } // Update "solution" using RK's method

28 Avvertenza importante Tutti i calcoli svolti qui per l'esercizio 10.1 non sono veri in generale per l'algoritmo di Runge Kutta. Questo è ovvio, dal momento che la nostra soluzione dipende da ω e v, che sono parametri del problema

29 Overloading degli operatori Per svolgere l'esercizio 10.1 metodo RK è necessario fare molte operazioni sui vettori. Ad esempio, nell'espressione δt δt k 2 = f ( t +, y 0+ k1) 2 2 si devono sommare tra loro y e δtk /2, che sono entrambi 0 1 vettori di 2 elementi posizione e velocità. Il C++ permette di ridefinire gli operatori matematici in modo che siano in grado di operare non solo sui tipi base come int e double, ma anche sulle classi definite nei propri programmi.

30 Overloading degli operatori: esempio Il seguente esempio sfrutta la classe std::vector, e dovrebbe essere facile adattarlo al caso di una classe VettoreLineare : #include <vector> typedef std::vector<double> vec; vec operator+(const vec &a, const vec &b) { vec result(a.size()); for (int j = 0; j < a.size(); ++j) { result[j] = a[j] + b[j]; } return result; } Il nome della funzione, operator+, indica al C++ che è la funzione da invocare quando si scrive v1 + v2, nel caso in cui sia v1 che v2 siano istanze della classe vec.

31 Overloading degli operatori Gli operatori overloading si possono definire sia come funzioni che come metodi di classi: class VettoreLineare { public: // VettoreLineare operator+(const VettoreLineare &) const; }; La scelta dell'una o dell'altra implementazione è equivalente.

32 RK ed overloading degli operatori Tornando ad espressioni vettoriali come δt y 0+ k 1, 2 se y0 e k1 sono istanze di VettoreLineare, il calcolo può essere implementato in C++ nel modo seguente: y0 + (deltat / 2.0) * k1 senza cicli for!, a patto che siano stati definiti gli operatori VettoreLineare operator+(const VettoreLineare & a, const VettoreLineare & b); VettoreLineare operator*(double s, const VettoreLineare & v);