Capitolo 2 Implementazione

(1)

Implementazione

Il capitolo ha lo scopo di presentare alcune soluzioni di implementazione adottate per sviluppare la procedura iterativa. Le problematiche della metodologia sono state elencate nel capitolo precedente. Alcune di esse saranno ora sviluppate dal punto di vista della costruzione del programma, altre, come la generazione della mesh aerodinamica e la fase di ottimizzazione, saranno trattate a parte.

2.1

Struttura del programma

La cartella “loop_nvele_cv” raccoglie l’intero programma. Il criterio seguito per ordinare i singoli file è stato quello di raccoglierli in tante cartelle quante sono le operazioni logiche.

(2)

Si riconoscono le cartelle principali: • Importa_vela:

contiene le GUI (Graphical User’s Interface) e le function scritte in MATLAB per cercare e scegliere il file della vela da importare. Sono attive due opzioni: scelta di un file *.rlx generato con il software AUTOMETRIX oppure tre matrici contenenti rispettivamente le coordinate X, Y, Z della griglia rappresentativa della vela e che costituisce la base per l’interpolazione e la generazione della superficie. Nell’eventualità che la procedura iterativa fallisca e si interrompa, questa seconda opzione consente di ripartire dalla notazione matriciale salvata nell’ultima iterazione corretta.

• S_interp:

contiene i file per gestire le operazioni di interpolazione e generazione del file *.igs. Una finestra di interfaccia grafica dedicata, consente la scelta di alcuni parametri come l’ordine delle funzione B-Spline e la dimensione della griglia con cui si desidera generare l’immagine della vela nel formato IGES.

• Gambit:

qui sono raccolti i file relativi alla scelta dei parametri geometrici per la costruzione della geometria in GAMBIT e l’editor del file journal.

• Fluent:

gestisce la GUI per le scelte relativi ad alcuni settagli, le operazioni relative alla scrittura del file journal che imposta la simulazione CFD, il lancio in cascata di GAMBIT e FLUENT, la creazione dei file *.dat contenenti le pressioni calcolate. • An_strutturale:

attiva le opzioni per la fase di ottimizzazione, gestisce il calcolo della deformata, rappresenta i risultati della storia di calcolo in un file *.txt dedicato alle singole iterazioni del loop, rappresenta i risultati parziali

• Start_loop:

contiene la GUI per confermare il lancio della procedura iterativa. Dopo la scelta dei parametri relativi alle fasi sopraelencate, è necessario assegnare i valori per i criteri di convergenza della procedura (spostamento massimo e frazione della energia di deformazione calcolata alla prima iterazione), il numero massimo di iterazioni ammesse, oltre alla tolleranza per valutare se una griglia è iso-u e iso-v.

(3)

eseguita una sessione di calcolo o avendo a disposizione i dati relativi a quelle precedenti, un’interfaccia GUI consente di rappresentare la storia di calcolo scelta: come evolve la superficie della vela, la storia di una generica sezione (iso-u, iso-v, iso-z) in termini di forma, incidenza geometrica e freccia %, la variazione dei parametri di convergenza (spostamento ed energia), spostamenti dei nodi.

• Input_veleria:

qui è stato archiviato il file output di autometrix e le tre matrici per la rappresentazione matriciale della vela.

I file contenuti nella cartella loop_nvele_cv e non appartenenti a nessuna delle cartelle, rappresentano variabili *.mat salvate nell’ultima sessione di calcolo e function di Matlab per le fasi di inizializzazione.

2.2

Avvio della procedura

Dopo avere lanciato il programma Matlab, per attivare la procedura è sufficiente eseguire quanto segue:

• Scegliere come “Current Directory” di Matlab la cartella “loop_nvele_cv”. • Digitare la stringa “ manager; ”.

Queste due semplici operazioni consentono di attivare la function “manager”, a cui è affidato il compito di gestire la procedura. Si possono distinguere due fasi principali e distinte:

• Fase di scelta o inizializzazione.

• Ciclo di calcolo dedicato alla ricerca della configurazione sotto carico della vela. Al termine della sessione di calcolo si può scegliere di attivare la fase di post-processing, digitando la stringa “post_processing;”. Il comando corrisponde alla omonima function, che attiva un’interfaccia grafica per consentire la selezione dei risultati che si desidera visualizzare.

2.3

Fase di scelta dei parametri

Si possono riconoscere i vari punti qui elencati nella figura 2.2, che illustra il diagramma di flusso parziale della procedura, limitandosi alla fase di scelta dei parametri.

(4)

• La finestra di interfaccia grafica “finestra0” consente di scegliere nome e percorso della cartella “sessione di lavoro ”, in cui salvare i dati generati durante i calcoli. I dati saranno organizzati in sottocartelle di questa, dal nome ITER1, ITER2, etc., ognuna corrispondente ad una iterazione del loop di calcolo. Questo semplifica la ricerca di file e permette una gestione dei numerosi dati che verranno creati.

• Il programma crea la cartella e la sotto-cartella ITER1 dove scrivere i dati relativi alla prima iterazione (all’inizio di ogni successiva iterazione i-esima del loop di calcolo si creererà una cartella ITER seguita dal numero corrispondente).

• La function “ add_path_loop” aggiorna il path di Matlab, aggiungendo a esso tutte le cartelle contenenti le function necessarie alla procedura. Ad ogni iterazione il Path è aggiornato con la nuova cartella ITER i-esima. Il “Path” di Matlab è semplicemente un elenco delle cartelle che Matlab è in grado di “vedere”, permettendo l’attivazione di subroutine con la semplice digitazione del nome, senza specificare il percorso integrale.

• Si attiva un’apertura in cascata di interfacce grafiche per la scelta della vela e dei parametri necessari alle varie fasi (per velocizzare la selezione, alcuni valori di default compaiono già inseriti nelle relative caselle di editazione). L’apertura di una GUI è vincolata alla chiusura di quella precedente, e ognuna contiene l’opzione “ RESET ” per inizializzare le caselle di editazione con i valori di default. È presente anche l’opzione “ INTERROMPI” per chiudere il programma ed uscire. Le interfacce grafiche vengono attivate nel seguente ordine:

1. Scelta nome della cartella “sessione di lavoro”

2. Scelta del metodo con cui importare la vela : file *.rlx o tre matrici 3. Selezione del file relativo alla vela con alcuni parametri, quali

o Unità di misura o Tipologia della vela

o Sigla con cui chiamare la vela

o Coordinate del punto di mura nel sistema di riferimento o Eventuale variazione dell’angolo di scotta δ

(5)

(6)

4. Se si è scelta l’opzione file Autometrix, il programma chiede quale griglia rettangolare si desidera estrapolare dai punti del file *.rlx importato. Successivamente è richiesta la conferma per accettare la vela. Se si rifiuta, si hanno a disposizione fino a 50 tentativi per selezionarne un’altra.

5. Confermata la scelta, la vela viene inserita nel sistema di riferimento assi-barca e ruotata, se si è richiesto un angolo di scotta diverso da quello del file originale. La griglia viene analizzata e trasformata in una iso-u e iso-v con tolleranza 10^-3 mm.

6. Si possono scegliere altre vele da inserire. Il programma è pensato, infatti, per la gestione di più vele, anche non è attualmente attiva l’opzione per un file journal relativo a questo caso.

7. Parametri di interpolazione: ordine delle funzioni B-spline e numero di punti per la griglia con cui si desidera generare il file IGES della vela.

8. Scelta del modello per generare la mesh aerodinamica con GAMBIT. Attualmente sono attive due scelte.

9. Parametri per la scrittura del file journal per GAMBIT. Si tratta di definire le proporzioni del dominio rispetto a due dimensioni di riferimento: corda della base ed altezza della vela. In questa fase si fissa anche la velocità del vento apparente.

10. Parametri per la scrittura del file journal per FLUENT (iterazioni massime consentite, tolleranza dei residui, area della vela, salvataggi intermedi). È attivo un PUSH-BUTTON con cui stimare l’area della vela se non si conosce il dato.

11. Scelta del metodo per l’analisi strutturale.

12. Scelta parametri specifici e relativi al metodo selezionato, compresi i vincoli geometrici per la vela.

13. Assegnazione dei criteri di convergenza del loop di calcolo e conferma del lancio di quest’ultimo.

• Tutte le scelte fatte vengono salvate in un file dal nome “impostazioni.txt”. Il file viene archiviato nella cartella definita all’inizio per la sessione di lavoro.

(7)

2.4

Ciclo di calcolo

All’inizio della fase di calcolo viene creato un file “report.txt”, in cui il file manager e varie function coinvolte, registrano lo stato di ogni singola fase ed alcuni risultati parziali. Esso propone la storia della sessione di calcolo attraverso l’elenco di tutti i processi coinvolti e in caso di fallimento della procedura permette di risalire alla fase in cui si è generato l’errore. La storia di calcolo della fase di ottimizzazione, con i risultati parziali, viene registrata invece in un file specifico generato per ogni iterazione del loop di calcolo. In ogni sottocartella ITER1, ITER2, etc., si può trovare un file “storia_calcolo_siglavela.txt”, dove è registrata la schermata con la successione di tutti i valori e gli output della rispettiva fase di ottimizzazione.

Vengono elencati ora, schematicamente, i processi coinvolti nella fase di calcolo e visualizzati nella fig. 2.3. Essa rappresenta il diagramma di flusso della parte iterativa della procedura, nonché la naturale prosecuzione del diagramma precedente (fig. 2.2).

1) Apertura del file “report.txt”.

2) Per la vela caricata si crea il file IGES siglavela.igs. Se la dimensione della griglia con cui si vuole generare il formato grafico è diversa da quella importata, si interpola quest’ultima per generare una griglia dalla dimensione desiderata. Il file IGES scritto viene salvato nella sottocartella ITER1.

3) Si scrive il file journal per la gestione delle operazioni in GAMBIT con i parametri impostati.

4) Si scrive il file journal contenente le istruzioni per il software FLUENT.

5) Si attiva la function “calcolo_CFD”, che gestisce l’apertura in cascata prima di GAMBIT poi di FLUENT. In questa fase si genera la mesh aerodinamica, si calcolano le pressioni sopravento e sottovento alla vela, le si salvano in due file separati: tabella_siglavela.dat_it1 per la faccia sottovento, tabella_siglavela_shad_it1.dat per la faccia sopravento.

6) La function “ attiva_analisi_strutt.m” introduce la fase di ottimizzazione, che scrive il file storia_di_calcolo.txt e determina la nuova configurazione di equilibrio della vela per i carichi assegnati.

7) Tornato il controllo al file manager, si applicano i criteri di convergenza. Le possibilità sono tre:

(8)

(9)

b) Che Non siano soddisfatti, e allora si prosegue.

c) Che si siano esaurite le iterazioni massime ammesse per il loop di calcolo.

Nei casi a) e c) la griglia strutturale della vela deformata viene trasformata in una griglia iso-u e iso-v, e salvata nelle tre matrici dal nome “x/y/z_siglavela_it(n)_GSisoend.dat”. Successivamente la si interpola, per generare una griglia con le stesse dimensioni di quella corrispondente al file della configurazione iniziale. Questa operazione crea tre matrici dal nome “x/y/z_siglavela_it(n)_end.dat”.

8) si visualizzano i risultati, con rappresentazioni delle varie sezioni della vela e grafici degli spostamenti dei nodi.

9) se la procedura prosegue si prepara l’iterazione successiva: a) si crea la sottocartella ITER(i+1) .

b) si analizza la griglia strutturale deformata ed eventualmente la si interpola per generare una griglia iso-u e iso-v delle stesse dimensioni, creando tre matrici dal nome x/y/z/_siglavela_it(i+1)_GSiso.dat. Si utilizza ancora la griglia strutturale per generarne una con le stesse dimensioni di quella della configurazione importata all’inizio, creando le matrici x/y/z_siglavela_it(i+1).dat.. Le matrici si salvano nella sottocartella ITER(i+1).

10) le matrici create rappresentano l’input per l’iterazione successiva e si torna al punto 2).

11) se la procedura viene interrotta si chiude il file “ report.txt”.

2.5

Sistemi di riferimento, rotazione e traslazione vela

Una volta scelta ed importata una vela, essa è nota sottoforma di tre matrici, che rispettivamente raccolgono le coordinate X, Y, Z di tutti i nodi della griglia della vela. La disposizione delle coordinate nelle matrici risulta ruotata di 90° gradi rispetto a come appare la griglia sulla vela: la prima colonna è relativa alla base, l’ultima alla penna, immaginata in tanti punti quante sono le linee che convergono in essa. Inoltre, leggendo i dati dall’alto in

(10)

basso della esima colonna, si ottengono le coordinate dei punti della linea orizzontale i-esima, nel verso di scorrimento che va dalla ralinga alla balumina.

ASSI -BARCA:

sono quelli utilizzati per generare la mesh in GAMBIT, valutare le pressioni in FLUENT, calcolare le nuove posizioni dei nodi nella fase di ottimizzazione.

ORIGINE: quota livello del mare, la si può immaginare coincidente con la proiezione

sull’acqua della prua o a scelta del punto di mura di una vela

ASSE XBARCA: parallelo all’asse di simmetria della barca, orientato da prua verso poppa

ASSE ZBARCA: verso l’alto

ASSE YBARCA: normale all’asse della barca e tale che terna levogira, cioè orientato dal lato

sinistro verso il lato dritto della barca (destra e sinistra per l’osservatore che guarda da poppa verso prua)

ASSI VELA:

la function “assi_vela” trasforma le coordinate dei nodi della griglia della vela nel senso illustrato di seguito:

ORIGINE: punto di mura della vela

ASSE XVELA: orizzontale e tale da intersecare la retta verticale passante per la penna

ASSE ZVELA: diretto verso l’alto ASSE YVELA : tale che terna levogira

barca assi barca assi vela assi zmura ymura xmura z y x z y x ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ − ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ = ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡

La caratteristica di questo sistema è quello di definire la posizione della vela in un sistema assi barca con origine nel punto di mura: infatti la mura e la penna di fiocchi, rande, gennaker sono allineate con l’asse della barca. Nel caso di spinnaker si è riprodotta la condizione di tangone tutto strallato a prua.

(11)

ANGOLO DI ASSETTO O DI SCOTTA

Per angolo di assetto o di scotta si intende quello tra l’asse della barca (versore orientato verso poppa) e la proiezione sul piano orizzontale della corda che ha origine nel punto di mura e termina in quello di scotta.

SIMULAZIONE DELL’ANGOLO DI ASSETTO DESIDERATO (function ruota_vela) Una volta nota la vela nell’ultimo sistema di riferimento, si opera la trasformazione necessaria a riprodurre un angolo di scotta desiderato rispetto all’asse della barca. Al variare dell’angolo di scotta, in generale, le coordinate in assi vela cambiano, perché la vela ruota intorno allo strallo o alla congiungente mura – penna, tranne nel caso dello spinnaker. Simulare un angolo di scotta e conoscere le coordinate della vela in assi barca, significa eseguire una combinazioni di rotazioni per passare da assi vela a assi barca. Nel caso dello spinnaker le cose sono più semplici, perché la rotazione avviene intorno ad un asse verticale.

CASO DELLO SPINNAKER:

Si valutano le coordinate della vela rispetto ad un nuovo sistema assi vela_primo, ottenuto da quello precedente traslando l’origine lungo l’asse Xvela affinché l’asse Zvela_primo passi per la penna. Si assume Xvela==Xvela_primo==Xbarca a meno di traslazioni, ovvero spinnaker strallato. vela assi vela assi primo vela assi ypenna xpenna z y x z y x ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ − ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ = ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ 0 _

Si immagini un riferimento assi vela_secondo, solidale alla vela ed inizialmente coincidente con assi vela_primo. Prima della rotazione

primo vela assi ondo vela assi z y x z y x _ sec _ ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ = ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡

(12)

Rispetto a tale riferimento le coordinate della vela non cambiano qualunque sia l’assetto desiderato. Desiderando ruotare di un angolo ψ lo spinnaker intorno all’asse verticale Zvela_primo, le nuove coordinate rispetto ad assi vela_primo saranno:

ondo vela assi primo vela assi z y x z y x sec _ _ 0 0 1 0 ) cos( sin( 0 ) sin( ) cos( ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ ⋅ ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ − = ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ ψ ψ ψ ψ

L’angolo di rotazione ψ che porta a sovrapporre l’asse Xvela_primo (terna di arrivo) con quello Xvela_secondo (terna di partenza) assume il seguente significato: angolo tra il versore dell’asse Xvela_primo==Xbarca ed il versore del tangone (coincidente col versore di Xvela_secondo). Quindi un angolo positivo significa che il tangone è dalla parte di Ybarca <0 (mura a sinistra), mentre un angolo negativo che il tangone è dalla parte di Ybarca >0 (mura a dritta). Di nuovo si può ottenere

vela assi primo vela assi vela assi ypenna xpenna z y x z y x ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ + ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ = ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ 0 _

CASO DEL GENNAKER E DELLE VELE INFERITE

La rotazione della vela, per variare il proprio angolo di scotta, avviene intorno all’asse passante per la mura e la penna. Esso risulta in genere inclinato di un angolo che definiamo di seguito e chiamiamo rake.

Si definisce un riferimento assi vela_primo, ottenuto dal precedente, con una rotazione intorno all’asse Yvela tale da portare l’asse Zvela a passare per la penna. Questa rotazione è uguale all’angolo che abbiamo chiamato rake. Conoscere le coordinate della vela rispetto a questo nuovo riferimento richiede solo la definizione di una matrice di rotazione relativa all’angolo rake. Qualunque rotazione della vela adesso avviene intorno all’asse Zvela nuovo. Se immaginiamo un sistema vela_secondo, sovrapposto al sistema assi vela_primo, ma solidale alla vela, qualunque rotazione intorno allo strallo non modifica le coordinate della vela rispetto ad esso. Queste coordinate sono proprio quelle calcolate con la matrice funzione solo dell’angolo di rake. La rotazione relativa tra il sistema assi vela_secondo ed assi vela_primo deve essere tale da ottenere l’angolo di scotta desiderato.

(13)

Questi si misura sul piano orizzontale, perciò la rotazione ψ intorno allo strallo deve rispettare la condizione sin(ψ)=sin(angolo scotta-angolo_iniziale)/cos(rake), che rappresenta un valore noto. Assumendo le coordinate nel sistema assi vela_secondo come valori di partenza e desiderando conoscerle nel sistema assi_vela, dopo che la vela ha subito la rotazione ψ, il risultato si ottiene combinando la matrice di trasformazione nell’angolo rake con quella nell’ angolo ψ. Riassumendo:

Passo 1) terna di partenza assi_vela; terna di arrivo assi vela_primo; la terna di arrivo si sovrappone a quella di partenza con rotazione oraria su y_vela pari all’angolo di rake se lo strallo (asse z vela_primo) è inclinato verso poppa. Per convenzione quindi rake<0.

vela assi primo vela assi z y x rake rake rake rake z y x ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ ⋅ ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ − = ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ ) cos( 0 ) sin( 0 1 0 ) sin( 0 ) cos( _

Passo 2) prima che avvenga la rotazione intorno allo strallo

primo vela assi ondo vela assi z y x z y x _ sec _ ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ = ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡

In caso di rotazione intorno allo strallo, le coordinate non mutano rispetto ad assi vela_secondo, cambiano rispetto ad assi vela_primo.

) cos( ) 0 sin( ) sin( _ rake vela assi δ δ ψ = −

Passo 3) la rotazione necessaria intorno allo strallo vale:

dove δ= angolo di scotta desiderato e δ0= angolo di scotta della vela non modificata

ondo vela assi primo vela assi z y x z y x sec _ _ 0 0 1 0 ) cos( sin( 0 ) sin( ) cos( ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ ⋅ ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ − = ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ ψ ψ ψ ψ

(14)

Passo 4) assumendo dopo la rotazione la terna assi vela_secondo come terna di partenza e quella assi vela come terna di arrivo, passando per assi vela_primo:

ondo vela assi T vela assi z y x rake rake rake rake z y x sec _ 1 0 0 0 ) cos( sin( 0 ) sin( ) cos( ) cos( 0 ) sin( 0 1 0 ) sin( 0 ) cos( ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ ⋅ ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ − ⋅ ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ − = ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ ψ ψ ψ ψ

Passo 5) da assi vela ad assi barca è necessaria eventualmente una traslazione

barca assi vela assi barca assi zmura ymura xmura z y x z y x ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ + ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡ = ⎥ ⎥ ⎥ ⎦ ⎤ ⎢ ⎢ ⎢ ⎣ ⎡

2.6

Interpolazione, modifica griglia e scrittura IGES

Senza entrare nei dettagli della teoria delle B-Spline, la famiglia di curve utilizzate per l’interpolazione della superficie, si vogliono elencare le operazioni preliminari che sono necessarie per scrivere un file IGES o accedere alla fase di ottimizzazione.

La vela è nota attraverso una griglia di punti. Al fine di generarne di dimensione diversa può essere necessario interpolarla. Ciò accade nei seguenti casi:

• Se si sceglie di scrivere un file IGES con una maggiore densità di punti appartenenti alla superficie.

• Se è necessario variare la dimensione della griglia per risolvere problemi di tempo di calcolo, e/o convergenza del metodo di ottimizzazione. Una griglia eccessivamente fitta può indurre tempi di calcolo molto più grandi o addirittura generare un errore numerico che non consente di rispettare le tolleranze impostate per stabilire la convergenza della fase di ottimizzazione.

• si desidera lavorare con griglie iso-u e iso-v, nel senso introdotto nel paragrafo 1.5.6. In ogni caso lo schema logico seguito si può rappresentare come segue:

(15)

Figura -2.4 Diagramma per la modifica della griglia

2.7

Attivazione di GAMBIT e FLUENT in cascata

gambit_journal_editor e fluent_journal_editor

La premessa a tale fase è quella di avere a disposizione dei file journal che si sono dimostrati affidabili. Questi file, generati dai programmi di analisi fluidodinamica stessi, come report delle prove condotte, contengono le istruzioni ed i settaggi per la sessione di calcolo prodotta con GAMBIT e FLUENT. In particolare, i codici CFD sono in grado di caricare tali file-testo interpretandoli come un insieme di righe di comando. Ciò rende possibile ripetere una prova con gli stessi settaggi. Partendo da un file journal di riferimento per GAMBIT ed da uno per FLUENT, si sono scritti due programmi in grado di editare, ad ogni iterazione del loop di calcolo, i file journal necessari. Essi sono in grado di modificare alcuni parametri sulla base delle scelte iniziali: la velocità del vento apparente, la sua direzione, le proporzioni dei sottovolumi che costituiscono il dominio da discretizzare, la dimensione della mesh in alcuni tratti. Al variare dell’ iterazione essi modificano anche il

(16)

(17)

path ed il nome dei file da caricare, creare, salvare, coerentemente con la struttura che è stata definita per organizzare la divisione dei dati generati durante la sessione di calcolo. Tali programmi fanno un uso esteso dei comandi fopen, fprintf, fclose, per i quali si rimanda all’help di Matlab[3]. Le routine costruite sono state indicate con i nomi di gambit_journal_editor e fluent_journal_editor.

La routine calcolo_CFD

Il controllo dell’attivazione in cascata dei programmi GAMBIT e FLUENT è stato affidato ad una function appositamente scritta. Terminata la fase preparatoria di scrittura dei file journal specifici per l’iterazione che la procedura sta sviluppando, il file “manager” passa il controllo alla function “calcolo_CFD”( Il diagramma di flusso di tale file è presentato nella fig. 2.5). Al termine della scrittura dei file .dat con i valori delle pressioni, il file manager attiva la parte successiva della procedura.

L’avvio dei programmi è possibile utilizzando una stringa di comando attivata con l’opzione “ eval” di Matlab [3]. Per la struttura delle stringhe che è necessario scrivere se si desidera avviare GAMBIT e FLUENT, si può consultare la guida dei rispettivi programmi alle voci “ STARTUP COMMAND” [1] e “STARTUP OPTIONS” [2]. Di seguito è descritto brevemente come sono state usate nel caso specifico.

STRINGA DI COMANDO CHE CONSENTE DI ATTIVARE GAMBIT DA MATLAB:

str_g=['! gambit id gambit_it',num2str(ind_loop),' init',path_jou_g,' -new'];

eval(str_g); % lancia gambit

Si apre una sessione gambit_it1, gambit_it2, etc., al variare dell’indice “ind_loop” dell’iterazione del loop di calcolo; si leggono le istruzioni per importare la vela, costruire il dominio, definire la mesh, esportare quest’ultima all’esterno. Tutto questo è scritto nel file journal il cui nome è stato preventivamente salvato nella stringa “path_jou_g”, e che costituisce il vero input. Prima di chiudersi, GAMBIT genera un file journal, un file .trn ed un file .dbs con lo stesso nome della sessione gambit_it1, etc.

Il file journal contiene le operazioni eseguite in cascata dal programma ed è una copia del file journal usato come modello. Il file .trn contiene avvisi, eventuali errori o conferma dell’ esito positivo delle singole operazioni. Il file .dbs contiene la geometria generata: la sua

(18)

apertura consente di visualizzare oggetti grafici e geometrici generati senza ripetere le operazioni in cascata.

PAUSA DI SESSANTA SECONDI

È una necessità, per evitare che FLUENT si apra prima che GAMBIT sia stato definitivamente chiuso. Questo, in un ambiente di calcolo dove già altre licenze sono attive e limitate numericamente, provocherebbe la sovrapposizione delle licenze con il rischio di interruzione della procedura.

STRINGA DI COMANDO CHE CONSENTE DI ATTIVARE FLUENT DA MATLAB

str_f=['! fluent 3d -i ',path_jou_f]; eval(str_f); % lancia fluent

l’input è costituito dalla stringa “ path_jou_f “, contenente il percorso del file journal con le istruzioni per FLUENT, ovvero quale mesh importare, quale solutore usare, quali dati esportare, dove scriverli.

CHIUSURA AUTOMATICA DI GAMBIT E FLUENT:

La chiusura automatica di GAMBIT è possibile usando come ultima riga del file journal la stringa “ end force” [1] .

La chiusura automatica di FLUENT è possibile usando come ultima riga del file journal la stringa “ exit” [2].

Ciclo WHILE:

La struttura appare più articolata di quanto ci si aspetti, a causa del problema riscontrato e già descritto nel paragrafo 1.5.2: una successione di comandi in MATLAB attende la chiusura di GAMBIT per proseguire, ma non fa lo stesso se viene lanciato FLUENT. È stato necessario quindi “catturare” Matlab in un ciclo WHILE, fino a quando non fosse terminata la sessione di calcolo di FLUENT e fossero disponibili i file .dat con i valori delle pressioni relative alla faccia sottovento (tabella_pressioni_vela) e alla faccia

(19)

sopravento (tabella_pressioni_velashad). La routine deve essere quindi in grado di distinguere tre diverse situazioni:

• FLUENT non ha ancora scritto il file .dat delle pressioni. • La scrittura è in corso.

• La scrittura è terminata.

La prima verifica avviene per il file delle pressioni relative alla faccia sottovento, fase evidenziata nella fig. 2.5 con il tratteggio rosso. La verifica è ciclica, come imposto dal ciclo WHILE. Fino a quando FLUENT non ha terminato di scrivere il primo file .dat, il programma definisce una variabile cosa_fare1=0, che esclude la verifica del secondo file .dat ancora non scritto, e obbliga MATLAB ad attendere senza passare il controllo al file manager. Verificata la scrittura del primo file .dat, la variabile cosa_fare1 assume il valore 1 e si controlla ciclicamente lo stato della generazione del secondo file. Questo aspetto è competenza della parte evidenziata con il tratteggio blu nella fig. 2.5. Analogamente, la variabile cosa_fare2 =0 resta costante fino alla chiusura anche del secondo file da parte di FLUENT. Quando entrambe le variabili hanno valore unitario il ciclo WHILE si interrompe e il controllo torna al file manager. Avere introdotto il controllo su entrambi i file scritti da FLUENT, svincola dall’ordine con cui si decide di scriverli.

Contemporaneamente il programma controlla in vari punti il valore della variabile stop_cfd. Essa è inizialmente uguale ad 1 e può essere modificata premendo in qualunque momento il pulsante “Interrompi”, che appare nella finestra di interfaccia grafica attivatasi al momento del lancio della routine calcolo_CFD. Una scelta di questo tipo provoca l’uscita forzata dal ciclo WHILE e ordina al programma manager di interrompere la procedura; vengono chiusi i file report.txt, si cancella dal path di MATLAB l’elenco delle cartelle contenenti i file per la procedura di calcolo. Naturalmente il programma che sta eseguendo l’analisi CFD, GAMBIT o FLUENT, deve essere chiuso con le tecniche consuete.

La spiegazione di come il programma possa riconoscere se FLUENT ha terminato di scrivere un file .dat e l’implementazione di questa fase sono descritte nelle figure successive, che illustrano nei dettagli ciò che accade nei riquadri evidenziati nella fig. 2.5 con un tratteggio rosso e blu. Ognuna delle porzioni tratteggiate è relativa ad un file diverso: quella rossa per le pressioni della faccia sottovento, quella blu per le pressioni della faccia sopravento. FLUENT associa automaticamente l’appellativo shadow alla faccia sopravento.

(20)

Il meccanismo è semplice, in quanto consiste nel tentativo di aprire in modalità lettura il file .dat di cui si conosce il percorso esatto. La funzione di MATLAB “fopen”, restituisce un identificatore per il file suddetto. Si distinguono già due condizioni:

• Identificatore fid=-1, il file non esiste. • Identificatore fid>0, il file esiste.

Nel secondo caso, per stabilire che effettivamente FLUENT abbia terminato la scrittura del file, si è adottato il criterio di contarne le righe, e verificare che il loro numero sia lo stesso per due conteggi successivi, separati da una pausa di quindici secondi. Se si verifica questa situazione, il programma ripete il conteggio delle righe, per escludere l’eventualità di un rallentamento della scrittura da parte di FLUENT. Se la condizione è ancora verificata, si ritiene la fase di scrittura del file conclusa.

Si nota inoltre come l’output delle due sezioni evidenziate sia proprio il valore della variabile di controllo associata: cosa_fare1 e cosa_fare2.

(21)

(22)

(23)

2.8

Filtro per le pressioni

Esiste una routine all’interno della procedura, denominata limita_dati, che può essere attivata dal pannello relativo alla selezione dei parametri che controllano la fase di ottimizzazione. Lo scopo di tale funzione è ridurre la dimensione dei file scritti da FLUENT, contenenti i dati delle pressioni, prima che vengano importati in MATLAB.

Quando la procedura importa una vela, si lavora con una griglia che ha dimensioni ridotte; nel caso del gennaker asimmetrico si conosce la superficie lungo una scacchiera di 21 linee verticali e 11 linee orizzontali, ovvero 231 nodi (se si scompone la penna in 21 punti). La griglia può essere modificata a piacere per generare un file IGES di dimensioni variabili o per definire una griglia strutturale in fase di ottimizzazione. Quando però si costruisce in GAMBIT la mesh di superficie, è necessario usare misure ridotte degli elementi geometrici. Su una superficie di circa 25 metri quadrati, una discretizzazione con triangoli aventi un lato di 50 mm, produce circa 22000 nodi. Il calcolo delle pressioni restituisce 22000 valori per ogni faccia, a cui si aggiungono le (22000 x 3) coordinate dei nodi stessi ed il numero identificativo del nodo, per una dimensione del file dat scritto di circa 0,5 MB.

Importare in MATLAB file estesi, trasformandoli in matrici, e la successiva elaborazione di queste grandezze, può produrre la saturazione dello spazio di memoria che MATLAB assegna ad una function per le variabili interne. Per evitare ciò, si può fare un uso esteso del comando “clear”, che cancella le variabili create e non più necessarie. Quando però la fonte dei dati è grande, (si possono immaginare applicazioni con un numero di nodi maggiore di 22000), può essere utile cancellare dei dati all’origine.

La routine limita_dati ha come input il numero limite dei dati che si desidera conservare. Il file viene aperto, letto e soltanto un numero parziale di dati viene salvato in una variabile di MATLAB, resa poi disponibile al programma che valuta i carichi. Il criterio è quello di stabilire uno step per la scansione e la lettura delle righe, tale da garantire un numero di dati prossimo al valore limite indicato come input.

Naturalmente il limite non deve incidere sulla valutazione dei carichi (forze), associati ai nodi della griglia strutturale, ovvero deve introdurre un elemento di approssimazione accettabile.

(24)

2.9

Post-processing

Durante la sessione di calcolo, i dati relativi alle griglie, gli spostamenti dei nodi, i parametri per stabilire la convergenza e altro, vengono raccolti nella cartella definita al momento del lancio della procedura e divisi per iterazione del loop. Conoscendo la distribuzione delle variabili e dei dati, è possibile poi organizzare delle procedure per estrarli in modo automatico, sulla base di una semplice selezione.

Attivando la stringa post_processing, si accede a un’interfaccia grafica (rappresentata nella figura 2.8). Dopo avere selezionato la sessione di lavoro, tra quelle presenti sul computer, si possono attivare le scelte grazie a dei menù a tendina o, nel linguaggio di MATLAB, popupmenu. Le opzioni sono le seguenti:

• scelta della vela, tra tutte quelle associate alla sessione di calcolo, immaginando in generale una configurazione multipla.

• rappresentazione delle superfici ottenute, utilizzando griglie con la dimensione di quella originale con cui si è importata la vela:

tutte le superfici solo le superfici scelte nessuna scelta

• rappresentazione delle superfici utilizzando la dimensione della griglia strutturale:

tutte le superfici solo le superfici scelte nessuna scelta

• rappresentazione degli spostamenti ∆x, ∆y, ∆z dei nodi, raccogliendo nello stesso grafico le tre componenti di spostamento dei nodi appartenenti alla stessa linea orizzontale iso-u della griglia:

spostamenti relativi ad ogni iterazione

spostamenti relativi ad una scelta precisa di iterazioni nessuna scelta

• storia di deformazione della generica sezione: sezione iso-v qualunque

sezione iso-u qualunque sezione iso-z qualunque

(25)

linea iso-v della griglia di superficie linea iso-u della griglia strutturale linea iso-v della griglia strutturale nessuna scelta

Alla rappresentazione grafica è associata la visualizzazione della variazione della freccia massima e della sua posizione % rispetto alla corda. Tutti questi dati vengono riprodotti anche sullo schermo, insieme all’angolo tra la corda della sezione e l’asse di simmetria della barca.

• rappresentazione dei parametri scelti per verificare la convergenza:

energia di deformazione i-esima iteraz./energia di def. alla iteraz. 1 spostamento massimo dei nodi

entrambi nessuna scelta

• cancellazione delle figure create con la selezione precedente. • pulsanti di controllo:

OK per confermare la scelta e visualizzare i risultati RESET per cancellare ogni selezione

INTERROMPI per concludere la fase di post-processing

È evidente come questa fase faccia uso di routine di interpolazione, in particolare per estrapolare da ogni superficie i dati relativi ad una sezione per ogni valore di u=[0,1] , v=[0,1] e z=[ zmin,zmax ]. Queste opzioni hanno richiesto routine dedicate, che utilizzassero la procedura di interpolazione con le B-Spline già sviluppata per la modifica della griglia e la scrittura del file IGES. Di seguito si mostra la finestra di interfaccia grafica che permette la scelta delle opzioni e alcuni risultati.

(26)

Figura -2.8 GUI per il post-processing

Selezionando la cartella polw90s50cc3, la richiesta di rappresentare una sezione a quota costante z=5000 mm, produce le stringhe di dati e le figure seguenti:

(27)

VELA gennaker- SEZ. ISO-Z CON Z= 5000 (mm)

iter. posizione % freccia massima % angolo (deg)

1 0.35 0.28 54.52 2 0.44 0.59 61.82 3 0.33 0.61 61.70 4 0.33 0.60 61.77 500 1000 1500 2000 2500 3000 0 500 1000 1500 2000

ascissa x (mm) a s ci s s a y ( m m ) sezione 1 sezione 2 sezione 3 sezione 4

Figura -2.9 Storia di deformazione della sezione iso-z con z=5000 mm

1 1.5 2 2.5 3 3.5 4 0.25 0.3 0.35 0.4 0.45 0.5 0.55 0.6 0.65 iterazioni

posizione % freccia massima %

(28)