il modello numerico openfoam - … · corso di laurea magistrale in ingegneria civile per la...

�

CORSO DI LAUREA MAGISTRALE IN

INGEGNERIA CIVILE PER LA PROTEZIONE DAI RISCHI NATURALI

RELAZIONE DI FINE TIROCINIO

IL MODELLO NUMERICO OpenFOAM®

PER LO STUDIO DEGLI TSUNAMI

Tutor: Prof. Giorgio Bellotti Tirocinante: Giacomo Cipollina Matricola: 451978

II

Sommario

Nella presente relazione viene descritto il funzionamento del software di calcolo OpenFOAM®. Esso è stato impiegato nel corso dello studio di tesi per l’analisi di onde di tsunami indotte da frana. In particolare, attraverso di esso, è stata ricreata e analizzata l’onda di tsunami, indotta da una frana magmatica, che si è verificata a Stromboli, Isole Eolie, il 30 dicembre del 2002. Ivi si riporta una breve introduzione storica sugli tsunami e su come siano stati studiati e modellati fino ad ora. Una più ampia trattazione, riguardante il modello numerico, la sua struttura, il suo funzionamento, la realizzazione di casi eseguibili e degli strumenti che sono stati impiegati per l’analisi dei risultati, è invece riportata nel seguito della trattazione.

Keywords Landslides tsunamis • Physical modeling •C++ • OpenFOAM®

III

Indice

Sommario ............................................................................................................... II�

Indice delle figure .................................................................................................. V�

Capitolo 1 Tsunami................................................................................................. 1�

1.1 Tsunami da Frana .......................................................................................... 2�

Capitolo 2 OpenFOAM ........................................................................................... 4�

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

2.2 Installazione del programma .......................................................................... 5�

2.3 Struttura del programma ............................................................................... 6�

Capitolo 3 Struttura delle cartelle di OpenFOAM® ................................................ 8�

3.1 Struttura dei file all’interno delle cartelle di OpenFOAM® ........................... 8�

3.2 Formato base dei files di input/output .......................................................... 9�

Capitolo 4 Avviare la procedura o eseguire il run ................................................ 12�

4.1 Running delle applications ........................................................................... 12�

4.2 Eseguire l’applicazione in parallelo .............................................................. 13�

Capitolo 5 Modellazione e generazione della Mesh .............................................. 16�

5.1 Descrizione della Mesh ................................................................................. 16�

5.2 Lo strumento cellShape ................................................................................ 17�

5.3 Generazione della mesh con lo strumento blockMesh ................................. 19�

5.4 Generazione della mesh mediante snappyHexMesh ..................................... 21�

Capitolo 6 Il modello e le sue proprietà fisiche .................................................... 23�

6.1 Condizioni al contorno ................................................................................. 23�

6.2 Modelli di turbolenza ................................................................................... 24�

6.3 Controllo temporale e dei dati in input/output........................................... 24�

6.4 Schemi numerici ........................................................................................... 25�

6.5 Il post-processing ......................................................................................... 26�

6.6 Nozioni su ParaView .................................................................................... 26�

Capitolo 7 Esempi applicativi ed esecutivi ........................................................... 28�

7.1 Tutorial onda di Stokes del V ordine ........................................................... 28�

7.1.1 Cartella 0.orig ......................................................................................... 30�

IV

7.1.2 Cartella costant ...................................................................................... 34�

7.1.3 Cartella system ....................................................................................... 38�

7.1.1 Avviare il run ......................................................................................... 44�

7.1.2 Visualizzare i risultati ............................................................................ 45�

7.2 Onda di Stokes del V ordine su fondale variabile ........................................ 47�

7.2.1 Realizzazione della rampa con Blender .................................................. 47�

7.2.2 Risultati del run ..................................................................................... 50�

7.3 Generazione d’onda alla Scott Russell. ........................................................ 51�

7.4 Tsunami indotto da frana ............................................................................ 53�

Capitolo 8 Conclusioni .......................................................................................... 55�

Bibliografia ............................................................................................................ 56�

Link di riferimento per i software open source ..................................................... 57�

Elenco dei programmi utilizzati ............................................................................ 58�

��

V

Indice delle figure

Figure 1 Possibili sorgenti di innesco di uno tsunami ............................................ 1�Figure 2 Frana sommersa (submerged) e costiera (sub-aerial) ............................... 2�Figure 3 Panoramica della struttura di OpenFOAM® ........................................... 6�Figure 4 Struttura della generica cartella Case in OpenFOAM® ............................ 8�Figure 5 Verso del vettore a partire dalla numerazione della faccia da esso attraversata ........................................................................................................... 17�Figure 6 Vertici, facce e numerazione per del cellShape ...................................... 19�Figure 7 Degenerazione di un esaedro in un pentaedro ........................................ 20�Figure 8 Rappresentazione di un blocco generico ................................................. 20�Figure 9 Schematizzazione 2D di una mesh impiegando snappyHexMesh ........... 21�Figure 10 Processo di mesh con snappyHexMesh ................................................ 21�Figure 11 Esempio dei parametri all'interno del controlDict ............................... 25�Figure 12 Principali schemi impiegati nell' fvSchemes ......................................... 26�Figure 13 Aspetto della finestra di ParaView ...................................................... 27�Figure 14 Diagramma di Le Mauthé per analisi della teoria ondosa .................... 29�Figure 15 Percorso della cartella "waveExampleStokesV" ................................... 29�Figure 16 Organizzazione dei file nelle sottocartelle ............................................. 30�Figure 17 Schermata del file alpha.water ............................................................. 31�Figure 18 Schermata del file p_rgh ...................................................................... 32�Figure 19 Schermata del file U ............................................................................. 33�Figure 20 Schermata del file g .............................................................................. 34�Figure 21 Schermata del file con le caratteristiche del trasporto ......................... 35�Figure 22 Schermata del file con le caratteristiche turbolente ............................. 36�Figure 23 Schermata del file riportante le proprietà d'onda ................................ 37�Figure 24 Schermata del file blockMesh ............................................................... 39�Figure 25 Schermata del file controlDict .............................................................. 41�Figure 26 Schermata del file decomposeParaDict ................................................ 42�Figure 27 Schermata del file setFieldDict ............................................................. 43�Figure 28 File Allrun ............................................................................................ 44�Figure 29 File Allclean .......................................................................................... 45�Figure 30 Cartelle e files in un case dopo un Run ................................................ 45�Figure 31 Mesh e discretizzazione del dominio..................................................... 46�Figure 32 Interfaccia aria-acqua in condizione indisturbata ................................. 46�Figure 33 Interfaccia aria-acqua con stato ondoso ................................................ 47�Figure 34 Generazione dell'oggetto Cube ............................................................. 48�Figure 35 Roto-traslazione del cubo dall'orgine del sistema................................. 49�Figure 36 Cubo deformato e trasformato in rampa .............................................. 49�

VI

Figure 37 Rampa con mesh infittita ..................................................................... 49�Figure 38 Griglia di calcolo del canale con rampa ................................................ 50�Figure 39 Profilo superficie libera indisturbata .................................................... 50�Figure 40 Accentuazione della cresta e conseguente frangimento ........................ 51�Figure 41 Modello di Scott Russell ....................................................................... 52�Figure 42 Rappresentazione del problema di Scott Russell nel modello numerico e propagazione ondosa ............................................................................................. 52�Figure 43 Rappresentazione del problema pseudo-Scott Russell nel modello numerico e propagazione ondosa .......................................................................... 53�

1

Capitolo 1 Tsunami

In natura uno dei fenomeni più distruttivi che si possa presentare è lo tsunami. La parola giapponese tsunami ( lett. “onda di porto”) è stata adottata dalla comunità scientifica per descrivere le onde di mare, anomale, indotte dalle azioni sismiche, dalle frane, dalle eruzioni vulcaniche e dai meteoriti. Di seguito è riportato uno schema che concettualmente rappresenta le possibili modalità di formazione degli tsunami.

Figure 1 Possibili sorgenti di innesco di uno tsunami

Il principale meccanismo, responsabile della generazione degli tsunami, risulta essere il terremoto, i.e. l’azione tettonica che causa la deformazione del fondale oceanico. Questa si presenta allorquando un vulcano sottomarino erutta, frattura il fondale e innalza una piattaforma oceanica rispetto all’altra. Il volume d’acqua che viene movimentato, che crea l’onda di tsunami, è paria al volume di placca che si solleva. Normalmente questa tipologia di onda si crea a largo, a migliaia di chilometri dalle coste, con altezza d’onda prima impercettibile ma che, nel propagarsi verso riva, attraverso il fenomeno di shoaling, raggiunge altezze di 10- 15 metri e lunghezza d’onda dell’ordine delle centinaia di metri. A largo la celerità con cui viaggiano queste onde è dell’ordine dei 1000km/h e il periodo è di 20/30 minuti, per tale ragione possono essere rilevate solamente da particolari sonde di pressione che vengono disposte sui fondali oceanici. Non si pensi però che gli tsunami possano formarsi solamente nelle aree oceaniche. Essi possono formarsi anche in specchi d’acqua più piccoli, come il Mediterraneo o addirittura all’interno di laghi. Normalmente, perché si sviluppino in queste condizioni, enormi frane devono impattare e alterare tali specchi.

2

1.1 Tsunami da Frana

Gli tsunami che possono formarsi in natura, dunque, non sono dovuti solamente ai terremoti e alle eruzioni sottomarine ma anche alle frane. Quest’ultime possono essere costiere (sub-aerial landslides) o sottomarine (submerged landslides). Nondimeno, le onde che possono formarsi con questi inneschi hanno caratteristiche potenzialmente più distruttive di quelle descritte nel precedente paragrafo. Talvolta vengono riconosciuti e chiamati Mega tsunami per via dell’altezza d’onda che viene raggiunta. Essa può essere molte volte maggiore di quella raggiunta dagli tsunami di terremoto. Nella figura riportata di seguito (Bellotti, et al., 2006) si può vedere come, in uno tsunami da frana, a seconda della sua tipologia, l’onda che va generandosi è preceduta: nel caso di frana sommersa, da un cavo (depression) e, nel caso di frana costiera, da una cresta (superelevation).

Figure 2 Frana sommersa (submerged) e costiera (sub-aerial)

Enormi volumi di materiale lapideo possono distaccarsi, rotolare o scivolare negli specchi d’acqua limitrofi ad alte velocità e generare delle onde catastrofiche che portano alla distruzione di tutto ciò che si trovi nelle vicinanze. Relativamente agli tsunami che possono formarsi nei laghi, si riporta un evento tragico. Si parla infatti del disastro del Vajont (Italia). In questa occasione sono morte 1910 persone, era il 9 ottobre 1963. Qui una frana di circa 270 milioni di m3 di roccia si è staccata dal sovrastante Monte Toc ed è scivolata per 500m nel sottostante lago artificiale (realizzato a scopo idroelettrico) ad una velocità di circa 30 m/s. Questo evento, durato non più 45 secondi, ha generato un’onda che ha superato di 250m il coronamento della diga.

3

Relativamente agli tsunami nel Mar Mediterraneo si può far riferimento a svariati eventi verificatisi nei secoli passati, ma anche all’evento verificatosi il 30 dicembre del 2002 a Stromboli, l’isola vulcanicamente attiva delle Eolie (Sud del mar Tirreno, Italia). L’evento, accaduto nel versante nord-ovest dell’isola, detto “Sciara del Fuoco”, è stato scaturito da una frana magmatica e lapidea. Quest’ultima ha generato, con l’impatto nell’acqua, le onde che hanno inondato e distrutto parte degli abitati dell’isola (Di Risio, et al., 2011) e mandato in risonanza (come onde di sessa) i porti calabresi adiacenti. In questa occasione fortunatamente non si sono contanti né morti né feriti. Tuttavia, non è da escludersi che in futuro un tale evento possa ripresentarsi in forma tanto lieve. Nella presente relazione si illustra pertanto il funzionamento del programma che è stato impiegato nel corso della tesi per la modellazione delle onde di tsunami generate da frane aere, facendo riferimento all’evento di Stromboli. �

4

Capitolo 2 OpenFOAM

2.1 Introduzione

Nel seguente capitolo viene presentato il software di calcolo che è stato impiegato per lo studio delle onde di tsunami per meglio dire l’argomento della tesi. In particolare, di seguito si riportano alcuni cenni storici e la struttura con cui è

organizzato OpenFOAM®; nei paragrafi successivi, invece, si trattano con maggiore

cura i comandi e gli step che sono stati impiegati per studiare il problema vero e proprio.

OpenFOAM®, che rappresenta l’acronimo anglosassone di “Open Field Operation And Manipulation”, è un programma open source scritto nel linguaggio di programmazione C++. Originariamente sviluppato negli anni 80’ nell’ Imperial College, Londra, con l’obiettivo di creare una piattaforma di calcolo più versatile e flessibile rispetto a quella che allora rappresentava l’unica alternativa (Fortran). Da allora il programma è stato rivisitato e riscritto più volte. Un aggiornamento dello stesso viene rilasciato ogni sei mesi (la versione impiegata nel corso della tesi è la v-1712). Prima che divenisse un software open source (2004) veniva venduto con il nome di FOAM dalla compagnia inglese Nabla Ltd. Esso, per essere utilizzato, necessita di un sistema operativo Ubuntu. Nella presente tesi, in particolare, è stato impiegato sia un PC personale con sistema operativo Windows sia un PC fisso, gentilmente messo a disposizione dall’università IH Cantabria, dove è stata condotto lo studio di tesi. Sul laptop personale quindi, attraverso il software “ORACLE VM Virtual Box”, è stato possibile emulare il sistema operativo di Linux, impiegando la metà dei processori presenti nel computer stesso e quindi utilizzando solo 2 processori (questo aspetto è cruciale per i tempi di calcolo e di risoluzione del problema). Di fatti, eccetto per un breve periodo in cui si è acquisita familiarità con il programma e con il linguaggio di scrittura, è stato impiegato il computer fisso dell’istituto cantabro con caratteristiche più prestanti. Esso in particolare ha le seguenti peculiarità: Ubuntu

16.04 LTS, 8 Processori Intel® Core™ i7-4790 da 3.60 GHz e sistema operativo da

64 bit.

OpenFOAM® è dunque una library del linguaggio C++ che è usata principalmente

per creare file eseguibili, noti come applications. Le applications possono dividersi in due categorie: le solvers, che sono concepite con lo scopo di risolvere problemi di meccanica continua; e le utilities, che sono progettate per risolvere problemi in cui sia necessario manipolare più dati. L’utente può dilettarsi a creare sia nuove

5

applications che nuovi solvers, ovviamente sono necessarie le conoscenze di alcuni prerequisiti sul software e sulle tecniche di programmazione dei problemi fisici.

2.2 Installazione del programma

Come suddetto, per l’installazione di OpenFOAM® , è opportuno disporre di un

computer con sistema operativo Linux. Se, come nel mio caso si ha un sistema operativo Windows, è possibile installare una macchina virtuale che emuli il funzionamento del sistema operativo desiderato. Si osservi che questa operazione, essendo virtuale, non necessita di un partizionamento fisico del computer. Per quanto riguarda l’istallazione della macchina virtuale si rimanda al seguente link: https://www.virtualbox.org/wiki/Downloads. Nella pagina si deve poi selezionare il collegamento Windows hosts. La procedura di installazione è rapida e si sceglie di emulare Ubuntu_16_04_LTS. Ora si formatta il sistema operativo e si impostano il nome e la password dell’utente. È importante che il PC non vada mai in standby poiché l’esecuzione dei programmi è eseguita dal terminale; una sospensione di quest’ultimo si traduce infatti nell’arresto dei programmi stessi. Una specifica su come effettuare la distribuzione del sistema operativo virtuale sui processori a disposizione nel computer materiale è inoltre necessaria. Un’indicazione generale per l’emulazione è di ripartire Ubuntu sulla metà dei processori a disposizione. Se si tentasse di aggiungerne più di metà si verificherebbero continui crash del software di emulazione. Queste specifiche, che riguardano le esigenze dell’utente, possono essere indicate seguendo il percorso: VirtualBox→ Setting System→ Processors, qui si specificano i processori dei quali si vuole disporre a fronte di quelli disponibili; nel mio caso 2 su 4 dei totali presenti nel PC. Successivamente all’installazione si procede come se si possedesse un sistema operativo Ubuntu, semplicemente aprendo la macchina virtuale dal menu Start.

Ora è necessario installare il programma OpenFOAM®. Le procedure d’ora in

avanti sono valide per entrambi i computer in quanto si lavora sul medesimo sistema operativo. Per il download del pacchetto open source si rimanda al seguente link: https://www.openfoam.com/download/install-binary-linux.php. Per l’installazione dei programmi, in Linux, è necessario procedere da terminale. Questo si traduce nel compilare dall’interfaccia del terminale le stringhe di comandi che sono riportate nel precedente link.

6

2.3 Struttura del programma

A seguito dell’installazione del programma vengono scaricate, all’interno della cartella principale “OpenFOAM”, due cartelle che dovranno essere estratte per essere leggibili. Una cartella è denominata “OpenFOAM-v1712” e l’altra “ThirdParty-v-1712”. La desinenza v-1712 specifica la versione che si sta impiegando. Ogni sei mesi ne viene rilasciato un aggiornamento; quella che è utilizzata è la diciassettesima (17) ed è stata rilascia a dicembre (12). All’interno della cartella ThirdParty-v-1712 vi sono tutte le istruzioni che vengono richiamate dal programma nella fase di pre e post processing con i rispettivi comandi, che saranno illustrati nel seguito. Nella cartella OpenFoam-v-1712 invece sono raccolte tutte le cartelle contenenti le equazioni, le costanti, i moduli e i files necessari per

l’esecuzione dei programmi in OpenFOAM®. Di particolare utilità è la cartella

“tutorials”, all’interno della quale sono riportati, in sottocartelle, esempi di vario genere per rispondere alla necessità di descrivere fenomeni disparati. Per esempio, si possono studiare fenomeni in cui si parli di combustione, di elettromagnetismo, di trasferimento di calore, di fluidi comprimibili o incomprimibili e molti altri. Nello specifico, parlando dell’interazione tra aria e acqua, si possono usare dei modelli che sono raccolti nella cartelle “multiphase”. In questa relazione, come si vedrà nel seguito, a partire da un caso esistente se ne creerà uno nuovo per comprendere come modificare il dominio, la sua forma, la sua mesh e la procedura di calcolo in generale.

In OpenFOAM® sono presenti due ambienti: uno di pre-processing e l’altro di post-

processing; entrambi sono delle utitlities dello stesso. La struttura del programma può essere così schematizzata:

Figure 3 Panoramica della struttura di OpenFOAM®

In breve, gli step che si seguono sono così riassumibili: • Pre-processing: è in questa fase che si genera la mesh, che si assegnano tutte

le caratteristiche del problema e le condizioni al iniziali- contorno. • Solving: è la fase durante la quale, a partire dalle equazioni che si intende

risolvere, si avviano le computazioni del problema. A seconda delle caratteristiche di quest’ ultimo vengono create tante cartelle quante sono gli

7

step temporali di salvataggio richiesti dall’utente nel pre-processing. All’interno di queste cartelle sono raccolte le soluzioni numeriche del problema in forma matriciale. Per averne una rappresentazione grafica si rimanda al passo successivo.

• Post-processing: qui, con l’ausilio del software di visualizzazione ParaView, che è anch’esso un programma open source, sul quale si appoggia

OpenFOAM®, è possibile condurre visualizzazioni scientifiche statiche e di

tipo interattivo.

8

Capitolo 3 Struttura delle cartelle di OpenFOAM®

Di seguito si illustra la struttura con la quale è organizzata una cartella di lavoro, genericamente indicata con “case” ma che, normalmente, prende come nome quello che l’utente le assegna. È importante sottolineare che all’inizio dell’impiego del programma, per acquisire dimestichezza, è auspicabile che si cominci con gli esempi già strutturati e funzionanti presenti nella cartella tutorials (essa viene scaricata automaticamente quando si esegue il download del programma). Inoltre, è buona norma lavorare su una copia della cartella originale per evitare così di comprometterla.

3.1 Struttura dei file all’interno delle cartelle di OpenFOAM®

La cartella case, in particolare, contiene al suo interno non meno di tre sottocartelle. Queste d’ora in avanti, come i comandi che saranno presentati in seguito, verranno richiamate con i loro nomi in lingua originale. Le tre cartelle, dunque, hanno i seguenti nomi: “costant”, “system” e l’ultima, che è dedicata alle condizioni iniziali, è indicata con “0”. Vi sono poi ulteriori sottocartelle di cui si darà una breve illustrazione a tempo debito. Qui si riporta la struttura di una cartella “case” del programma:

Figure 4 Struttura della generica cartella Case in OpenFOAM®

Di seguito si dà una breve descrizione qualitativa delle tre directory.

9

• Costant directory: essa contiene una descrizione completa della mesh in esame, delle proprietà del flusso che si vuole descrivere, ossia delle caratteristiche di trasporto (transportProperties), e una sottocartella definita polyMesh.

• System directory: qui vengono configurati i parametri che sono associati alla procedura per determinare la soluzione del problema. Essa, a sua volta, contiene almeno tre file definiti come: controlDict, fvSchemes e fvSolution. Essi rispettivamente hanno i ruoli qui riportati. Per quanto riguarda il primo vi si definiscono i parametri di controllo per il “run” (che rappresenta l’avvio della procedura di calcolo nei programmi elettronici) inclusi il tempo di inizio e di fine della procedura (start-end), i passi di calcolo (step) ed i parametri per l’output. Nel secondo si descrive lo schema di discretizzazione e, per quanto riguarda l’ultimo, vi sono descritti altri parametri relativi al run come: le equazioni da risolvere, le tolleranze di approssimazione e altri algoritmi propedeutici al run stesso.

• 0 directory: questa cartella è utile per fissare le condizioni iniziali delle variabili che sono impiegate nello studio del problema. Nel caso di flussi laminari e incompressibili, retti dalle equazioni di Navier-Stokes, le condizioni iniziali, ad esempio, sono poste solo sul campo di velocità e di pressione. Nel caso in cui il flusso non sia laminare o il fluido sia compressibile, sarà opportuno assegnare altre variabili. In ogni caso, a ciascuna variabile, si devono specificare, mediante i files qui richiamati, le dimensions (ossia l’unità di misura della stessa), il “campo interno” internalField e il campo delle condizioni al contorno indicato con boundaryField.

3.2 Formato base dei files di input/output

OpenFOAM® legge svariate strutture di dati: stringhe, scalari, vettori, tensori, liste

e campi. I formati dei campi di input/output (I/O) sono estremamente flessibili e intuitivi cosicché, seguendo delle semplici regole di sintassi, è facile comprenderne

la forma. In particolare, OpenFOAM® segue i principi generali del linguaggio di

programmazione C++.

1. Tra i più ricorrenti, si richiamano i comandi per non far leggere e quindi eseguire al programma una determinata stringa o parte del testo del file. Con il comando doppio slash //, anteposto ad una stringa di testo, si fa sì che quest’ultima non venga letta. Se si desidera invece non eseguire una porzione di programma, oltre a deselezionare ogni stringa manualmente, è possibile comprendere il testo tra /* e */ cosicché sia ignorato ma leggibile dall’utente.

10

2. In OpenFOAM®, uno scalare è rappresentato semplicemente come un singolo

numero all’interno del file. Un vettore è un VectorSpace, ossia un tensore di ordine 1 e dimensione 3. Siccome il numero degli elementi è sempre fissato pari a 3, un vettore può essere rappresentato semplicemente come una semplice lista. In particolare, il vettore (1.0, 1.1, 1.2) può essere semplicemente scritto come: ��

In OpenFOAM®, un tensore è un VectorSpace di ordine 2 sempre con

dimensione tre. Pertanto, i dati da inserire per costruirlo sono sempre 9 numeri reali. Il tensore identità può essere scritto tanto in forma matriciale: ��

��

��

��

�

Da qui si può intuire che in OpenFOAM® i rientri di linea non vengono letti

e pertanto lo stesso tensore può essere scritto e letto come un’unica riga: ��

3. OpenFOAM®, di default, segue le regole dimensionali del Sistema

Internazionale (SI). Pertanto, per impostare l’unità di misura di una grandezza, si fa riferimento alla notazione riportata dopo il seguente esempio. Se ad esempio si vuole rappresentare una densità, che è data dal rapporto tra la massa (�) e il volume (�) ovvero � � �, lo si fa scrivendo una stringa di 7 scalari racchiusa da parentesi quadre. Nel caso in esame quindi, si scrive: ��

11

Ogni elemento rappresenta la potenza di ognuna delle basi delle unità di misura riportate nella tabella ivi riportata: Tabella 1 Basi per le grandezze nel SI

N# Grandezza unità nel SI

1 Massa (kg) 2 Lunghezza (m) 3 Tempo (s) 4 Temperatura (K) 5 Peso molecolare (kgmol) 6 Ampere (A) 7 Candela (cd)

Le specifiche delle dimensioni delle grandezze in esame si eseguono all’interno della cartella DimensionedCostant contenuta all’interno del controlDict.

12

Capitolo 4 Avviare la procedura o eseguire il run

Ricordando che OpenFOAM® è un software scritto nel linguaggio di

programmazione C++, esso è impiegato poiché, mediante library, crea files eseguibili, noti come applications. Il programma è rilasciato con una vasta gamma di appications precompilate, l’utente, comunque, ha la facoltà di poterne creare di nuove a partire da un livello zero o sfruttando quelle già esistenti. Le applications si possono suddividere in due categorie:

• solvers che sono designate di risolvere problemi specifici della meccanica computazionale nel continuo;

• utilities che eseguono incarichi semplici di pre e post-processing, che principalmente riguardano lo sviluppo e l’elaborazione di calcoli algebrici.

OpenFOAM® si suddivide quindi in una serie di librerie precompilate che

interscambiano dinamicamente informazioni nel processo di compilazione tra le utilities ed i solvers. Pertanto, librerie come queste, per la descrizione di modelli fisici, sono utili all’utente che le può aggiungere nel proprio programma in base alle sue esigenze. Questo paragrafo dà una breve panoramica del solutore, le utilities e le libraries, le rispettive realizzazioni, come si modifichino, della compilazione e della loro esecuzione.

4.1 Running delle applications

Ogni applicazione è realizzata cosicché possa essere eseguita dal terminal (il terminal rappresenta la configurazione più rudimentale e diretta di ciò che si vuole elaborare sul PC). Normalmente è poco impiegato ma, in Linux, rappresenta un elemento fondamentale per eseguire ogni genere di comando). I files possono essere letti e scritti direttamente nel terminal e i dati che ne vengono elaborati sono salvati come descritto precedentemente (vedi pag. 8). Per ogni genere di applicazione, la spiegazione e il suo funzionamento può essere visualizzata semplicemente riportandone il nome ed estendendone il testo con il comando ��.

��

��

��

��

�� !��"�#�� !��"�#�� !��"�#�� !��"�#��

��$ � %��$ � %��$ � %��$ � %�� #�� &� �#�� #�� &� �#�� #�� &� �#�� #�� &� �#��

�� $#��%� ��$#��%� ��$#��%� ��$#��%�� #�� '�� #� �� #�� '�� #� �� #�� '�� #� �� #�� '�� #� ��

13

��(��"��(��"��(��"��(��"��

��)��#��"�� )��#��"�� )��#��"�� )��#��"��

�� $��*�%��#�� '��*�� $��*�%��#�� '��*�� $��*�%��#�� '��*�� $��*�%��#�� '��*��

�� +�� +�� +�� +��

�� *�� *�� *�� *��

��

,�� ,�� ,�� ,��

(� ��'��&�� (� ��'��&�� (� ��'��&�� (� ��'��&�� #�� #�� #�� #��

'� ��)�� #��'� ��)�� #��'� ��)�� #��'� ��)�� #�� !��!��!��!��

(� �'� ��)��*�� -��.��/�0��&�� 1�(� �'� ��)��*�� -��.��/�0��&�� 1�(� �'� ��)��*�� -��.��/�0��&�� 1�(� �'� ��)��*�� -��.��/�0��&�� 1��

#��.�0#.1�� 2�� #�� &� ��'��3#��.�0#.1�� 2�� #�� &� ��'��3#��.�0#.1�� 2�� #�� &� ��'��3#��.�0#.1�� 2�� #�� &� ��'��3��

#��4�� 5�� *�� 3#��4�� 5�� *�� 3#��4�� 5�� *�� 3#��4�� 5�� *�� 3��

�� #��6�� 7�� # �� #��6�� 7�� # �� #��6�� 7�� # �� #��6�� 7�� # ��

��

Gli argomenti che vengono riportati tra parentesi quadre, �� , sono quelli che

possono essere scelti per il comando selezionato (nel caso di sopra ��1��1��1��1. Se

l’applicazione è eseguita dalla cartella nella quale si lavora, essa è eseguita direttamente in essa. Viceversa, se così non fosse, sarà possibile richiamare l’applicazione ed eseguirla da dove si preferisca inserendo l’estensione della cartella nella quale essa si trova. L’esecuzione del programma, come in ogni sistema operativo UNIX/Linux, può essere eseguita in background senza che se ne visualizzi ogni passo di calcolo.

4.2 Eseguire l’applicazione in parallelo

Un’operazione molto utile, che può essere compiuta al fine di rendere più veloce il computo, è quella di distribuire il problema su più processori. In particolare,

OpenFOAM®, per eseguire il metodo in parallelo, scompone il dominio, ossia la sua

geometria ed i rispettivi campi su più processori e poi, come riportato di seguito, lo ricompone per dare alla luce un risultato unico. Tale processo consta delle seguenti fasi: decomposizione della mesh e dei campi; running delle applications in parallelo; post-processing del caso decomposto.

14

• Decomposizione della Mesh: al fine di eseguire il metodo “in parallelo” è opportuno suddividere la mesh in sottodomini. La suddivisione deve richiedere un dispendio computazionale minimo e deve essere tale da garantire una rapida convergenza alla soluzione. Per la decomposizione, che può essere effettuata secondo svariate metodologie, si va ad intervenire nel documento denominato decomposeParDict che si trova all’interno della cartella system del caso in analisi. In particolare, si hanno a disposizione quattro metodi per la decomposizione. Essi sono:

o Simple: che decompone il dominio e le equazioni lungo i tre assi principali, secondo le esigenze dell’utente;

o Hierarchical: che prevede la decomposizione geometrica del simple, consentendo inoltre di scegliere rispetto quale asse cominciare;

o Scotch: che non richiede una decomposizione geometrica ma che tenta di minimizzare il numero di processori. L’utente può precisare quale processore impiegare visualizzandone le sue caratteristiche e performance richiamando l’ulteriore comando processorWeight;

o Manual: dove l’utente assegna manualmente uno specifico processore a determinate celle del dominio.

• Esecuzione del caso decomposto: un problema decomposto è eseguito in parallelo usando openMPI. Esso è impiegato per aprire i messaggi che passano per l’interfaccia (dall’anglosassone Message Passing Interface). openMPI può essere eseguito su un dispositivo con multiprocessori in maniera molto semplice; quando però lo si esegue tra macchina e server è necessario che sia comunque presente una cartella che riporti il nome dell’utente del computer.

• Post-processing dei casi lanciati in parallelo L’utente, a seguito di aver eseguito il programma in parallelo, ha due possibilità:

o Riscostruire la mesh e il campo dei risultati per ricomporre l’intero dominio, che può essere successivamente studiato come un normale post-processing. In particolare, dopo che un caso è stato eseguito come decomposto, successivamente, può essere ricostruito a partire della fusione dei campi e dei valori che sono relativi i medesimi intervalli temporali. Il comando che viene impiegato è recontructPar.

o Effettuare un post-processing individuale su ciascun sottodominio del caso originale. In particolare, attraverso il programma di visualizzazione “Para View”, è possibile visualizzare il dominio originale costituito come unione di tutti i sottodomini costituenti lo stesso. In questo caso nella cartella nella quale si lavora non si avrà un

15

unico campo di moto, ma tanti quanti sono i processori che sono stati impiegati per l’esecuzione del programma.

16

Capitolo 5 Modellazione e generazione della Mesh

In questo paragrafo si descrivono le caratteristiche principali per realizzare la mesh del problema. In prima istanza si riportano i casi in cui la mesh è particolarmente semplice, con forma geometrica non strutturata, successivamente invece, si dà un’idea di come, a partire da una mesh semplice, se ne possa realizzare una più articolata e complicata, in grado di descrivere un qualsivoglia dominio.

5.1 Descrizione della Mesh

La Mesh rappresenta una parte fondamentale del problema, senza di essa non si

potrebbe pervenire ad alcun risultato. In ogni problema scritto in OpenFOAM®

viene eseguita una verifica. In particolare, viene controllato che la mesh sia concettualmente corretta e che rispetti determinati criteri, affinché si possa pervenire ad una soluzione accurata e valida. Di default il programma definisce una mesh costituita da celle poliedriche in un dominio 3-D. Queste possono avere facce di una qualsivoglia forma e numerosità. Una mesh con una struttura tanto generica è definita “polyMesh”; essa consente all’utente di descrivere la mesh con grande libertà. Il rovescio della medaglia, nell’impiego di questo genere di mesh, risiede nel fatto che è particolarmente complicata da realizzarsi con gli strumenti di scrittura che usualmente si impiegano. Una mesh per essere tale deve soddisfare le seguenti caratteristiche:

• Punti: i punti che la costituiscono sono posizionati in uno spazio tridimensionale, dove le coordinate sono espresse in metri. Nella lista di punti che formano la mesh non ve ne può essere più di uno con le stesse coordinate.

• Facce: una faccia è costituita da una lista di punti, dove un punto è identificato dalla sua etichetta. L’ordine delle etichette dei punti in una faccia è tale che due punti adiacenti tra loro siano connessi da un bordo, in particolare quindi si seguono i punti come se si ruotasse attorno alla faccia. Le facce sono compilate come liste e ognuna di esse si riferisce ad una propria etichetta. Il verso del vettore uscente dalla faccia in considerazione segue la regola della mano destra, i.e. guardando la faccia, se la numerazione dei punti segue un verso antiorario, il verso del vettore normale punta fuori dal foglio, come riportato nella seguente figura:

17

Figure 5 Verso del vettore a partire dalla numerazione della faccia da esso attraversata

Si deve osservare che esistono due generi di facce. Vi sono quelle interne, cioè quelle che connettono due e solo due celle. In questo caso il vettore normale alla faccia punta nella cella con l’etichetta di ordine maggiore. Esistono poi le facce che si trovano al contorno, esse appartengono ad una sola cella in quanto coincidono con i confini del dominio. Il verso del vettore normale, in questo caso, punta verso l’esterno del dominio.

• Celle: una cella è costituita da una lista di facce, disposte in ordine arbitrario. Le celle hanno le proprietà di seguito riportate. Devono essere contigue ossia devono ricoprire l’intero dominio senza sovrapporsi tra loro; devono essere convesse nel senso che il loro centro si trovi al loro interno; inoltre devono essere ortogonali nel senso che per ogni cella interna il vettore che congiunge due celle contigue (con verso che punta dall’etichetta con valore più basso a più alto) deve formare un angolo minore di 90 gradi con il vettore ortogonale alla faccia stessa.

• Bordo: o boundary, è una lista di patches ossia di regioni alle quali, a ciascuna di esse, è associata una condizione al contorno. Un patch è una lista di facce che, naturalmente, deve contenere solamente le facce di contorno e no quelle interne. È richiesto che il bordo del dominio sia chiuso, cosicché la somma di tutti i vettori delle aree delle facce di contorno sia pari a zero.

5.2 Lo strumento cellShape

In OpenFOAM®, nonostante sia possibile impiegare un qualsivoglia poligono per

discretizzare la mesh del problema, in generale è meglio impiegare delle forme che siano esaedri (oggetti solidi con sei facce). In particolare, le forme e quindi il cellShape di tali oggetti è riportata in Figure 6 Vertici, facce e numerazione per del

18

cellShape. La descrizione di una cella è costituita da due parti: una del modello e l’altra della lista ordinata di etichette. In particolare, le numerazioni delle etichette partono sempre da 0 e, a partire da una lista di punti, che rappresentano i vertici dell’esaedro, si riporta il seguente esempio: 8 ( (0 0 0) // vertex number 0 (1 0 0) // vertex number 1 (1 1 0) // vertex number 2 (0 1 0) // vertex number 3 (0 0 0.5) // vertex number 4 (1 0 0.5) // vertex number 5 (1 1 0.5) // vertex number 6 (0 1 0.5) // vertex number 7 ) (hex 8(0 1 2 3 4 5 6 7)) Qui è stato usato il comando hex (dall’inglese hexaedral) per definire la forma della cella. Altre forme e comandi sono di seguito riportati.

19

Figure 6 Vertici, facce e numerazione per del cellShape

5.3 Generazione della mesh con lo strumento blockMesh

Alla base di questo strumento vi è l’idea di suddividere il dominio in un set (al massimo tridimensionale) di blocchi di esaedri. I bordi dei blocchi in generale possono essere o semplicemente dei segmenti o anche archi o curve spezzate. Ogni esaedro deve essere costituito da otto vertici, ognuno dei quali è definito mediante

delle coordinate tridimensionali e, ricordando che OpenFOAM® è scritto nel

linguaggio C++, la numerazione parte dallo 0. Allo stesso tempo si può realizzare un blocco con meno vertici facendo degenerare l’esaedro in una figura con meno vertici, quindi meno facce. Un esempio è qui riportato: hex (0 1 2 3 4 5 5 4)

20

Figure 7 Degenerazione di un esaedro in un pentaedro

Questo può esser fatto facendo collassare il vertice 7 nel 4 e il vertice 6 nel 5 e scrivendo come sopra, ossia scrivendo nella settima posizione il numero 5 e nell’ottava posizione il numero 4. Ogni blocco possiede delle coordinate locali che devono seguire la regola della mano destra. Un set di assi che rispetti tale regola è tale se, ponendosi all’interno del blocco, si vedono i vertici ruotare in senso antiorario. La figura di riferimento è riportata di seguito (Figure 8). Il sistema di coordinate locali è definito dall’ordine col quale vengono scritti i vertici nella descrizione del blocco. In generale si devono seguire le seguenti regole:

• L’origine degli assi è il primo punto ad essere scritto nella definizione del blocco, nel caso di sopra (vedi Figure 7) è il vertice 0;

• L’asse �� viene descritto congiungendo il primo vertice al secondo; • L’asse �� è descritto dalla vettore congiungente il secondo vertice al terzo; • I vertici 0,1,2,3 definiscono il piano per cui �� ; • Il quarto vertice si ricava spostandosi dal vertice 0 lungo la direzione ��; • I vertici 5,6 e 7 si determinano similarmente spostandosi lungo la direzione

��, rispettivamente dai vertici 1,2 e 3.

Figure 8 Rappresentazione di un blocco generico

21

5.4 Generazione della mesh mediante snappyHexMesh

Per realizzare una mesh articolata vi sono innumerevoli vie, quella che è di seguito descritta è quella che viene impiegata nel lavoro di tesi. Essa si basa sull’idea di inserire all’interno di un blocco (generato come sopra descritto e in color grigio) un oggetto o una forma che altrimenti sarebbe oltremodo complicato studiare e descrivere, tanto quanto oggetto quanto come mesh.

Figure 9 Schematizzazione 2D di una mesh impiegando snappyHexMesh

In particolare, snappyHexMesh crea una mesh tridimensionale contenente esaedri(hex) ed esaedri-divisi (split-hex) automaticamente dalla triangolazione delle geometrie delle superfici che vengono lette in formato STL (da Stereolithography, questo stesso formato è impiegato nel mondo delle stampe 3-D). Il processo che viene seguito è quello di realizzare un blocco di riferimento e all’interno di esso inserirvi l’oggetto nel formato STL per poi far combaciare le mesh dei due ambienti (Figure 10 Processo di mesh con snappyHexMesh). In una prima fase si inserisce l’oggetto, poi si specifica quale area/volume se ne vuole considerare (se interno o esterno) in ultimo, attraverso un processo automatico e iterativo, si va ad infittire la mesh nelle zone prossime all’oggetto (Figure 10 Processo di mesh con snappyHexMesh). Per infittire la mesh vi sono diverse specifiche; quella più impiegata è definita “castellatedMesh” (Figure 10 Processo di mesh con snappyHexMesh. Di seguito si riportano delle immagini qualitative che esplicano meglio gli steps sopra descritti.

Figure 10 Processo di mesh con snappyHexMesh

22

L’impiego di questo genere di mesh consente di pervenire a risultati accurati con possibilità di errore di descrizione del modello molto limitate. Nel corso della stesura della tesi sono stati impiegati diversi software per la realizzazione della mesh. Quello che verrà introdotto e presentato nel Capitolo 7 Esempi applicativi ed esecutivi) è il programma open source Blender.

23

Capitolo 6 Il modello e le sue proprietà fisiche

In OpenFOAM® sono presenti innumerevoli solutori ciascuno dei quali realizzato

per uno specifico problema. Le equazioni e gli algoritmi che caratterizzano il problema che si vuole studiare sono assai differenti tra solutore e solutore. Pertanto, risulta cruciale la scelta di un solutore che sia adatto alla descrizione dello specifico problema. Normalmente per valutare quale sia il solutore che meglio si adatti alle necessità dell’utente si fa riferimento alla guida del programma stesso (OpenFOAM, 2017) . Successivamente all’aver scelto il tipo di solutore è opportuno valutare e determinare quali siano i parametri e le proprietà fisiche che possano rappresentare al meglio il problema in esame. In particolare, queste specifiche possono essere modificate all’interno della cartella costant che si troverà nella directory del caso che si vuole studiare con caratteristiche differenti. Qui si illustrano sommariamente i modelli più impiegati e le proprietà che vi sono associate.

6.1 Condizioni al contorno

Per ottenere una simulazione che restituisca risultati soddisfacenti è necessario che siano poste delle appropriate condizione al contorno. Se esse non fossero tali oltre ad avere dei risultati poco veritieri si potrebbe incorrere in un errore del sistema che risulterebbe fatale per il processo computazionale. L’utente deve dunque specificare le condizioni al contorno per ogni campo del dominio di calcolo. In totale nel software sono disponibili più di 70 tipologie di condizioni; qui si riportano solo le principali che, d’altronde, sono quelle impiegate nel seguito.

• fixedValue: questa condizione, anche nota come condizione alla Dirichlet, impone come vincolo un valore prefissato;

• zeroGradient: questa condizione, nota come condizione alla Neumann, esprime un flusso nullo attraverso la parete sulla quale essa viene posta (normalmente è impiegata per imporre l’impermeabilità di una superficie);

• empty: questa condizione si usa allorquando il modello che si descrive è mono o bidimensionale; in queste situazioni, questa condizione, è posta sulle pareti normali alla geometria del problema. In particolare, applicandola, non si studia la soluzione lungo tali pareti;

• symmetry: si impiega per applicare un vincolo di simmetria; • inletOutlet: con questo comando si impone, a partire da un prestabilito flusso

in ingresso, un generico flusso di uscita;

24

• noSlip: fissa il valore della velocità pari a zero lungo la parete su cui viene posta la condizione;

6.2 Modelli di turbolenza

Nello studio di ogni fenomeno è opportuno specificare le caratteristiche del flusso in esame. In particolar modo se ne devono descrivere le caratteristiche turbolente, nel programma indicate come turbulanceProperties. I possibili modelli che si possono impiegare sono: il laminar, il RAS e il LES. Il primo, il laminar, in particolare, è un modello nel quale il flusso è considerato laminare e pertanto privo di turbolenza. Scegliendo i modelli RAS o il LES si deve specificare quale modellazione degli stessi si desideri fare. Nelle relative sottocartelle, ossia in RASmodel e LESmodel, si può scegliere quale modello impiegare per descrivere la turbolenza. Normalmente i coefficienti legati ai due modelli sono assegnati di default dal programma, tuttavia è possibili ridefinirli e modificarli.

6.3 Controllo temporale e dei dati in input/output

Affinché il problema sia risolvibile sono necessarie, oltre le condizioni al contorno e le equazioni del moto, anche delle condizioni iniziali e, in generale, temporali. Inoltre, è necessario imporre degli schemi numerici che consentano di controllare il progresso dei calcoli fino al raggiungimento della loro soluzione.

Il solutore di OpenFOAM® comincia tutte le procedure di calcolo (runs) a partire

dalla creazione di un database. Il database controlla gli I/O e, dal momento che i file di output sono forniti ad intervalli temporali, il fattore tempo è un aspetto ineludibile all’interno del database stesso. All’interno del file controlDict sono riportati i parametri essenziali per la creazione del database. In particolare, al suo interno si assegna in quale istante cominciare la simulazione e in qual finirlo, si specifica il passo di calcolo, ogni quanto riportare in output la soluzione, la precisione con cui devono essere eseguiti i calcoli ed il massimo numero di Courant. Un esempio della schermata che si visualizza è di seguito riportata:

25

Figure 11 Esempio dei parametri all'interno del controlDict

6.4 Schemi numerici

All’interno della cartella system si trova il file denominato fvSchemes. Esso consente di intervenire sugli schemi numerici ossia di scegliere come risolvere le equazioni differenziali alla base del problema. Normalmente ciò che viene assegnato all’interno di questo file, oltre allo schema con cui risolvere le equazioni è anche il metodo con cui interpolare i valori da una serie di nodi di calcolo ad un altro. Senza dubbio l’interpolazione più impiegata è quella lineare di Gauss ma all’utente è concesso di scegliere quella che meglio rispecchi le sue esigenze. In particolare, il metodo d’integrazione lineare di Gauss interpola i valori tra i volumi finiti delle celle di calcolo. All’interno degli schemi a ispezione sono presenti ulteriori specifiche che si possono aggiungere in fase di programmazione. Un esempio può essere la scelta dello schema gradScheme con il quale si possono calcolare i gradienti delle grandezze come grad(p). Gli schemi tra cui si può scegliere sono ivi riportati:

26

Figure 12 Principali schemi impiegati nell' fvSchemes

Quindi per ciascun degli schemi sopra elencati esiste un ulteriore classificazione delle azioni che si possono compiere in merito alla scelta di interpolazione. Nella tesi si farà uso delle configurazioni di default.

6.5 Il post-processing

In questo paragrafo si illustra il programma sul quale si appoggia OpenFOAM® per

la visualizzazione grafica dei risultati. Il software, ParaView, è un open source che viene richiamato mediante l’utility paraFoam. ParaView sfrutta come elaboratore dei dati Visualisation Toolkit (VTK) e per questo è in grado di aprire i files con

estensione VTK. In OpenFOAM® l’utility foamToVTK che è in grado di convertire

i file nativi in files in formato VTK. Questo fa sì che, più in generale, si possa impiegare qualsiasi programma in grado di aprire e rielaborare files con questa specifica estensione.

6.6 Nozioni su ParaView

Attraverso l’esecuzione del comando paraFoam, una volta che la procedura di calcolo è stata ultimata, è possibile aprire, direttamente dalla shell dei comandi, ParaView. Quello che si vede all’apertura del programma è la schermata che segue (vedi Figure 13 Aspetto della finestra di ParaView). In particolare, si fa riferimento

ad uno dei casi presenti nei tutorials di OpenFOAM®.

27

Figure 13 Aspetto della finestra di ParaView

Il caso in esame può essere controllato dal pannello di sinistra. Esso contiene un accesso diretto ai casi che sono aperti con ParaView, nel presente esempio cavity.foam. In questa regione si può attivare e disattivare la visualizzazione dei casi che sono stati caricati. Vi è poi un pannello che contiene i dettagli dei dati d’input chiamato properties dove si riportano: tempo, regioni e campi. Un altro pannello consente di modificare la scala di colori di rappresentazione dei risultati e in ultimo vi è un pannello in cui sono riportate le informazioni riguardanti la mesh e la geometria del problema. Attraverso ParaView è inoltre possibile, a partire dai dati elaborati dal software, estrapolare stream plots, contour plots , effettuare sezioni del dominio, modificare il punto di vista e registrare quanto si vede sullo schermo. I risultati che verranno riportati in seguito saranno dunque estratti con questo comodo programma.

28

Capitolo 7 Esempi applicativi ed esecutivi

Nel presente capitolo, dopo che le caratteristiche, la struttura ed il funzionamento del programma sono state descritte, si riportano degli utili esempi su come, a partire da problemi presenti nei tutorials del programma se ne possano generare di nuovi. Una breve illustrazione sul software Blender, indispensabile per la realizzazione di mesh articolate, è data nel momento in cui si parlerà del suo impiego.

7.1 Tutorial onda di Stokes del V ordine

In questo paragrafo, essendo il primo esempio che si riporta, viene data un’ampia

descrizione su come sia strutturato un problema in OpenFOAM®, come lo si esegua

e come si valutino i risultati graficamente attraverso il software di visualizzazione ParaView. Come prima indicazione generale si consiglia di copiare sempre la cartella di lavoro sulla quale si vuole effettuare una qualsivoglia modifica. Questo consente di mantenere inalterate le caratteristiche del problema, dato che non è possibile tornare indietro nelle operazioni una volta che vengono salvate o eseguite. Si osservi che l’analisi che si conduce è stata effettuata su onde rappresentate dalla teoria di Stokes di ordine V. Questo perché, attraverso il diagramma di Le Mauthé, di cui si riporta un’immagine (vedi Figure 14), scegliendo un’onda di altezza H=0,1 m, con periodo T=2 s, su un fondale h=0.4 m, si verifica che il rapporto sull’asse

delle ascisse �

�� e su quello delle ordinate

�

�� garantisce una

condizione descrivibile mediante tale teoria.

29

Figure 14 Diagramma di Le Mauthé per analisi della teoria ondosa

In particolare, facendo riferimento alla cartella che si trova all’interno del percorso riportato in Figure 15, se ne effettua una copia sulla quale si lavora.

Figure 15 Percorso della cartella "waveExampleStokesV"

Ciò che è presente in tale cartella è visionabile sempre nella stessa figura. Come illustrato sopra (più sopra) ciascuna delle cartelle al suo interno contiene i file che vengono impiegati per assegnare: le caratteristiche del dominio, le equazioni del moto ed i valori delle grandezze impiegate nello studio. Di seguito (vedi Figure 16) è riportato un diagramma gerarchico con il quale si visualizzano e riportano tali file nelle rispettive cartelle.

30

Figure 16 Organizzazione dei file nelle sottocartelle

Di seguito si riportano i contenuti dei diversi file.

7.1.1 Cartella 0.orig

All’interno di questa cartella sono presenti tre file: alpha.water (vedi Figure 17Errore. L'origine riferimento non è stata trovata.), p_rgh (vedi Errore. L'origine riferimento non è stata trovata. ) e U (vedi Figure 19-19).

��

� ��

��

��

��

�

��

�

��

��

��

��

��

��

�� !��

��!��

"��

!��

�� #��"!��

31

Figure 17 Schermata del file alpha.water

32

Figure 18 Schermata del file p_rgh

33

Figure 19 Schermata del file U

Nella cartella 0.orig pertanto si attribuiscono a ciascuna parete del dominio delle condizioni al contorno che variano a seconda della grandezza in analisi. Per

34

esempio, a partire dalle dimensioni delle grandezze, si osserva che per quanto riguarda l’alpha.water, che rappresenta l’interfaccia tra aria e acqua, essa è una grandezza adimensionale e le sue dimensions sono 7 zeri, per la pressione si ha [1 -1 -2 0 0 0 0 ] ossia [kg m-1 s-2] e per quanto riguarda la velocità invece si ha [0 1 -1 0 0 0 0 ] ossia [m s-1].

7.1.2 Cartella costant

All’interno di questa cartella sono presenti 4 file. Di seguito ne vengono riportati i rispettivi contenuti, che saranno brevemente analizzati.

Figure 20 Schermata del file g

Come si può vedere questo file racchiude in sé le caratteristiche del campo gravitazionale che agisce in tutto il dominio. Esso è un vettore con direzione verticale (la costante è infatti riportata nella terza posizione della terna cartesiana) e verso il basso (il segno negativo, per come è posto il sistema di riferimento, indica la direzione opposta allo stesso). Lw dimensioni sono quelle di un’accelerazione e pertanto sono rappresentate con la stringa [0 1 -2 0 0 0 0] ossia [m s-2].

35

Figure 21 Schermata del file con le caratteristiche del trasporto

In questo file si descrivono le caratteristiche dei fluidi che si stanno studiando. In particolare, lavorando con un caso in cui sono presenti solo aria e acqua, si studia le loro interazione a partire dalle caratteristiche che le descrivono. Con il termine nu si rappresenta la viscosità cinematica del mezzo e con rho la sua densità. In questo caso l’acqua ha una densità di 1000 kg m-3, l’aria invece di 1. La stringa con il comando sigma rappresenta la tensione superficiale che divide i due fluidi.

36

Figure 22 Schermata del file con le caratteristiche turbolente

In questo file si specificano le caratteristiche dello schema con il quale si intende studiare la turbolenza. Nella fattispecie, analizzando il caso di flusso laminare, si impiega una simulazione di tipo laminar.

37

Figure 23 Schermata del file riportante le proprietà d'onda

All’interno del file sopra riportato si specificano le caratteristiche dell’onda che si intende riprodurre con il modello numerico. In particolare, si evidenzia che sono presenti due macrostrutture: una definita inlet e l’altra outlet. Queste sono delle condizioni che vengono poste alle facce di ingresso e di uscita del moto ondoso; nel prossimo sotto paragrafo si analizza meglio questo aspetto. In ogni caso all’interno di queste macrostrutture si indica la teoria ondosa che si intende impiegare (come suddetto le onde che si rappresentano sono relative alla teoria di Stokes del V

38

ordine). L’altezza d’onda è posta pari a 0.1 m; l’angolo d’incidenza con la superficie d’ingresso, indicata con waveAngle, è posta pari a 0 cosicché risulti perfettamente ortogonale ad essa. Si può inoltre assegnare il periodo d’onda che viene posto par a 2 s. Inoltre, si osservi, che mentre per l’inlet si impone che l’onda rispetti la teoria di Stokes, per l’outlet si indica un modello di assorbimento, e quindi di propagazione, di tipo shalloWaterAbsorpion.

7.1.3 Cartella system

Questa cartella, sebbene descritta per ultima, è una delle più importanti. Al suo interno sono riportati 4 file, che descrivono tanto la mesh quanto come discretizzarla, con quali intervalli temporali eseguire i calcoli iterativi e il modo in cui ripartire il problema su più processori. Nell’ordine in cui si presentano aprendo la cartella si hanno:

39

Figure 24 Schermata del file blockMesh

Questo file è fondamentale per la descrizione della mesh del problema. Nel caso in esame si studia la propagazione di onde all’interno di un canale lineare che può essere schematizzato come un parallelepipedo degenere. Effettivamente qui lo si

40

analizza come se fosse una piastra, il cui spessore è pari ad una cella di calcolo. Nel file è riportata nella prima stringa il comando scale, questo è impiegato per scalare le grandezze che vengono assegnate nei vertici. In questo caso non è opportuno scalare il dominio e per questo, tale rapporto, è posto pari ad 1. Successivamente, con le regole già illustrate nel paragrafo 5.3 Generazione della mesh con lo strumento blockMesh, sono definiti i vertici dell’esaedro che rappresenterà le estremità del dominio di calcolo. Viene poi create un blocco con i vertici appena definiti e di questo se ne specifica come lo si intenda discretizzare. In particolare, 750 sono i passi di discretizzazione lungo l’asse x per descrivere i 30 m di canale; 1 è la cella che descrive lo spessore fittizio di 0.04 m e 70 sono i passi di discretizzazione della verticale z. Successivamente, sotto il comando boundary vengono assegnate le condizioni al contorno sulle facce costitute dai vertici. In particolare, sono poste condizione di tipo inlet e tipo outlet nelle sezioni di ingresso e di uscita del flusso; condizioni tipo ground sul fondo del canale; condizione top sulla superficie superiore e sides, che potrebbe essere omessa poiché viene compilata di default quando non viene assegnata, sulle pareti laterali. Quest’ultima condizione consente di valutare il flusso in analisi come se fosse una sezione di un caso reale.

41

Figure 25 Schermata del file controlDict

Nel file ControlDict, una cui rappresentazione è riportata qui sopra, si impongono le modalità con cui studiare e discretizzare temporalmente il fenomeno. In particolare, si esplicita il tipo di application, che è di tipo interFoam; si specifica che, in caso di interruzione del run, la procedura riprenda i calcoli dall’ultimo

42

intervallo di calcolo, attraverso il comando latestTime, assegnato alla stringa startFrom. Nella stringa successiva si assegna la condizione temporale iniziale, ossia il tempo al quale cominciare i calcoli numerici. Il comando stopAt indica a quale intervallo temporale si debba interrompere la simulazione; nel caso in esame si deve interrompere ad endTime che è stato fissato a 30 s. Il detaT rappresenta, come logico immaginare, i passi di discretizzazione temporale; nella fattispecie è pari a 0.01 s. Il comando writeInterval è molto importante poiché è esso a dettare ogni quanto trascrivere i risultati in apposite cartelle che si generano in fase di run. Si noti che le animazioni di cui si farà uso in fase di post processing, con il software ParaView, sono elaborate a partire dai dati, che vengono salvati durante i suddetti intervalli di salvataggio. Di default, inoltre, il programma ha un’accuratezza che si spinge fino alla deste cifra decimale; per evitare che si generino errori di in fase di calcolo è bene non modificare questa impostazione. È inoltre riportato il massimo numero di Courant con il quale eseguire i calcoli. Valori superiori o prossimi all’unità restituiscono risultati grossolani ovvero del tutto insensati. Questo valore può in ogni caso essere modificato in fase di run e automaticamente, al contrario delle altre impostazioni, si aggiornerà in tutti i calcoli del processo.

Figure 26 Schermata del file decomposeParaDict

43

Nel file sopra riportato, viene specificato quanti processori impiegare in fase di run. Si specifica come ripartirli sul dominio, che è decomposto in due sottodomini lungo l’asse x. Il fatto che venga decomposto lungo l’asse x è dettato dal 2 nella prima cella della terna, che è riportata dopo il comando n. La suddivisione del dominio deve essere tale che il prodotto dei processori impiegati lungo le tre celle sia al massimo pari al numero di processori presenti nel computer e comunque di quelli indicati in numberOfSubdomains.

Figure 27 Schermata del file setFieldDict

Quest’ultimo file indica in quale zona del dominio debba trovarsi il volume d’acqua. In particolare, si assegna di default che essa non sia presente e che, invece, nella regione contenuta tra i due spigoli diametralmente opposti di coordinate (0 0 0) e (30.0 1.0 0.4) vi sia un volume d’acqua nella condizione iniziale e indisturbata. Si osservi, che le coordinate del secondo spigolo non è richiesto che coincidano con la regione definita nella mesh. Come si vede nella direzione y si assegna una larghezza del volume d’acqua di un metro quando nella mesh era di appena 0.04 m. Nella

44

terza cella per assegnare si specifica che il volume d’acqua debba avere, rispetto alle coordinate del sistema di riferimento, un’altezza di 0.4 m.

7.1.1 Avviare il run

Descritte le cartelle presenti nel caso in esame è possibile dedicarsi all’analisi del processo di run. In particolare, nella cartella del caso in analisi sono presenti altri due file denominati: Allrun ed Allclean. Il primo di essi, come si vede in Figure 28 contiene dei comandi, che altrimenti andrebbero richiamati singolarmente con questo ben preciso ordine logico nella shell dei comandi. Al suo interno è presente il comando di ricostruire una cartella come quella 0.orig cosicché non venga persa né sovrascritta; venga eseguita e costruita la Mesh; venga decomposta nel numero di domani e sui processori precedentemente assegnati; venga eseguito in parallelo il calcolo del campo di moto dei mezzi fluidi e, sempre in parallelo, si attui l’applicazione del campo.

Figure 28 File Allrun

Il secondo di essi (vedi Figure 29), l’Allclean, serve a ripulire la cartella di lavoro in cui è stato precedentemente eseguito il run. Una volta che l’Allclean è eseguito tutti i dati creati precedentemente vengono eliminati e si torna alla configurazione primordiale del caso.

45

Figure 29 File Allclean

Per lanciare il programma e l’avvio del run si ricorda che si deve intervenire dal terminal. Di seguito si riporta una chiara illustrazione su come si faccia. Per eseguire il run è opportuno porsi nella cartella del caso in analisi e, come in Figure 15, cliccare il tasto destro del mouse, selezionare il comando open in Terminal. Una volta che tale finestra si è aperta, per rendere eseguibile

OpenFOAM®, si deve richiamare il comando source ~/OpenFOAM/OpenFOAM-v1712/etc/bashrc e premere il comando invio. Successivamente, per avviare la procedura, si digita il comando Allrun preceduto dal comando di esecuzione ./ (lo stesso deve precedere il comando di pulizia Allclean qualora fosse necessario richiamarlo). Al termine del run, all’interno della cartella originari, verranno create delle nuove cartelle con i processori in cui è stato scomposto il caso e tutte le cartelle temporali di salvataggio delle variabili che, in post processing, potranno poi essere analizzate. Un’idea visiva delle cartelle che vengono scritte a seguito del run la si può avere guardando la figura sottostante:

Figure 30 Cartelle e files in un case dopo un Run

All’interno della cartella postProcessing vengono poi create tutte le cartelle con i valori dei campi di velocità e pressione, calcolati ai diversi istanti temporali.

7.1.2 Visualizzare i risultati

Una volta che il programma è stato eseguito correttamente e senza alcun errore, il processo di calcolo si interrompe e nel terminal si ha nuovamente la possibilità di scrivere i comandi liberamente. A questo punto, per aprire direttamente il software di visualizzazione, si utilizza il comando paraFoam che automaticamente, prendendo il caso in esame, lo carica su ParaView. Per caricare il caso di interesse,

46

e valutare la propagazione dell’onda, si clicchi con il tasto sinistro del mouse sul pulsante verde Apply disposto in basso a sinistra nella pagina. La prima cosa che si può visualizzare su Para View è la mesh e la discretizzazione che le è stata applicata. Per farlo basta sostituire al comando Surface, nel pannello a tendina, il comando Wireframe. Con esso si vedranno tutte le celle costituenti il dominio. Uno sketch della visualizzazione è ivi riportato:

Figure 31 Mesh e discretizzazione del dominio

Ora è possibile valutare l’andamento della superficie libera. Si procede selezionando nuovamente il comando Surface e successivamente, nella casella sulla sua sinistra, si selezioni la visualizzazione di alpha.water. Di seguito è riportato due immagine qualitative della superficie d’interfaccia tra aria ed acqua, in fase indisturbata (t=0) e di moto ondoso ad un istante temporale non nullo (� � �).

Figure 32 Interfaccia aria-acqua in condizione indisturbata

47

Figure 33 Interfaccia aria-acqua con stato ondoso

Per avere un’idea di quale sia l’effettiva propagazione del moto ondoso si suggerisce, d’ora in avanti, di aprire i link a YouTube riportati nel corso della relazione. Il primo, relativo al caso in esame è di seguito riportato. https://www.youtube.com/watch?v=cEup78pukAQ «---

7.2 Onda di Stokes del V ordine su fondale variabile

In questo paragrafo, a partire dall’esempio sopra illustrato, si dà un’idea di come si possa modificare la mesh e su come si possano manipolare le modellazioni presenti nei tutorials. In questo esempio, pertanto, si riporta come si possa modificare la mesh del problema precedente sfruttando il software open source Blender. In particolare, si inserisce una rampa nel canale computazionale mediante il comando snappyHexMesh, che consente di sovrapporre la mesh, realizzata con il software esterno, a quella esistente costruita con il file blockMesh.

7.2.1 Realizzazione della rampa con Blender

Blender è un software mediante il quale è possibile: elaborare, generare e modificare oggetti, piani e tridimensionali. È particolarmente impiegato per la realizzazione dei file che vengono impiegati per le stampe 3D. Con esso, senza entrare in dettagli che non sono d’interesse per il lavoro che si sta conducendo, è possibile, a partire da oggetti di forma semplice, come: cubi, sfere, piramidi, coni, piani ecc., realizzare delle forme più complesse, non solo di forma ma soprattutto di mesh. È infatti possibile, con un semplice comando, infittire la mesh di discretizzazione dell’oggetto che si vuole inserire in quella esaedrica del problema di base. All’aumentare dell’infittimento, tuttavia, è bene metterlo in luce, sarà necessario un tempo di calcolo maggiore. Viceversa, se la mesh che si va ad inserire nell’esaedro fosse troppo rozza ne conseguirebbero dei risultati grossolani e poco veritieri.

48

Qui si riportano alcune immagini del programma ed i comandi impiegati per la sua realizzazione e la sua estrazione in formato .stl, che è quello letto e riconosciuto da

OpenFOAM®. Per prima cosa, aprendo il programma, si eliminano gli oggetti

presenti nella finestra che compaiono di default. Essi si trovano nella destra della schermo e sono: Camera, Cube e Lamp; per elimarli e non visualizzarli sul monitor basta: porvisi sopra con il cursore, premere sul tasto destro e selezionare il comando delate. Una volta fatto ciò è possibile inserire un oggetto, in questo caso un cubo, che sarà poi impiegato per realizzare la rampa, attraverso il comando Create, selezionando l’oggetto Cube, presente nella tendina delle mesh. Questa è l’immagine che si dovrebbe visualizzare:

Figure 34 Generazione dell'oggetto Cube

In seguito, è possibile modificarne la posizione e l’inclinazione effettuando una rotazione dell’oggetto. Si osservi che le coordinate che vengono impostate sono

espresse in metri come in OpenFOAM®. Inoltre, quando l’oggetto .stl, che viene

sovrapposto a quello esistente nel blockMesh, è inserito facendo coincidere gli origini dei due sistemi di riferimento. Qui si riporta un’illustrazione del cubo traslato di 5 m sull’asse delle x e ruotato di 45° attorno all’ asse y. Si noti inoltre, che il Radius, che rappresenta in generale il raggio dell’oggetto e in particolare metà della lunghezza di un lato, è stato posto pari a 0.4 m.

49

Figure 35 Roto-traslazione del cubo dall'orgine del sistema

Ora è possibile deformare il cubo mediante il comando Scale presente nella tendina Tools. Nel caso in esame, per esempio, si è allungato il prisma lungo l’asse x di un fattore 2 e lo si è contratto di 0.5 sulla z.

Figure 36 Cubo deformato e trasformato in rampa

Una volta che l’oggetto soddisfa le esigenze dell’utente, è possibile infittirne e modificarne la mesh. Per farlo bisogna andare nella parte destra dello schermo e selezionare con il tasto sinistro del mouse il triangolo rovesciato, che si trova a destra dell’oggetto Cube che è stato appena realizzato. Quello che ne risulta da questa selezione è una rappresentazione arancione delle facce dell’oggetto. È ora possibile andare sul menu a tendina Tools e premere sulla cella Subdivide. Così facendo la mesh si infittisce ad ogni click che viene premuto. Qui è riportato uno sketch dell’oggetto con la mesh infittita.

Figure 37 Rampa con mesh infittita

50

A questo punto è possibile salvare il file appena realizzato nel formato .blend, per poterlo riaprire senza perderne le modifiche, che nel richiesto formato .stl. Per estrarre il formato in formato .stl si selezioni File Export e per ultimo Stl.

Il file, per poi essere aperto e letto da OpenFOAM®, deve trovarsi in una specifica

cartella con altri files di lettura all’interno di quest’ultima. In particolare, l’oggetto rampa viene salvato all’interno della cartella triSurface contenuta all’interno di costant. Così facendo è possibile, in fase di run, dare in pasto ad un file, appositamente scritto, definito come snappyHexMeshDict il file .stl.

7.2.2 Risultati del run

Eseguendo il run dell’applicazione è ora possibile visualizzare i risultati dell’operazione di sovrascrittura della mesh. Di seguito è riportata un’immagine con il medesimo canale lineare descritto nel sotto paragrafo 7.1.3 Cartella systemcon sovrapposta la mesh della rampa:

Figure 38 Griglia di calcolo del canale con rampa

Nella diapositiva seguente invece si riporta il profilo della superficie libera dell’acqua nel canale nell’istante iniziale, con la calma.

Figure 39 Profilo superficie libera indisturbata

Nelle due immagini successive invece si riporta un profilo delle onde, con diverse prospettive, in istanti di tempo che ne mettano in luce le caratteristiche e l’interazione con il fondo, ossia il fenomeno di shoaling.

51

Figure 40 Accentuazione della cresta e conseguente frangimento

Di seguito si riporta il link dell’animazione del modello. https://www.youtube.com/watch?v=906JHwH_bk4

7.3 Generazione d’onda alla Scott Russell.

Nel presente paragrafo si riporta un altro esempio di come si possa impiegare il

programma OpenFOAM®, ora per la generazione di onde. In particolare, essendo

la generazione di onde di tsunami indotte da frana il tema della mia tesi, ivi se ne descrive un caso schematicamente e concettualmente molto semplice, ma non per questo privo di interesse. Nel paragrafo successivo, invece, viene illustrato un caso relativamente più complesso. Per riprodurre il fenomeno Scott Russell (Scott Russell, 1842-43), per primo, concepì l’idea di generare, in laboratorio, onde di tsunami a partire dal rilascio di un oggetto cubico nell’estremità di un canale lineare. Il rilascio di tale elemento, sia esso sommerso o emerso, implica il dislocamento di un volume d’acqua equivalente a quello del solido che genera un’onda. Quest’onda, in scala di laboratorio, può essere confrontata con una di tsunami. Di seguito si riporta un’ immagine qualitativa dell’esperimento fisico.

52

Figure 41 Modello di Scott Russell

Per riprodurre tale esperimento col software di calcolo, a partire dal tutorial “damBreak” contenuto nella directory “multiphaseInterFoam”, si procede come di seguito descritto. Innanzitutto, si impiega come modello di origine un multiphase poiché con esso è possibile descrivere la fluidodinamica e l’interazione di più di due fluidi. L’idea è infatti, a costo di non avere una rappresentazione perfetta del modello originale, quella di descrivere l’oggetto solido mediante un fluido più pesante e meno viscido. In particolare, viene usato il mercurio, con le sue proprietà meccaniche, per la generazione dell’onda. Per prima cosa, del modello del tutorial, si modifica il dominio di calcolo per descrivere il canale lineare. Le sue caratteristiche sono: � � �� m. Per la discretizzazione si suddivide il primo asse in 600 elementi, lungo il secondo in 80 e, per la profondità del canale, solamente con una cella in quanto si studia il caso bidimensionale. Per quanto riguarda il file setFieldDict, dove si specifica come siano ripartite le varie fasi liquide, si ha che l’aria è assegnata di default a tutto il dominio, il volume d’acqua ha piezometrica di 0.35 m e il mercurio, che ha il ruolo di rappresentare l’oggetto che cade, ha la faccia inferiore a contatto coll’acqua e lati di 15 cm. Un immagine di come appaia il problema nel modello numerico è qui riportata:

Figure 42 Rappresentazione del problema di Scott Russell nel modello numerico e propagazione ondosa

53

Nella Figure 42 l’area blue rappresenta l’acqua, quella rossa l’aria e quella rosea il mercurio, ossia l’oggetto esterno che viene lasciato cadere e che, sotto l’azione della gravità, genera l’onda. Qui il link per l’animazione del fenomeno: https://www.youtube.com/watch?v=fnfH9CjhxPs Lo stesso esperimento può esser condotto eseguendo l’applicazione con l’oggetto sommerso. In particolare, mantenendo inalterate le caratteristiche del dominio e del volume di mercurio, si fa coincidere la faccia superiore del volume dell’oggetto con il pelo libero dell’acqua. Procedendo in questo modo, quello che si evince è che l’onda generata è di entità più ridotte della precedente. Purtroppo, a differenza del problema reale, modellando l’oggetto cubico indeformabile con un fluido, non è possibile apprezzare delle differenze sostanziali tra cavo e cresta.

Figure 43 Rappresentazione del problema pseudo-Scott Russell nel modello numerico e propagazione ondosa

7.4 Tsunami indotto da frana

A partire dalla generazione di onde con il modello di Scott Russell si è pensato di descrivere, come precedentemente accennato, un’onda di tsunami generata dall’azione franosa di un oggetto. In questo caso, infatti, il blocco di Scott Russell non è né cubico né lasciato cadere lungo la verticale bensì lungo un piano inclinato, che rappresenta un pendio con pendenza costante. Anche qui il caso che viene rielaborato è quello contenuto nella directory “multiphaseInterFoam”. In particolare, le caratteristiche del dominio sono ivi riportate attraverso una descrizione illustrativa dello stesso.

54

Qui si riporta il link a YouTube per la visualizzazione qualitativa del fenomeno: https://www.youtube.com/edit?o=U&video_id=dWZNveZXDmM

55

Capitolo 8 Conclusioni

In conclusione, nella presente relazione è descritta l’esperienza di tirocinio. Quest’ultima è stata propedeutica per la stesura della tesi. In particolare, si è descritto il principio di generazione degli tsunami, delle loro caratteristiche e di come possano essere descritti in maniera semplificata. Una più ampia trattazione, a partire dall’installazione del programma, della sua struttura e del suo funzionamento è descritta con maggior dettaglio nel corso della presente relazione. I casi esaminati, a partire dalle strutture presenti nei tutorial, sono stati utili per comprendere la filosofia con cui è si debba affrontare un problema e come lo si studi. Gli ultimi esempi di generazione di onde, nonostante siano solo qualitativi, illustrano come, prima di affrontare il problema vero e proprio di generazione degli tsunami, fosse possibile effettuare valutazione rudimentale degli stessi, modificando e alterando un problema già esistente nella cartella tutorial. Per quanto riguarda la struttura impiegata per descrivere il problema di tesi, indubbiamente più complesso e articolato, si rimanda alla stessa.

56

Bibliografia

Bellotti, G., Di Risio, M., Panizzo, A. & De Girolamo, P., 2006. Tsunami waves generated by landslides along a straight sloping coast: new 3D experiments. In: Coastal Engineering 2006. s.l.:s.n., pp. 1431-1442. Di Risio, M., Bellotti, G. & Montagna, F., 2011. 3D numerical modeling of landslide-generated tsunamis around a conical island. Springer, pp. 58:591-608. OpenFOAM, 2017. OpenFOAM V5 UserGuide. [Online] Available at: https://cfd.direct/openfoam/user-guide/standard-solvers/#x13-960003.5

57

Link di riferimento per i software open source

OpenFOAM®: https://www.openfoam.com/download/install-binary-linux.php

Guida OpenFOAM®: https://www.openfoam.com/documentation/user-guide/

Oracle VM Virtual Box: http://www.oracle.com/technetwork/server-storage/virtualbox/downloads/index.html MeshLab: https://uappexplorer.com/snap/ubuntu/meshlab Blender: https://www.blender.org/download/

58

Elenco dei programmi utilizzati

OpenFOAM®;

Meshlab; Blender; Autodesk™-AutoCAD; Autodesk™-Tinkercad; Math-Works MATLAB; Microsoft Word;

il modello numerico openfoam - … · corso di laurea magistrale in ingegneria civile per la...

Documents