1

Corso di Laurea Magistrale in

Ingegneria civile per la protezione dai rischi naturali

D.M. 270

Relazione di fine tirocinio A.A. 2017 - 2018

“Modelli di previsione del moto ondoso”

Relatore: Giorgio Bellotti Tirocinante: Francesco Passaro Correlatore: Roberto Inghilesi

2

Sommario 1. L’attività di Tirocinio...................................................................................................................................... 3

1.1. Introduzione ............................................................................................................................................ 3

2. Apprendimento e conoscenza di Python e Latex .......................................................................................... 4

2.1. Introduzione .................................................................................................................................................. 4

2.2. Python ............................................................................................................................................................ 5

2.2.1. Introduzione al linguaggio .................................................................................................................... 5

2.2.2. Tipi di dato ............................................................................................................................................. 7

2.2.3. Costrutti ................................................................................................................................................. 8

2.2.4. Dato strutturato ................................................................................................................................... 10

2.2.5. Funzioni ................................................................................................................................................ 12

2.2.6. File e Directory .................................................................................................................................... 13

2.2.7. Numpy .................................................................................................................................................. 13

2.2.8. Matpoltlib ............................................................................................................................................. 16

2.2.9. Sviluppi di Python ................................................................................................................................ 18

2.3. Latex ............................................................................................................................................................ 19

2.3.1. Descrizione del linguaggio ................................................................................................................... 19

3. Studio per la determinazione delle mareggiate nei mari italiani............................................................... 20

3.1. Introduzione .......................................................................................................................................... 20

3.2. Sistema di previsione costiero MC_WAF ........................................................................................... 21

3.3. Metodo POT (Durate Parziali Sopra Soglia) ...................................................................................... 23

3.4. Script di Python..................................................................................................................................... 25

4. Stesura delle relazioni sullo stato dei mari italiani ..................................................................................... 26

4.1. Introduzione .......................................................................................................................................... 26

4.2. Relazione sullo stato dei mari italiani Maggio 2017 .......................................................................... 27

4.2.1. Descrizione generale delle mareggiate occorse nel mese .................................................................. 27

4.2.2. Episodio 6-8 Maggio: Mar Tirreno, Mar di Sardegna e Canale di Sicilia .................................... 28

4.2.3. Episodio 19-20 Maggio: Mar Ligure e Mar Tirreno Centrale ......................................................... 31

4.2.4. Episodio 25 Maggio: Mar Adriatico Meridionale ............................................................................. 33

4.2.5. Elenco mareggiate .................................................................................................................................. 34

4.2.6. Tabella a due ingressi .............................................................................................................................. 35

5. Bibliografia .................................................................................................................................................... 36

3

1. L’attività di Tirocinio

1.1. Introduzione

Il tirocinio esterno è stato svolto presso l’Istituto Superiore per la Protezione e la Ricerca Ambientale dal 15/05/2018 al 16/07/2018 per un totale di 150 ore corrispondenti a 6 CFU. L’attività è consistita nell’acquisire competenze per l’uso del linguaggio di programmazione “Python” e del linguaggio di scrittura “Latex” tramite dei corsi di formazione. Gli obiettivi sono stati quelli di studiare e valutare con il metodo POT le mareggiate nei mari italiani in un anno nel periodo tra Maggio 2017 e Aprile 2018 grazie al modello di previsione costiero MC_WAF e al software Python. Un ulteriore obiettivo è stato quello di redigere delle relazioni sullo stato dei mari italiani tramite il linguaggio di scrittura Latex per descrivere le mareggiate. Il tutto ai fini delle attività di tesi. Il tirocinio è stato suddiviso in tre fasi:

1. apprendimento e conoscenza del linguaggio di programmazione Python e del linguaggio di scrittura Latex (capitolo 2);

2. studio per la determinazione delle mareggiate nei mari italiani (capitolo 3);

3. stesura delle relazioni sullo stato dei mari italiani a descrizione delle mareggiate

tra Maggio 2017 e Aprile 2018 (capitolo 4).

4

2. Apprendimento e conoscenza di Python e Latex

2.1. Introduzione

Il primo passo del tirocinio è consistito nell’apprendimento dell’uso del linguaggio di programmazione Python e del linguaggio di scrittura Latex. Entrambi hanno permesso di raggiungere gli obiettivi prefissati e cioè lo studio, la valutazione e la descrizione delle mareggiate avvenute nei mari italiani in un anno nel periodo tra Maggio 2017 e Aprile 2018. Il primo, sfruttando la georeferenziazione delle mappe riguardanti il Mar Mediterraneo, ha permesso, in corrispondenza delle boe ondametriche posizionate su determinati punti della penisola italiana, la determinazione dei parametri fondamentali che rappresentano le mareggiate: l’altezza d’onda significativa, il periodo di picco, il periodo medio, la direzione di provenienza delle onde e il tempo di ritorno. Python è stato importante per generare le tabelle in Latex con il parametro sopraelencato dell’altezza d’onda significativa e la corrispondente frequenza di accadimento. In base a queste tabelle, conoscendo il linguaggio di scrittura Latex, è stato possibile scrivere le relazioni sullo stato dei mari che descrivono le mareggiate nell’arco di tutto l’anno e sull’intera penisola. In queste relazioni sono presenti tutti i dati e le illustrazioni prese dal modello di previsione costiero MC_WAF che specificano più approfonditamente dove e con quale intensità la mareggiata si è verificata.

5

2.2. Python

2.2.1. Introduzione al linguaggio

Python è un linguaggio di programmazione di alto livello, interpretato, orientato agli oggetti e con una semantica dinamica. Interessante per lo sviluppo rapido di applicazioni, così come per l’utilizzo come linguaggio di scripting o come linguaggio collante per connettere assieme componenti esistenti. La sintassi semplice e facile da apprendere di Python enfatizza la leggibilità. La programmazione è modulare ed il codice è riutilizzabile. L’interprete Python e l’estesa libreria standard sono disponibili sia come sorgente che in forma binaria. Python è un linguaggio interpretato che si distingue dal linguaggio compilato (es. C/C++):

Figura 1. Linguaggi interpretati e compilati

La differenza tra i 2 linguaggi sta nel processo di compilazione che è costituito da diverse fasi:

Figura 2. Processo di compilazione

6

E’ possibile definire i linguaggi distinguendoli anche per utilizzo o per caratteristiche macroscopiche:

- i linguaggi compilati adottano una tipizzazione statica e debole e cioè che una variabile può essere associata a diversi oggetti purché questi oggetti abbiano tutti lo stesso tipo (il tipo di dato può essere ignorato);

- i linguaggi interpretati adottano una tipizzazione dinamica e forte e cioè che una variabile può essere associata a più dati differenti ma solo se i tipi di dati sono coerenti tra loro.

Un linguaggio interpretato, e quindi lo stesso Python, prevede almeno 2 componenti fondamentali:

- interprete; - set di librerie base.

Python è costituito da una serie di moduli, forniti dall’installazione di base oppure aggiunti esternamente, che vengono importati grazie al comando di sistema from/import. I moduli sono raggruppati da pacchetti che hanno una struttura gerarchica rappresentata da directory. In Python tutto è un oggetto e quindi anche i moduli stessi e ovviamente anche le classi di modulo. E’ possibile perciò guardare nel modulo e interrogare i suoi dati membro o conoscere la documentazione su una generica funzione.

Figura 3. Struttura dell’oggetto

7

2.2.2. Tipi di dato

Python è un linguaggio dinamicamente e fortemente tipato. E’ possibile associare ad

un oggetto un nome simbolico che non necessita di essere dichiarato detto

“Identificatore”. In Python non esistono dichiarazioni esplicite di variabili ma vengono

create nel momento dell’assegnamento e distrutte all’uscita dello scope.

Python dispone di due tipologie di dato:

1) dati semplici:

– Int

– Long

– Float

– Complex

– String

2) contenitori:

– Tuple ()

– List []

– Dict {}

– Set

Il linguaggio mette a disposizione quattro tipi numerici di dato:

Integer (interi)

Long Integer (interi grandi)

Floating point number (reali)

Complex number (complessi)

Il modulo math fornisce le più comuni funzioni matematiche tra cui quelle

trigonometriche, potenze e logaritmi e trasformazione angoli.

Si usa il tipo bool per rappresentare valori booleani. Una variabile di tipo bool può

assumere valori TRUE e FALSE che possono essere interscambiati con i valori 1 e 0

rispettivamente.

Una stringa letterale è una sequenza di caratteri racchiusa tra doppi o singoli apici.

Per accedere al singolo carattere si può ricorrere all’operatore []. Non è possibile

modificarlo ma è possibile assegnare alla stringa un nuovo valore. Attraverso

operatori matematici, logici o metodi built in è possibile manipolare o formattare la

stringa.

8

In Python i tipi sono individuati senza necessità di dichiarazione all’interno del

codice.

Creazione di una variabile: la variabile viene creata quando le si assegna un

valore.

Tipo di una variabile: il tipo è associato all’oggetto non alla variabile.

Uso di una variabile: quando una variabile appare in un’espressione viene

rimpiazzata dall’oggetto associato.

Figura 4. Creazione, tipo e uso di una variabile

2.2.3. Costrutti

L’insieme dei costrutti che servono a gestire il flusso di esecuzione del programma è

detto “Control Flow” (strutture di controllo). I costrutti possono essere classificati in:

costrutti condizionali;

costrutti iterativi;

costrutti non locali;

costrutti fondamentali.

If è un costrutto condizionale: se la condizione è soddisfatta viene eseguito il blocco

di istruzioni corrispondente altrimenti si analizzano le condizioni di verità dei blocchi

elif (opzionale).

Il costrutto for è un costrutto iterativo che viene utilizzato per ripetere una suite di

istruzioni un numero definito di volte. Per iterare su una sequenza di interi, Python

dispone della funzione built-in range([start,] stop[, step]) che restituisce una lista di

interi.

Figura 5. Ciclo condizionale for

9

Il costrutto while permette di eseguire un blocco di istruzioni un numero indefinito

di volte finché una particolare espressione risulta True (condition==True).

Figura 6. Ciclo condizionale while

L’istruzione break interrompe l’esecuzione del loop. Per i cicli annidati break

interrompe esclusivamente l’esecuzione del loop più interno.

L’istruzione continue salta all’iterazione successiva di un ciclo. Nel caso di cicli annidati

continue agisce sul ciclo più interno.

Ai cicli condizionali for e while può essere associato un else statement a patto che

questi non terminino con break:

Figura 7. Cicli condizionali for e while con else statement

Il costrutto try-except permette di rilevare le eccezioni e generare except nel caso in

cui ci siano degli errori e try nel caso in cui non ce ne siano:

Figura 8. Costrutto try-except

Il costrutto try-except può avere un else-clause opzionale. L’else-clause viene eseguito

quando il costrutto try non genera eccezioni.

E’ possibile forzare la generazione di un’eccezione attraverso lo statement raise.

Figura 9. Statement Raise

10

2.2.4. Dato strutturato

Oltre ai tipi di dato del linguaggio come stringhe, interi o complessi Python fornisce

delle strutture dati del linguaggio che possono essere mutevoli o immutevoli e sono:

Liste

Tuple

Dizionari

list definisce un tipo di dato strutturato lista. Una lista può contenere

contemporaneamente elementi di diverso tipo. Gli elementi di una lista sono

contenuti tra []. L’ordinamento viene mantenuto poiché una lista non è una collezione

di dati ma una sequenza ordinata di dati. Le liste supportano l’operatore di

slicing[start:stop:step]. La funzione range() serve per generare liste di numeri interi.

Le liste sono contenitori dati modificabili. Gli oggetti di tipo lista contengono metodi

built_in per manipolare e modificare i dati membro:

Inserimento (append, insert o extend)

Ricerca (count o index)

Eliminazione (remove o pop)

Ordinamento (reverse o sort)

Le tuple sono sequenze ordinate di dati racchiusi tra (). Le tuple sono liste molto

particolari i cui elementi sono immutabili e non contengono pertanto metodi di

eliminazione, inserimento e ricerca. L’accesso al singolo elemento avviene attraverso

l’operatore []. Lo slicing[start:end] è ammesso anche sulle tuple. E’ possibile

convertire un dato tupla in un dato lista e viceversa rispettivamente attraverso le

funzioni list e tuple.

Un dictionary è un insieme non ordinato di oggetti. Ogni oggetto di un dictionary è

identificato univocamente da una key. Ogni elemento di un dictionary è

rappresentato da una coppia key–value. In Python le keys possono essere solo oggetti

immutabili: le tuple, per esempio, possono essere usate come chiavi di indicizzazione

di un dictionary. Come le tuple e le liste anche i dizionari sono tipi built-in. I dati sono

racchiusi tra { }, l’accesso al singolo elemento avviene attraverso [ ]. I dizionari

vengono manipolati attraverso le funzioni di Update ed Eliminazione (clear, pop).

Tabella 1. Liste, Tuple e Dizionari

11

Il ciclo for consente di iterare su oggetti iterabili come liste, tuple, stringhe, set,

dizionari.

Figura 10. Ciclo for per Liste, Tuple e Dizionari

Per ciclare sugli oggetti di un array (lista, tupla o stringa; in generale(containers)) si

utilizza il ciclo for. Il ciclo for per operare all’interno degli elementi del cointainers

utilizza un oggetto detto iteratore.

12

2.2.5. Funzioni

Una funzione è un blocco organizzato di codice che viene utilizzato per eseguire un

preciso task. Python dispone di funzioni built-in, print(), help(), dir() etc, ma è possibile

definire nuove funzioni. La definizione di una funzione in Python ha la seguente

sintassi:

Figura 11. Definizione funzione

Quando lo statement def viene eseguito crea una nuova function object e le assegna

un nome.

Figura 12. Definizione funzione oggetto

La funzione f1 non viene creata finché lo statement def non viene raggiunto ed

eseguito. In Python è importante distinguere tra oggetti mutabili e immutabili per

capire il passaggio di argomenti ad una funzione:

Immutabili, vengono passati per valore

Mutabili, vengono passati per referenza

E’ possibile chiamare una funzione utilizzando dei keyword arguments della forma

keyword=value. Python consente di utilizzare come parametro di funzione una lista

di lunghezza variabile di argomenti.

Con un asterisco * questi argomenti vengono mantenuti in una tupla:

Figura 13. Definizione Tupla

Con due asterischi ** questi argomenti vengono mantenuti in un dictionary:

Figura 14. Definizione Dizionario

Python permette di utilizzare una funzione come argomento di un’altra funzione

attraverso un riferimento ad un funcion-object. Le funzioni in Python sono strutture

molto flessibili: sono oggetti a tutti gli effetti. Questo consente a una funzione di

essere argomento di un’altra funzione, di essere assegnata ad una variabile etc.

13

2.2.6. File e Directory

Python dispone di funzionalità per gestire e manipolare files e directories che

lavorano su più piattaforme: ricercare files, navigare in directories, manipolare,

eliminare e rinominare files. Sono disponibili alcune funzioni built-in per le operazioni

più comuni di manipolazione dei file object:

creazione;

lettura;

scrittura;

posizione;

chiusura;

attributi.

Le operazioni di processamento di file e directory possono facilmente essere eseguite

tramite Python e sono:

modulo os.path;

modulo os;

modulo Shutil;

modulo Glob.

2.2.7. Numpy

NumPy è l’abbreviazione di Numerical Python: un’estensione del linguaggio pensata

per l’ottimizzazione della gestione di grosse moli di dati e utilizzata in ambito

scientifico. Introduce una modalità naturale ed efficiente per utilizzare array multi-

dimensionali e aggiunge una serie di utili funzioni matematiche di base. Numpy

fornisce un nuovo tipo di dato: un array N-dimensionale (ndarray), una struttura dati

omogenea. Le caratteristiche di un array sono:

size (numero elementi);

rank (numero assi);

shape (numero dimensioni);

itemsize (memoria singolo elemento).

Figura 15. Caratteristiche array

14

Ci sono diverse modalità per generare un array. La più semplice consiste nell’utilizzo

della funzione array(object, dtype=None, copy=1, order=None). L’array si crea

convertendo le altre strutture dati di Python con nuovi dtype definiti dall’utente.

Se il contenuto di un array è a priori ignoto, è utile usare funzioni per riempire in modo

sistematico l’array:

zeros, per creare array di soli zero;

ones, per creare array di soli uno;

empty, per creare array di certe dimensioni;

identity, per generare matrice identita nxn;

range, per creare una sequenza di numeri per gli array;

linspace, per generare sequenza di numeri uniformemente distribuita

compresa tra start e stop.

I metodi resize e reshape permettono di modificare la forma e la dimensione

dell’array. Il metodo reshape(shape, order=‘C’) restituisce una nuova struttura dati

ridistribuendo gli elementi dell’array secondo la nuova forma shape con ordine order

lasciando invariato il numero di elementi dell’array.

La funzione resize(new_shape, refcheck=True, order=False) permette di modificare la

forma dell’array e di ridimensionarlo. Resize funziona solo se l’array non è referenza

o non è referenziato.

Figura 16. Reshape in C e Fortran

L’accesso agli elementi di un array avviene tramite l’operatore []. Anche sugli array è

applicabile l’operatore di slicing[:] che però è profondamente differente rispetto a

quello delle liste. Nel caso delle liste la sotto-lista è una copia per valore della lista

originale mentre nel caso degli array la copia è di default per referenza.

Il nuovo array ha:

la shape dell’array di indici;

tipo e valori dell’array di partenza.

15

L’iterazione sugli elementi di un array può essere effettuata attraverso

ciclo for (lungo gli assi);

iteratore flat (su ogni elemento).

Le operazioni numeriche su un array sono operazioni elementari con scalari

attraverso operatori aritmetici, logici e di confronto. Numpy oltre alla definizione

dell’oggetto ndarray definisce anche le funzioni universali ufunc, che permettono di

operare elemento per elemento sull’intero array. NumPy offre più di 60 ufuncs:

funzioni trigonometriche, esponenziali, logaritmiche, funzioni di confronto e funzioni

floating point. E’ possibile a volte lavorare su array che non hanno le stesse

dimensioni, in questo caso si parla di broadcasting, il quale segue due regole:

– se gli array non hanno lo stesso numero di dimensioni, l’array più piccolo viene

ridimensionato fino a che entrambi gli array non hanno la stessa dimensione;

– array con dimensione ‘1’ lungo una particolare direzione si comportano come

l’array più grande lungo quella dimensione.

Figura 17. Broadcasting

Uno dei vantaggi nell’utilizzo degli array consiste nel fatto che molte operazioni

possono essere svolte evitando loop espliciti. Questo procedimento prende il nome

di vettorizzazione. L’object class array dispone di utili funzionalità implementate

come:

attributi (dtype, flat, itemsize, ndim, size e shape);

metodi (take, choose, compress, sort e transpose).

Per valutare una funzione 2D su una griglia si usa il comando meshgrid.

Figura 18. Meshgrid

16

2.2.8. Matpoltlib

Uno strumento per la grafica bidimensionale è fornito dalla libreria Matplotlib. La

libreria Matplotlib nasce per emulare in ambiente Python i comandi grafici di Matlab.

È sviluppata interamente in Python e utilizza il modulo Numpy per la rappresentazione

di grandi array.

Matplotlib è divisa in tre parti:

Pylab interface: set di funzioni fornite dal modulo Pylab;

Matplotlib API;

Backend: grafici per l’output su file e visuali per l’output su interfacce grafiche.

Matplotlib è disegnata per la programmazione object oriented da cui si possono

definire oggetti per colours, lines, axes, etc.

Ci sono 2 modi per usare Matplotlib:

object-oriented way: Il modo Pythonico di lavorare con Matplotlib. Il modulo

pyplot fornisce un'interfaccia alla libreria matplotlib;

pylab: un modulo che unisce Matplotlib e NumPy in un ambiente simile a

Matlab.

L’interfaccia Pylab costituisce il modo più semplice per lavorare con Matplotlib. Le

funzioni sono molto simili all’ambiente Matlab.

La funzione figure() istanzia un oggetto figura.

La funzione close(n) chiude la finestra n.

La funzione show() visualizza tutte le figure.

Figura 19. Interfaccia Pylab

17

Le principali entità su cui lavorare sono:

figure, per gestire e creare un numero arbitrario di figure;

plot e subplot, per creare grafici specificando stile e numero di colonne e righe;

line2D, per modificare dimensione stile colore etc.;

text, per gestire stringhe di testo all’interno di grafici;

axes, per gestite gli assi (simile a subplot).

Figura 20. Plot, figure, line2D, text e axes

18

2.2.9. Sviluppi di Python

Una volta acquisite le competenze per l’uso di Python, è stato possibile valutare gli

sviluppi del programma utilizzando le nozioni apprese durante il corso di formazione.

L’argomento affrontato ha riguardato “L’energia del moto ondoso nel Mar

Mediterraneo”. Per poter determinare l’energia del moto ondoso è stato necessario

importare la mappa del Mar Mediterraneo tramite il comando import basemap oltre

al modulo Numpy per le funzioni matematiche e al modulo Matplotlib per la grafica

bidimensionale. Successivamente, è stata realizzata una funzione per poter valutare

l’energia del moto ondoso che dipende dalla latitudine e longitudine, dalla profondità

del fondale marino e dalla celerità del moto ondoso lungo le due coordinate.

E’ stato così possibile determinare, in un certo istante e in qualsiasi punto, l’energia

del moto ondoso lungo tutta la superficie del Mar Mediterraneo

Figura 22. Energia del moto ondoso nel Mar Mediterraneo

19

2.3. Latex

2.3.1. Descrizione del linguaggio

Latex è un linguaggio di scrittura usato per la preparazione di testi basato sul

programma di composizione tipografica TEX. Fornisce funzioni di desktop publishing

programmabili e mezzi per l'automazione della maggior parte della composizione

tipografica, inclusa la numerazione, i riferimenti incrociati, tabelle e figure,

organizzazione delle pagine, bibliografie e molto altro.

I documenti redatti con LaTeX possono essere scritti utilizzando diverse classi:

book, per realizzare libri;

article, per articoli, soprattutto scientifici;

letter per lettere;

report;

slides per creare presentazioni.

Un documento si compone di due parti principali: il preambolo ed il corpo del

documento vero e proprio. Nel preambolo sono contenute le istruzioni principali

relative alla struttura del documento (la lingua, il formato della pagina, il numero di

colonne ecc.). Segue il corpo del documento vero e proprio, che è tutta la parte di

testo compresa fra le istruzioni \begin{document} e \end{document}.

All’inizio di un documento in Latex è previsto il preambolo che comincia con il

comando \documentclass{…} che specifica il tipo di documento da scrivere con la

classe, il tipo di foglio e il carattere.

Successivamente, per caricare i pacchetti da utilizzare riguardanti lingua, testo, grafici,

tabelle ecc. si utilizza il comando \usepackage{…}. Infine, per determinare lo stile della

pagina, e quindi i piè di pagina, si usa il comando \pagestyle{style}.

Il corpo del documento prevede l’autore (\author{…}), il titolo (\title{…}), il sottotitolo

(\maketitle{}) e i capitoli (\section{…}) e sottocapitoli (\subsection{…}) se presenti.

Alcuni dei comandi principali sono \\ o \newline per andare a capo e \newpage per

cambiare pagina. Altri riguardano il carattere e sono \underline{…} per sottolineare il

testo e \emph{…} per scrivere in corsivo. Per inserire le tabelle si usano i comandi

\begin{table}[pos] e \begin{tabular}[pos]{table spec}, con pos che può essere t, b o c

a seconda che il testo si trovi in alto, in basso o al centro della cella e table spec che

può essere l, r o c a seconda che il testo si trovi a sinistra, a destra o al centro della

cella. Per inserire invece le figure i comandi da dare a Latex sono \begin{figure}[pos]

con pos che può essere h,b,p o ! a seconda che sia al centro, in basso, in alto o non ci

sia. Mentre per i grafici il comando è \includegraphics[key] con key che specifica

larghezza, altezza, rotazione e scala del grafico da inserire.

20

3. Studio per la determinazione delle mareggiate nei mari italiani

3.1. Introduzione

Una volta acquisite le competenze necessarie in ambito informatico, l’obiettivo è

stato quello di studiare e valutare con il Metodo dei Picchi sopra soglia (POT) le

mareggiate nei mari italiani in un anno nel periodo tra Maggio 2017 e Aprile 2018

grazie al modello di previsione costiero MC_WAF fornito dall’ISPRA e al linguaggio di

programmazione Python. MC_WAF ha fornito accurate previsioni dello stato del mare

in specifiche aree costiere del Mediterraneo e nello specifico in corrispondenza delle

15 boe ondametriche della Rete Ondametrica Nazionale (RON) posizionate su

determinati punti della penisola italiana. E’ stato così possibile, grazie al seguente

modello, la determinazione dei parametri fondamentali che descrivono una

mareggiata: l’altezza d’onda significativa, il periodo di picco, il periodo medio, la

direzione di provenienza delle onde e il tempo di ritorno. Grazie alla

georeferenziazione delle mappe del Mediterraneo è stato possibile recuperare questi

dati attraverso degli script su Python per poi generare delle tabelle in Latex con i

parametri sopracitati e i grafici di altezza d’onda rispetto al tempo in relazione a un

singolo mese.

21

3.2. Sistema di previsione costiero MC_WAF

L’obiettivo del sistema di previsione marino-costiero MC_WAF (Mediterranean Coastal Wave Forecasting System) è di fornire accurate previsioni dello stato del mare

in specifiche aree costiere del Mediterraneo secondo uno schema che prevede l’utilizzo di due modelli d’onda di terza generazione, in tre livelli di cascata: dalla grande scala (Mar Mediterraneo), alla scala regionale e quindi alla scala costiera. Il WAM (Wave Model) copre tutto il Mediterraneo e produce condizioni "al contorno" sulle aree a scala regionale. Nelle sotto-aree viene impiegato ancora il WAM ma a risoluzione doppia rispetto al modello a grande scala. Lo

SWAN utilizza i risultati del WAM alla scala regionale come condizioni al contorno per simulare i processi fisici legati alla propagazione delle onde in aree costiere ed acque basse. L’operatività di MC_WAF permette non solo di integrare il sistema di monitoraggio costiero dell’ISPRA con la previsione a medio termine dello stato del mare, ma consente anche di sviluppare studi e applicazioni di lungo periodo inerenti la dinamica costiera, l’erosione, l’ingegneria costiera e la biologia marina. La struttura del sistema MC_WAF è ideata in modo da essere facilmente modificabile, permettendo l’inserimento di nuove griglie di calcolo in funzione delle diverse esigenze. La predisposizione delle griglie di calcolo segue lo schema, già ampliamente testato in un anno di simulazioni partendo dalla griglia generale su tutto il Mediterraneo (risoluzione 1/30 di grado). Le griglie sono state scelte in modo da coprire la costa tirrenica e la costa orientale della Sicilia. Sono state definite dimensioni e posizione di sei griglie di calcolo, due delle quali sono operative da marzo 2012 (G1 e G4), tutte le altre operano da luglio 2012.

Figura 23. Griglie di calcolo penisola italiana

22

A scala costiera, l’individuazione delle aree a maggiore risoluzione dipende dalle necessità applicative dell’ISPRA e dalla disponibilità di batimetrie ad alta risoluzione. Al momento sono parte attiva del sistema le tre griglie costiere annidate alla griglia regionale G1 (Marina di Carrara, Isola d’Elba ed Isola del Giglio) e due griglie costiere nella griglia G4, Terracina e Golfo di Napoli.

Figura 24. Griglie di calcolo Mar Tirreno Centro-Settentrionale

Le previsioni del vento utilizzate nel sistema MC_WAF sono prodotte dal modello meteorologico Bolam2011 del SIMM (Sistema Idro-Meteo-Mare) dell’ISPRA. Il dominio d’integrazione del SIMM permette di fornire le previsioni meteorologiche sull’intero Mare Mediterraneo con un passo di griglia di circa 10 km ogni ora. Per il modello a grande scala e per le aree regionali sono state utilizzate le carte batimetriche GEBCO (General Bathymetry Chart of Oceans) della BODC (British Oceanographic Data Centre) con risoluzione 1/2 grado. Per la scala costiera, in cui sono determinanti i processi di interazione tra onda e fondale come la rifrazione, lo shoaling ed il frangimento, è di fondamentale importanza la batimetria utilizzata. Per questo motivo le batimetrie a scala costiera sono state integrate con le mappe digitali dell’Istituto Idrografico della Marina e con ulteriori apporti forniti da diverse istituzioni a seconda dell’area costiera in esame.

23

3.3. Metodo POT (Durate Parziali Sopra Soglia)

La prima fase da affrontare in un’analisi rivolta alla previsione delle massime altezze d’onda in un determinato arco temporale prevede la selezione dei dati omogenei e indipendenti tra quelli disponibili. Le popolazioni statistiche estratte dai dati osservati possono essere distinte in due

diversi tipi, a seconda del procedimento seguito per la loro formazione: il primo

prevede il campionamento regolare della serie osservata e genera una popolazione

temporalmente aggregata; l’altro prevede un campionamento ad evento e quindi

genera una popolazione temporalmente disaggregata. Il primo procedimento è

riconducibile al metodo del campione totale (Goda, 1988), il secondo è riconducibile

al Metodo delle Durate Parziali Sopra Soglia (“Peak Over Threshold ” - Goda, 1988) o

al Metodo dei Massimi Annuali. Il metodo del campione totale non assicura a priori

né l’indipendenza né l’omogeneità dei dati che formano il campione. Al contrario, il

Metodo delle Durate Parziali Sopra Soglia, grazie alla definizione di opportuni criteri

d’individuazione degli eventi, permette la cernita di dati sia omogenei sia

indipendenti. L’indipendenza campionaria della serie dei colmi è assicurata

imponendo un valore di soglia per l’intervallo che intercorre tra due mareggiate

successive. Per far sì che i dati risultino indipendenti, l’intervallo tra un evento e il

successivo deve essere maggiore di 48 ore, selezionando solo il valore culmine della

mareggiata. Affinché i dati siano anche omogenei oltre che indipendenti, sono

utilizzati nelle analisi soltanto i valori superiori ad una seconda soglia d’altezza d’onda

posta nel nostro caso a 2 m.

Grafico 2. Altezza d’onda significativa in un mese

Infine, se l’omogeneità climatica può essere ottenuta con il metodo delle serie di

durata parziale, l’omogeneità direzionale può essere garantita imponendo

l’appartenenza della direzione media di provenienza della mareggiata a determinati

settori direzionali.

24

Al fine di individuare tali settori direzionali per ogni boa della RON, si sono prese in

considerazione diverse informazioni:

la conformazione delle aree di generazione del moto ondoso sottese da

ciascuna boa (distribuzione dei fetch geografici);

la distribuzione direzionale della frequenza di accadimento delle osservazioni;

la distribuzione direzionale dei colmi di mareggiata e della loro frequenza di

accadimento.

Sia la frequenza di accadimento dei dati osservati, sia quella dei colmi di mareggiata

possono essere calcolate imponendo diversi valori della soglia di troncamento (1.0m,

2.0m, 3.0m). Questi valori saranno poi utili nelle relazioni sullo stato dei mari italiani

per la realizzazione della “Tabella a due ingressi” in cui si ha una distribuzione

congiunta di altezza d’onda significativa e direzione di propagazione delle onde con la

relativa frequenza di accadimento.

25

3.4. Script di Python

Una volta definiti i criteri d’individuazione degli eventi con il Metodo delle durate parziali sopra soglia (POT) con cui selezionare i dati più rilevanti ai fini dello studio e della valutazione delle mareggiate sull’intera penisola italiana, si è proceduto per ogni mese con l’esecuzione di 3 script su Python realizzati dall’ISPRA: 1) mod_report.py, per generare il grafico di altezza d’onda rispetto al tempo; 2) mktable.py, per generare le tabelle a due ingressi in Latex che mettono in

relazione altezza d’onda significativa e direzione di propagazione delle onde con la relativa frequenza di accadimento;

3) mkreport.py, per generare la relazione sullo stato dei mari italiani insieme alla relativa tabella con l’elenco delle mareggiate in Latex.

Lo script principale è il terzo perché, tramite l’istruzione import, carica anche i primi 2 script permettendo, una volta eseguito, la generazione dei grafici e delle tabelle suddette. Questo processo è fondamentale visto che permette la determinazione dei valori di altezze d’onda significative, periodi di picco, periodi medi, direzioni di provenienza e tempi di ritorno delle mareggiate occorse durante tutto l’arco del mese, fondamentali per la conoscenza degli eventi di mareggiata e di seguito riportati nella stesura della relazione. Il tutto è stato reso possibile dal sistema di previsione costiero MC_WAF che ha predetto le mareggiate durante tutto l’arco temporale in cui si è compiuto lo studio. La georeferenziazione delle mappe del Mar Mediterraneo da parte di Python ha consentito di conoscere per ogni ora tutto quello che è successo sulle coste italiane dal punto di vista del moto ondoso e quindi le mareggiate occorse nei mari italiani nei mesi analizzati, prendendo come riferimento le posizioni delle boe RON. Tale scelta ha permesso, in buona parte dei casi, di poter valutare gli eventi in relazione al clima ondoso osservato.

26

4. Stesura delle relazioni sullo stato dei mari italiani

4.1. Introduzione

Conoscendo il linguaggio di scrittura Latex, in base alle tabelle generate in Python è

stato possibile redigere le relazioni sullo stato dei mari che descrivono le mareggiate

nell’arco di tutto l’anno sull’intera penisola. In queste relazioni, sono presenti tutti i

dati e le illustrazioni presi dal modello di previsione costiero MC_WAF che specificano

più approfonditamente dove e con quale intensità la mareggiata si è verificata. Si è

proceduto così con la stesura delle relazioni su Latex dopo aver osservato le

mareggiate occorse nei singoli mesi sul sistema di previsione costiero MC_WAF

presente sul sito dell’ISPRA. L’arco temporale analizzato è stato pari ad un anno ed è

durato da Maggio 2017 ad Aprile 2018 riscontrando eventi estremi come

immaginabile soprattutto nella stagione invernale. Delle 12 relazioni redatte (una per

ogni mese) cito la relazione sullo stato dei mari italiani del mese di Maggio 2017.

27

4.2. Relazione sullo stato dei mari italiani Maggio 2017

4.2.1. Descrizione generale delle mareggiate occorse nel mese

Durante il mese di maggio 2017 sono stati previsti tre episodi mareggiata. Il primo

episodio, previsto tra il 6 ed il 8 maggio ha interessato la parte occidentale della

Sardegna, il Mar Tirreno e il Canale di Sicilia. Le onde più alte sono state previste ad

Alghero con 𝐻𝑚0 = 3.6 𝑚 e Mazara del Vallo con 𝐻𝑚0 = 3.3 𝑚, valori in linea con il

clima ondoso atteso. Il secondo caso, tra il 19 ed il 20 maggio, ha interessato il Mar

Ligure, il Mar Tirreno Centrale ed in parte le coste occidentali della Sardegna. Le onde

più alte sono state previste a La Spezia con 𝐻𝑚0 = 3.1 𝑚 e a Ponza con 𝐻𝑚0 = 2.7 𝑚,

inferiori ai massimi annuali localmente attesi. L'ultimo episodio, di breve durata e

fortemente localizzato nell'Adriatico Meridionale, è comunque di un certo interesse

avendo previsto a Monopoli un'altezza significativa 𝐻𝑚0 = 4.1 𝑚 con tempo di

ritorno di 1,5 anni.

Grafico 3. Altezza d’onda significativa Maggio 2017

28

4.2.2. Episodio 6-8 Maggio: Mar Tirreno, Mar di Sardegna e Canale

di Sicilia

La mareggiata ha avuto inizio il 6 maggio con un caso di Mistral dal Golfo del Leone, e

si è propagata attraverso le Bocche di Bonifacio fino alle coste del Mar Tirreno. Sono

state previste onde con 𝐻𝑚0 = 2.5 𝑚 a Civitavecchia e 𝐻𝑚0 = 2.6 𝑚 a Ponza. Il

giorno successivo i fenomeni hanno interessato prima il Canale di Sardegna, facendo

registrare ad Alghero un'altezza d'onda 𝐻𝑚0 = 3.6 𝑚, poi il Canale di Sicilia dove il

modello ha previsto 𝐻𝑚0 = 3.3 𝑚 a Mazara.

Figura 27. MCWAF ISPRA - altezza significativa 𝑯𝒎𝟎

Mar Mediterraneo

29

Figura 28. MCWAF ISPRA - altezza significativa 𝑯𝒎𝟎

Mar Tirreno Centrale

Figura 29. MCWAF ISPRA - altezza significativa 𝑯𝒎𝟎

Mar di Sardegna

30

Figura 30. MCWAF ISPRA - altezza significativa 𝑯𝒎𝟎 Canale di Sicilia

31

4.2.3. Episodio 19-20 Maggio: Mar Ligure e Mar Tirreno Centrale

Un ulteriore caso di Mistral ha caratterizzato la mareggiata proveniente dal Golfo del

Leone, prevista la notte del 19 maggio nel Mar Ligure, con 𝐻𝑚0 = 3.1 𝑚 a La Spezia.

La stessa si è propagata anche attraverso le Bocche di Bonifacio fino a lambire le coste

Tirreniche, facendo registrare a Ponza un'altezza d’onda significativa 𝐻𝑚0 = 2.7 𝑚.

Tutte le condizioni previste sono risultate in linea con il clima ondoso atteso.

Figura 31. MCWAF ISPRA - altezza significativa 𝑯𝒎𝟎

Mar Mediterraneo

Figura 32. MCWAF ISPRA - altezza significativa 𝑯𝒎𝟎

Mar Ligure

32

Figura 33. MCWAF ISPRA - altezza significativa 𝑯𝒎𝟎 Mar Tirreno Centrale

33

4.2.4. Episodio 25 Maggio: Mar Adriatico Meridionale

La mareggiata del 25 maggio ha interessato esclusivamente la zona dell'Adriatico

Meridionale. L'episodio, caratterizzato da una breve durata (8 ore), ha raggiunto

un'altezza massima a Monopoli di 𝐻𝑚0 = 4.1 𝑚, valore superiore al massimo annuale

localmente atteso.

Figura 34. MCWAF ISPRA - altezza significativa 𝑯𝒎𝟎

Mar Mediterraneo

Figura 35. MCWAF ISPRA - altezza significativa 𝑯𝒎𝟎

Mar Adriatico Meridionale

34

4.2.5. Elenco mareggiate

In Tab. sono elencate tutte le mareggiate occorse nei mari italiani nel mese di Maggio

2017, prendendo come riferimento le posizioni delle boe RON. Tale scelta permette,

in buona parte dei casi, di poter valutare gli eventi in relazione al clima ondoso

osservato. In questa tabella la direzione Dir [°N] indica la direzione di provenienza

delle onde (convenzione meteorologica).

Tabella 2. Elenco Mareggiate

35

4.2.6. Tabella a due ingressi

Si allegano infine le tabelle a due ingressi o Joint Frequency Functions (JFF) di altezza

significativa e direzione a la Spezia e Monopoli per il mese di maggio 2017. Dalle

statistiche si può osservare la distribuzione congiunta di altezza e direzione delle

onde, che caratterizza il clima ondoso mensile. In queste tabelle la direzione Dir [°N]

indica la direzione di propagazione delle onde (convenzione marina).

Tabella 3. Tabella a 2 ingressi (JFF) La Spezia

Tabella 4. Tabella a 2 ingressi (JFF) Monopoli

36

5. Bibliografia

Oetiker T., Partl H., Hyna I and Schlegl E., “The Not So Short Introduction to LATEX”.

Langtangen H. P., “A Primer on Scientific Programming with Python Scripting”.

Corsini S., Franco L., Inghilesi R. and Piscopia R., “Atlante delle Onde nei Mari Italiani

Italian Wave Atlas”.

Inghilesi R. “Statistical Analysis of Extreme Waves on the Italian Coasts from 1989 to

1999”.

Franco L., “Analisi Statistica delle Onde Estreme”.

Bellotti G., “La statistica a Lungo Termine del Moto Ondoso secondo la DNV‐RP‐C205”.

Mathiesen M., “Recommended Practice for Extreme Wave Analysis”.

Martucci G., Carniel S., Chiggiato J., Sclavo M., Lionello P., and Galati M. B., “Statistical

Trend Analysis and Extreme Distribution of Significant Wave Height from 1958 to 1999

– an Application to the Italian Seas”.

World Meteorological Organization 2008, “Guide to Hydrological Practices”.

http://www.isprambiente.gov.it/pre_mare/coastal_system/html/info.html ,

“Il Sistema di Previsione Marino-Costiero”.

http://www.isprambiente.gov.it/pre_mare/coastal_system/maps/med/mediterraneo.

html, “Previsioni dello Stato del Mare nel Mar Mediterraneo”.