OpenFOAM su server Linux, lavorando da Windows: SSH, FileZilla, PowerShell, log e ParaView client/server

OpenFOAM Foundation è sviluppato e distribuito per Linux. Su Windows esistono strade indirette (WSL2 con Ubuntu, container Docker, macchine virtuali), utili per studiare su un portatile, ma il server resta il posto giusto per il calcolo: più core e più RAM, dischi dimensionati per le cartelle dei tempi, possibilità di lasciare un calcolo acceso per ore o giorni senza tenere acceso il PC.

Il flusso descritto qui separa nettamente i ruoli. Su Windows restano gli strumenti grafici e la copia di lavoro dei file di configurazione; sul server stanno la copia eseguita del caso, i risultati e i log. Tre canali li collegano, tutti cifrati e tutti basati su SSH:

• SFTP (porta SSH, di solito 22): trasferimento di file, usato da FileZilla;
• SSH interattivo (stessa porta): un terminale Linux dentro PowerShell;
• tunnel SSH (port forwarding locale): porta il traffico di ParaView da localhost:11111 di Windows al pvserver del server senza aprire porte verso la rete.

Un solo servizio da autorizzare (SSH) e un solo segreto da custodire (password o chiave): è la configurazione che gli amministratori di sistema preferiscono, ed è il motivo per cui la guida non usa FTP in chiaro, desktop remoti o porte di ParaView esposte.

Su Windows 10 (dalla versione 1809) e su Windows 11 il client OpenSSH è una funzionalità facoltativa normalmente già presente. Dall’interfaccia: Impostazioni → App → Funzionalità facoltative → Aggiungi funzionalità → Client OpenSSH. Da PowerShell aperto come amministratore:

# stato delle funzionalità OpenSSH
Get-WindowsCapability -Online | Where-Object Name -like 'OpenSSH*'

# installazione del solo client
Add-WindowsCapability -Online -Name OpenSSH.Client~~~~0.0.1.0

# verifica (nuova finestra PowerShell)
ssh -V

Se Get-WindowsCapability riporta State : Installed per OpenSSH.Client, non c’è altro da fare. Il server OpenSSH di Windows non serve: il PC fa solo da client.

Con una coppia di chiavi non si digita la password a ogni connessione, e FileZilla e PowerShell usano la stessa identità. Si genera la chiave sul PC (la parte privata non lascia mai Windows) e si copia sul server soltanto la parte pubblica. Prima di farlo, verificare che l’amministratore consenta l’autenticazione a chiave.

# PowerShell: genera la coppia di chiavi (Invio per il percorso proposto,
# poi una passphrase per proteggere la chiave privata)
ssh-keygen -t ed25519

# Windows non ha ssh-copy-id: si accoda la chiave pubblica con un comando unico
type $env:USERPROFILE\.ssh\id_ed25519.pub | ssh UTENTE@SERVER "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

# prova: ora la connessione chiede la passphrase della chiave, non la password
ssh UTENTE@SERVER

In FileZilla, nel Site Manager, scegliere Logon Type: Key file e indicare C:\Users\NOME\.ssh\id_ed25519: FileZilla propone di convertirla nel proprio formato .ppk e la usa da quel momento. I permessi 700 sulla cartella ~/.ssh e 600 su authorized_keys sono obbligatori: con permessi più larghi il server SSH ignora la chiave e torna a chiedere la password.

Il client OpenSSH di Windows legge C:\Users\NOME\.ssh\config (file di testo senza estensione). Un alias raccoglie host, utente, porta, chiave e anche il tunnel per ParaView:

Host cfd
    HostName SERVER
    User UTENTE
    Port 22
    IdentityFile ~/.ssh/id_ed25519
    ServerAliveInterval 60

Host cfd-paraview
    HostName SERVER
    User UTENTE
    Port 22
    IdentityFile ~/.ssh/id_ed25519
    LocalForward 11111 127.0.0.1:11111
    ServerAliveInterval 60

Da quel momento ssh cfd apre il terminale e ssh cfd-paraview apre il terminale con il tunnel della sezione 9. ServerAliveInterval 60 invia un segnale ogni minuto e riduce le disconnessioni dovute a router o firewall che chiudono le sessioni inattive.

L’impronta (fingerprint) identifica il server: se coincide con quella attesa, si sta parlando con il server giusto e non con un intermediario. L’amministratore la ottiene sul server con:

ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
# esempio di uscita:
# 256 SHA256:Xy3k...q8M root@server (ED25519)

La stessa impronta compare nella finestra di FileZilla e alla prima connessione di ssh da PowerShell. Una volta accettata, Windows la registra in C:\Users\NOME\.ssh\known_hosts e FileZilla nella propria configurazione. Se in seguito compare l’avviso che la chiave host è cambiata, fermarsi e chiedere all’amministratore: può trattarsi di una reinstallazione del server, ma anche di un tentativo di intercettazione.

FileZilla ha un’impostazione Transfer type (Auto/ASCII/Binary), ma la conversione dei fine riga riguarda soltanto l’FTP. In SFTP i file viaggiano sempre byte per byte: un file salvato con terminazioni Windows (CRLF) arriva sul server con CRLF. Per questo i fine riga Unix (LF) vanno impostati nell’editor, come spiega la sezione 4, e non ci si può affidare al programma di trasferimento.

Il client OpenSSH di Windows include anche scp, utile per trasferimenti ripetitivi o da script. Da PowerShell, nella cartella C:\CFD\casi:

# carica l'intero caso (solo configurazione, cartella piccola)
scp -r .\mioCaso UTENTE@SERVER:~/cases/

# carica un solo dizionario modificato
scp .\mioCaso\system\controlDict UTENTE@SERVER:~/cases/mioCaso/system/

# scarica un log nella cartella dei log
scp UTENTE@SERVER:~/cases/mioCaso/log.foamRun C:\CFD\log\mioCaso\

Quando servono molti file piccoli (per esempio i dati di postProcessing/ o tutti i log), conviene raccoglierli prima in un archivio sul server e scaricare un solo file:

cd ~/cases/mioCaso
tar czf ~/mioCaso_log_post.tgz log.* postProcessing/
ls -lh ~/mioCaso_log_post.tgz

Windows 10/11 include tar e apre l’archivio con tar xzf mioCaso_log_post.tgz da PowerShell.

Dalla versione 11 della Foundation i singoli eseguibili come icoFoam o simpleFoam sono stati sostituiti da foamRun, che carica un modulo di solver. Il modulo si indica con la voce solver in system/controlDict:

application     foamRun;
solver          incompressibleFluid;

Per questo l’estratto della guida va letto come un frammento: in un caso reale accanto a application c’è la voce solver, e le altre voci (endTime, deltaT, writeControl) hanno valori legati alla fisica del caso. Il significato di ciascuna voce è spiegato in Parte 4: controlDict e controllo della simulazione. Per leggere il valore attuale senza aprire il file:

foamDictionary -entry solver system/controlDict
foamDictionary -entry endTime system/controlDict

In Notepad++ View → Show Symbol → Show All Characters mostra i terminatori: CR LF indica Windows, LF indica Unix. La barra di stato riporta sempre il formato corrente (Windows (CR LF) o Unix (LF)) e la codifica.

Sul server la diagnosi e la correzione sono immediate:

file Allrun
# Allrun: POSIX shell script, ASCII text, with CRLF line terminators   <- da correggere
# Allrun: POSIX shell script, ASCII text                               <- corretto

sed -i 's/\r$//' Allrun      # rimuove i CR (equivalente di dos2unix)
head -c 3 Allrun | od -c     # se compare 357 273 277 il file ha un BOM UTF-8

La prima riga di uno script deve essere esattamente #!/bin/sh (o #!/bin/bash), senza spazi tra # e ! e senza BOM davanti: è la riga che dice al sistema quale interprete usare. Gli script dei tutorial Foundation iniziano con #!/bin/sh seguito da cd ${0%/*} || exit 1, che porta lo script nella propria cartella qualunque sia la directory da cui viene lanciato.

Il file system di Windows non distingue maiuscole e minuscole, quello di Linux sì. Su Windows non possono coesistere U e u nella stessa cartella; su Linux sono due file diversi, e OpenFOAM cerca esattamente 0/U, 0/p, system/fvSchemes. Se un file arriva sul server come fvschemes o fvSchemes.txt, l’errore sarà del tipo cannot find file "system/fvSchemes". Controllare con ls -l system/ dopo ogni caricamento, e disattivare in Esplora file l’opzione che nasconde le estensioni note, così un .txt aggiunto per sbaglio resta visibile.

I pacchetti Ubuntu della Foundation installano OpenFOAM 14 in /opt/openfoam14 (tutto minuscolo, senza trattino); una compilazione da sorgente si trova di solito in $HOME/OpenFOAM/OpenFOAM-14; altri server usano percorsi propri o i module dell’ambiente di calcolo. Per trovare il file giusto:

ls -d /opt/openfoam* /opt/OpenFOAM* $HOME/OpenFOAM/OpenFOAM-* 2>/dev/null
module avail 2>&1 | grep -i foam        # solo se il server usa Environment Modules

Se l’ambiente non viene caricato automaticamente, si aggiunge una riga in fondo a ~/.bashrc (una sola volta), dopo averla provata a mano:

echo 'source /opt/openfoam14/etc/bashrc' >> ~/.bashrc
# nuova connessione SSH, poi:
foamVersion          # deve stampare la versione 14

Non aggiungere la riga se l’amministratore ha già previsto un altro meccanismo: caricare due volte ambienti diversi produce PATH incoerenti e errori difficili da leggere.

Nella stessa finestra convivono due mondi. Prima di ssh valgono i comandi di PowerShell e i percorsi Windows (C:\CFD, separatore \); dopo il login valgono bash e i percorsi Linux (/home/UTENTE, separatore /, ~ per la home). Alcuni nomi esistono in entrambi (ls, cd, pwd sono alias in PowerShell) ma si comportano diversamente: le opzioni -lh funzionano solo nel ls di Linux.

• Incollare: nel terminale di Windows si incolla con il clic destro o con Ctrl+V (Windows Terminal); per copiare basta selezionare con il mouse.
• Interrompere: Ctrl+C interrompe il comando Linux in esecuzione, non la connessione.
• Leggere un file lungo: less log.foamRun (frecce per scorrere, /testo per cercare, q per uscire); head -n 50 e tail -n 50 per l’inizio e la fine.
• Completamento: il tasto Tab completa nomi di file e comandi; due Tab elencano le possibilità.
• Storico: freccia su per richiamare i comandi precedenti, history | tail -n 30 per vederli.

2>&1 unisce l’uscita degli errori (stream 2) a quella normale (stream 1): senza, i messaggi FOAM FATAL ERROR comparirebbero a video ma non finirebbero nel log. tee duplica il flusso: lo mostra nel terminale e lo scrive nel file indicato.

Gli Allrun dei tutorial Foundation usano spesso le funzioni di $WM_PROJECT_DIR/bin/tools/RunFunctions:

#!/bin/sh
cd ${0%/*} || exit 1
. $WM_PROJECT_DIR/bin/tools/RunFunctions

runApplication blockMesh        # scrive log.blockMesh
runApplication foamRun          # scrive log.foamRun

runApplication crea da sé log.<programma> e si rifiuta di rieseguire un passo se il log esiste già, stampando un messaggio del tipo blockMesh already run on ... remove log file 'log.blockMesh' to re-run. È una protezione, non un errore: per rifare da capo si usa ./Allclean (se presente) oppure si rimuovono i log interessati. Leggere lo script prima di eseguirlo serve proprio a sapere quali log produrrà e dove guardare.

Una sessione tmux vive sul server: sopravvive alla chiusura di PowerShell, allo spegnimento del PC e alla caduta della rete. Non sopravvive al riavvio del server. Se tmux non è installato, screen offre la stessa funzione (screen -S nome, distacco con Ctrl+A poi D, rientro con screen -r nome).

Un server è di solito condiviso. Prima di lanciare un calcolo pesante conviene sapere quante CPU e quanta memoria ci sono e quanto sono occupate:

nproc                 # numero di core disponibili
free -h               # memoria totale e libera
uptime                # carico medio negli ultimi 1, 5, 15 minuti
top                   # processi attivi (q per uscire); htop se installato

Il flusso parallelo di OpenFOAM, trattato nel caso 05: calcolo parallelo con MPI, si avvia così, con il numero di sottodomini scritto in system/decomposeParDict:

decomposePar 2>&1 | tee log.decomposePar
mpirun -np 4 foamRun -parallel 2>&1 | tee log.foamRun
reconstructPar 2>&1 | tee log.reconstructPar

Il valore di -np deve coincidere con numberOfSubdomains. Rispettare le regole del server: alcuni impongono un numero massimo di core per utente o l’uso di un gestore di code (per esempio Slurm, con sbatch); in quel caso il calcolo non si lancia in tmux ma con lo script di coda indicato dall’amministratore.

Ogni passo temporale (o iterazione, nei casi stazionari) produce un blocco come questo; la forma esatta dipende dal modulo di solver e dagli algoritmi scelti in fvSolution:

Courant Number mean: 0.0742 max: 0.4121
Time = 0.005s

smoothSolver:  Solving for Ux, Initial residual = 0.0213, Final residual = 4.1e-07, No Iterations 3
smoothSolver:  Solving for Uy, Initial residual = 0.0390, Final residual = 6.2e-07, No Iterations 3
GAMG:  Solving for p, Initial residual = 0.214, Final residual = 0.0097, No Iterations 4
time step continuity errors : sum local = 1.2e-08, global = 3.4e-10, cumulative = 3.4e-10
GAMG:  Solving for p, Initial residual = 0.0182, Final residual = 8.8e-07, No Iterations 9
ExecutionTime = 1.52 s  ClockTime = 2 s

• Courant Number: rapporto tra spostamento del fluido in un passo e dimensione della cella; il massimo va confrontato con maxCo quando il passo è adattivo.
• Initial residual: quanto il campo del passo precedente non soddisfa l’equazione all’inizio del passo; è il valore da seguire nel tempo.
• Final residual e No Iterations: dove si è fermato il solutore lineare e quante iterazioni ha fatto, in base a tolerance e relTol.
• continuity errors: errore di conservazione della massa dopo la correzione di pressione.
• ExecutionTime / ClockTime: tempo di CPU e tempo reale trascorso; la differenza cresce se il server è carico o se il disco è lento.

Il significato di residui, tolleranze e algoritmi è sviluppato in Parte 6: fvSolution, solutori lineari e algoritmi.

Interrompere con Ctrl+C o kill ferma il processo senza scrivere l’ultimo tempo. Se runTimeModifiable è attivo (è il valore predefinito), OpenFOAM rilegge controlDict durante il calcolo, e si può chiedere una chiusura pulita:

cd ~/cases/mioCaso
foamDictionary -entry stopAt -set writeNow system/controlDict
# il solver scrive il tempo corrente ed esce al passo successivo
tail -f log.foamRun

Dopo l’arresto riportare stopAt a endTime prima di ripartire. Solo se il processo è bloccato si usa kill PID (il PID si legge con ps); kill -9 è l’ultima risorsa. Le opzioni di arresto e ripartenza sono descritte in Parte 4.

Ogni tempo scritto contiene tutti i campi su tutte le celle; con mesh grandi e scritture frequenti il disco si riempie in fretta, e un disco pieno interrompe il calcolo con errori di scrittura. Controllare spesso:

df -h ~                     # spazio libero nel file system della home
du -sh ~/cases/mioCaso      # occupazione del caso
du -sh ~/cases/mioCaso/* | sort -h | tail   # le cartelle più grandi

In controlDict, purgeWrite N conserva solo gli ultimi N tempi; writeCompression on comprime i campi scritti. Prima di cancellare risultati, chiedersi se servono per il confronto o la validazione: la cancellazione su Linux non passa da un cestino.

• Apertura: klogg indicizza il file in background e apre senza problemi log di centinaia di megabyte, che Notepad++ gestisce con fatica.
• Ricerca: la casella in basso accetta espressioni regolari; i risultati compaiono in un riquadro separato e un clic porta alla riga nel file completo.
• Evidenziatori: si possono definire colori fissi per FOAM FATAL, Courant Number, Time =, così le righe importanti saltano all’occhio scorrendo.
• Follow: con la modalità follow klogg rilegge il file quando cambia; utile su una copia locale aggiornata periodicamente, non sostituisce tail -f sul server.

Il sito del progetto è https://klogg.filimonov.dev/; il codice sorgente e le note di rilascio sono su GitHub.

OpenFOAM include l’utility foamLog, che legge un log e crea la cartella logs/ con un file a due colonne per ogni grandezza (tempo, valore): per esempio logs/Ux_0, logs/p_0, logs/CourantMax_0. Sul server:

cd ~/cases/mioCaso
foamLog log.foamRun
ls logs/
tar czf logs_residui.tgz logs/      # un solo file da scaricare con FileZilla

In alternativa, su Windows, uno script Python legge il log scaricato e produce un CSV apribile in Excel o un grafico:

# residui.py  -  uso: python residui.py log.foamRun
import re, sys, csv
t = None
rows = []
rx_t = re.compile(r'^Time = ([0-9.eE+-]+)')
rx_r = re.compile(r'Solving for (\w+), Initial residual = ([0-9.eE+-]+)')
seen = set()
with open(sys.argv[1], encoding='utf-8', errors='replace') as f:
    for line in f:
        m = rx_t.match(line)
        if m:
            t = float(m.group(1)); seen = set(); continue
        m = rx_r.search(line)
        if m and t is not None and m.group(1) not in seen:   # primo residuo del passo
            seen.add(m.group(1))
            rows.append((t, m.group(1), float(m.group(2))))
with open(sys.argv[1] + '.csv', 'w', newline='') as f:
    w = csv.writer(f); w.writerow(['time', 'field', 'initial_residual']); w.writerows(rows)
print(len(rows), 'righe scritte in', sys.argv[1] + '.csv')

Lo script conserva solo il primo Initial residual di ogni campo per ciascun passo, che è il valore significativo quando la pressione viene risolta più volte nello stesso passo. In Excel si costruisce poi un grafico a dispersione con asse verticale logaritmico, filtrando per campo.

L’opzione -L 11111:127.0.0.1:11111 si legge così: porta locale 11111 sul PC Windows → destinazione 127.0.0.1:11111 vista dal server. ParaView si collega a localhost:11111 sul PC; il client SSH prende quel traffico, lo cifra dentro la connessione SSH già autenticata e il server SSH lo consegna a pvserver, che ascolta solo sul proprio loopback grazie a --bind-address=127.0.0.1. Dall’esterno nessuno vede la porta 11111.

Se si preferisce tenere separati tunnel e terminale, il tunnel si apre da solo con -N (nessun comando remoto) in una finestra dedicata, e pvserver si lancia da una seconda sessione SSH o dentro tmux:

# finestra 1 (resta aperta, non mostra un prompt)
ssh -N -L 11111:127.0.0.1:11111 UTENTE@SERVER

# finestra 2
ssh UTENTE@SERVER
pvserver --server-port=11111 --bind-address=127.0.0.1

Con il file ~/.ssh/config della sezione 2 basta ssh cfd-paraview.

Client e server ParaView devono avere la stessa versione principale e secondaria (per esempio 5.13 con 5.13): con versioni diverse la connessione viene rifiutata con un messaggio di incompatibilità. Sul server la versione si legge con pvserver --version; su Windows in Help → About.

Se la porta è occupata (Address already in use), si scopre chi la usa:

# Windows PowerShell
netstat -ano | findstr :11111
# Linux
ss -ltnp | grep 11111

Spesso è un pvserver rimasto acceso da una sessione precedente: si chiude con Ctrl+C nella sua sessione, o con kill PID se la sessione è persa. Su un server con più utenti conviene che ognuno usi una porta propria, per esempio 11112: ssh -L 11112:127.0.0.1:11112, pvserver --server-port=11112 e porta 11112 nella configurazione di ParaView. Le tre porte devono coincidere.

• Case Type: Reconstructed Case legge le cartelle dei tempi nella radice del caso; Decomposed Case legge direttamente processor*/ e in parallelo, se pvserver è avviato con più processi.
• Mesh Regions: internalMesh è il volume; le singole patch (inlet, outlet, walls) si attivano separatamente e permettono di vedere le grandezze sui contorni.
• Cell Arrays: i campi da caricare; caricare solo quelli che servono riduce memoria e tempo.
• Skip Zero Time: attivo per impostazione predefinita, nasconde la cartella 0/ con le condizioni iniziali; disattivarlo per vederle.
• Refresh (o Reload Files): durante un calcolo ancora in corso aggiorna l’elenco dei tempi scritti senza riaprire il caso.

Il caso parallelo e la scelta tra lettura scomposta e ricostruzione sono trattati nel caso 05.

Le build di ParaView per server senza schermo usano EGL (scheda grafica) oppure OSMesa (rendering software su CPU). Con una build che le supporta, l’opzione --force-offscreen-rendering evita di cercare un display X11:

pvserver --server-port=11111 --bind-address=127.0.0.1 --force-offscreen-rendering
# più processi per dataset grandi (build con MPI):
mpiexec -np 4 pvserver --server-port=11111 --bind-address=127.0.0.1

Se il server non dispone di un pvserver utilizzabile, restano due strade. La prima è estrarre sul server solo ciò che serve e scaricarlo: per esempio foamToVTK -latestTime crea file VTK dell’ultimo tempo, apribili con ParaView in locale dopo il download. La seconda è automatizzare le immagini con pvbatch o pvpython sul server e scaricare soltanto i PNG. In entrambi i casi il volume dei dati trasferiti va controllato prima, con du -sh.

Per fare l’esercizio senza un caso proprio si copia un tutorial nell’area di lavoro. Con l’ambiente OpenFOAM caricato:

mkdir -p ~/cases
cp -r $FOAM_TUTORIALS/incompressibleFluid/cavity ~/cases/mioCaso
cd ~/cases/mioCaso
ls
foamDictionary -entry solver system/controlDict

Il caso è piccolo, si calcola in pochi secondi e contiene mesh, campi e dizionari completi. Per lavorarci da Windows si scarica una volta l’intera cartella con FileZilla nella copia locale C:\CFD\casi\mioCaso (prima che esistano le cartelle dei tempi) e da lì si segue la procedura. Se il percorso del tutorial è diverso nella propria installazione, ls $FOAM_TUTORIALS/incompressibleFluid mostra quelli disponibili.

# ambiente e verifica
source /opt/openfoam14/etc/bashrc      # percorso dei pacchetti Ubuntu Foundation
command -v foamRun ; foamVersion

# script e file
file Allrun ; sed -i 's/\r$//' Allrun  # diagnosi e correzione CRLF
foamDictionary -entry endTime system/controlDict

# risorse e spazio
nproc ; free -h ; uptime ; df -h ~ ; du -sh ~/cases/mioCaso

# arresto ordinato
foamDictionary -entry stopAt -set writeNow system/controlDict

# residui in colonne
foamLog log.foamRun ; tar czf logs_residui.tgz logs/

# porte occupate
ss -ltnp | grep 11111                  # Linux
netstat -ano | findstr :11111          # Windows