OpenFOAM 14, parte 2: costruire una mesh con blockMeshDict

Parte 2 di 8 della serie sulla costruzione del caso nel percorso Imparare OpenFOAM 14: dalla geometria a una mesh di volume verificata.

Il compito. Costruire un canale tridimensionale a partire da otto vertici, sceglierne la distribuzione delle celle, assegnare ogni faccia di contorno e verificare la mesh generata.
Il risultato. Un system/blockMeshDict completo, un caso minimo che contiene solo la mesh e un metodo per leggere la documentazione ufficiale corrispondente.

Come usare questa parte

La Parte 1 ha introdotto il linguaggio e la cartella concettuale trainingChannel. Questa parte trasforma quel nome in una mesh concreta. Appartiene alla serie sulla costruzione dei dizionari, non ai primi casi pratici.

Tieni un terminale e questo articolo uno accanto all’altro. Leggi prima le sezioni su geometria e ordinamento, poi scrivi i file completi delle sezioni 10 e 11. Le note con le risposte sono nella sezione 20, dopo gli esercizi.

Percorso di lettura	Sezioni	Che cosa farai
Specificare e descrivere	1–4	Fissare le dimensioni, etichettare i vertici e definire un blocco destrorso.
Distribuire le celle	5–7	Scegliere la risoluzione e capire il grading in un verso o simmetrico.
Dare un nome al contorno	8–9	Separare identità della patch, tipo di mesh e ordine delle facce.
Costruire e ispezionare	10–15	Creare i due file, generare la mesh e confrontare con le previsioni.
Lavorare da soli	16–20	Modificare, diagnosticare e costruire un secondo canale.
Usare la documentazione	21 e riferimenti	Trovare sintassi, esempi e riferimenti primari.

Risultato principale
Dovresti saper spiegare come ogni sezione principale di blockMeshDict cambia la geometria, la topologia, la distribuzione delle celle o l’assegnazione delle patch. Un file che funziona senza questa spiegazione non è il punto d’arrivo.

Ambito e prerequisiti

Usa una shell Bash con OpenFOAM 14 della Foundation caricato e una tua cartella dei casi scrivibile. Servono la modifica e la navigazione di base, più la sintassi dei dizionari della Parte 1. Non servono sviluppo C++, modelli CAD, modelli di turbolenza o solutori di flusso.

Riquadri di richiamo facoltativi
I riquadri «richiamo facoltativo» contengono contesto o derivazioni. Si possono saltare senza interrompere il percorso pratico principale.

Documentazione: Parte 1, §1.1 e §B.1. I riferimenti pubblici [R1]–[R10] sono in fondo all’articolo.

1. Specificare il canale prima di scrivere

L’esempio è un condotto rettangolare tridimensionale. La direzione prevista del flusso è +x. Tutte e quattro le facce lunghe sono pareti; le facce di estremità normali a x sono ingresso e uscita. Sono scelte didattiche, non dimensioni di un reattore o impostazioni validate sperimentalmente.

Grandezza	Valore	Significato
Lunghezza L	100 mm	x: dall’ingresso all’uscita
Altezza H	10 mm	y: tra la parete inferiore e quella superiore
Profondità W	5 mm	z: tra le due pareti laterali
Celle	40 × 10 × 5	Direzioni locali x, y e z
Grading	1 × 1 × 1	Inizialmente uniforme in ogni direzione
Nomi delle patch	inlet / outlet / walls	I nomi che passeranno ai file di campo

Scrivi prima queste previsioni
Il bounding box nel sistema SI predefinito va da (0 0 0) a (0.1 0.01 0.005) m. Le celle sono 2.000. Il volume è 5 × 10⁻⁶ m³. Userai queste previsioni indipendenti per scoprire errori di unità e di risoluzione.

Documentazione: [R1], §§5.4.2–5.4.5. Valori numerici e geometria di questa parte sono esempi didattici originali.

2. Il file è una ricetta, non la mesh

blockMesh legge la descrizione dei blocchi, crea celle e connettività e scrive una mesh in constant/polyMesh/. Gli otto vertici del blocco sono punti di controllo per la costruzione; non sono l’elenco completo dei punti della mesh generata.

system/blockMeshDict
        |
        |  blockMesh
        v
constant/polyMesh/
    points   faces   owner   neighbour   boundary

Voce	Come si legge	Ruolo in questa parte
FoamFile	Un sotto-dizionario tra graffe	Identifica un oggetto dizionario chiamato blockMeshDict.
units	Una voce di unità di lunghezza	Fa interpretare le coordinate in millimetri.
vertices	Una lista tra parentesi tonde	Fornisce le coordinate degli otto angoli.
blocks	Una lista tra parentesi tonde	Definisce connettività, numero di celle e grading.
boundary	Una lista di sotto-dizionari con nome	Assegna alle patch le sei facce esterne del blocco.

Leggi la punteggiatura come struttura

Un vettore come (100 10 5) è una lista di componenti. Una voce vertices (...); termina con un punto e virgola dopo la parentesi di chiusura. Il corpo di ogni patch usa le graffe. La voce boundary stessa è una lista, non un unico sotto-dizionario tra graffe.

Omesso di proposito
Gli spigoli rettilinei non richiedono la voce edges. Questo caso a un solo blocco non richiede nemmeno mergePatchPairs. Nessuna faccia esterna verrà lasciata a una patch predefinita implicita. Aggiungi una funzione solo quando la geometria la richiede.

Documentazione: [R1], §§5.4.1, 5.4.4, 5.4.7–5.4.8; [R2]; grammatica dei dizionari: [R4].

3. Vertici: le etichette sono posizioni nella lista

La prima voce di vertices ha etichetta 0, la seconda etichetta 1, e così via. I commenti sono promemoria per chi legge; i commenti non assegnano le etichette. Riordinare la lista cambia il significato di tutti i riferimenti alla lista.

units [mm];

vertices
(
    (  0   0  0)   // 0
    (100   0  0)   // 1
    (100  10  0)   // 2
    (  0  10  0)   // 3
    (  0   0  5)   // 4
    (100   0  5)   // 5
    (100  10  5)   // 6
    (  0  10  5)   // 7
);

Un rapido controllo di coerenza

I vertici 0-3 stanno a z = 0; i vertici 4-7 a z = 5 mm. Ogni coppia attraverso la profondità differisce solo in z. Le coordinate x valgono solo 0 o 100; le coordinate y solo 0 o 10.

Unità: converti una volta sola
Con units [mm]; scrivi 100 per 100 mm, non 0.1. La mesh generata usa l’unità di lunghezza di base, il metro nell’impostazione SI predefinita. Non aggiungere anche un fattore scale da millimetri a metri a questo esempio.

Documentazione: [R1], §§5.4.2–5.4.3; [R4], unità e sintassi delle liste.

4. L’ordine del blocco hex definisce le direzioni locali

blocks
(
    hex (0 1 2 3 4 5 6 7) (40 10 5)
    simpleGrading (1 1 1)
);

hex descrive un blocco esaedrico. Le prime quattro etichette percorrono un quadrilatero; le quattro successive sono i vertici corrispondenti nella terza direzione. In questo particolare blocco rettangolare le direzioni locali coincidono con le x, y e z globali.

Direzione locale	Come si identifica qui	Controlla
1: +x	0 → 1	40 celle; primo valore di grading
2: +y	1 → 2 (parallela a 0 → 3)	10 celle; secondo valore di grading
3: +z	0 → 4	5 celle; terzo valore di grading

Perché l’ordine non può essere arbitrario

Il blocco deve essere destrorso. Per questo esempio rettangolare prendi e₁ = r₁ − r₀, e₂ = r₃ − r₀ ed e₃ = r₄ − r₀. Il loro prodotto misto è positivo. Uno scambio arbitrario di etichette può capovolgere o torcere il blocco invece di limitarsi a rinominarne gli angoli.

Richiamo facoltativo / orientazione destrorsa
Per questo parallelepipedo, (e₁ × e₂) · e₃ = LHW = 5.000 mm³ > 0. Il segno controlla l’orientazione; il valore è il volume. Questo calcolo su un solo angolo non è un test di qualità generale per un esaedro curvo o deformato.

Distinguere un blocco dalle sue celle

Una voce hex non significa una cella di calcolo. Descrive la regione che verrà suddivisa in 40 × 10 × 5 = 2.000 celle. Ruotare un blocco può cambiare la relazione tra le direzioni locali dei conteggi di celle e gli assi globali.

Documentazione: [R1], §5.4.5; [R8], descrizione dell’ordinamento dei blocchi. Calcolo del prodotto misto: derivato per questo esempio.

5. La risoluzione è indipendente dalle dimensioni

Le coordinate fissano il dominio fisico. Il numero di celle fissa quanto finemente viene diviso quel dominio. Con grading uniforme, le dimensioni di riferimento delle celle si ottengono direttamente dalle tre lunghezze.

Direzione	Calcolo	Dimensione della cella
x	100 mm / 40	2,5 mm
y	10 mm / 10	1,0 mm
z	5 mm / 5	1,0 mm

Prevedi prima di modificare il file

Modifica	Numero di celle	Che cosa resta uguale
Riferimento: (40 10 5)	2.000	Dominio di riferimento e patch
Solo x: (80 10 5)	4.000	Dimensioni del dominio; larghezze delle celle in y e z
Tutte le direzioni: (80 20 10)	16.000	Dimensioni del dominio e posizione delle patch
L doppia; (40 10 5) invariato	2.000	Topologia; le celle in x diventano lunghe il doppio

Raddoppiare i conteggi in tre direzioni moltiplica per otto il numero di celle. Questa aritmetica da sola non dice di quanto aumenta il tempo di simulazione, che dipende anche dal solutore, dal passo temporale e dalla convergenza.

Richiamo facoltativo / le celle sono volumi di controllo
Il metodo dei volumi finiti fa il bilancio delle grandezze sulle celle e scambia flussi attraverso le loro facce. Infittire cambia l’approssimazione spaziale; non aggiunge nuove dimensioni fisiche al problema. Una mesh che supera i controlli geometrici può comunque essere troppo grossolana per la grandezza che interessa.

Non trasformare per sbaglio un condotto 3D in un modello 2D

Il riferimento ha cinque celle in profondità e patch di parete su entrambe le facce z. Una mesh spessa una sola cella non è automaticamente un modello bidimensionale valido. Una direzione empty richiede una geometria compatibile e condizioni di campo coerenti; in questa parte non si usa.

Documentazione: [R1], §5.4.5; vincoli bidimensionali: [R3]. Tutti i conteggi delle tabelle sono previsioni analitiche.

6. Grading: cella finale divisa cella iniziale

Per una direzione con N celle, simpleGrading usa il rapporto di espansione complessivo E = Δ_ultima/Δ_prima. Non è il rapporto tra celle vicine. Qui la direzione y va dalla parete inferiore a y = 0 a quella superiore a y = H.

simpleGrading (1 4 1)

Per H = 10 mm, N = 10 ed E = 4, la prima cella è larga circa 0,4542 mm e l’ultima circa 1,8170 mm. Il numero di celle e l’altezza totale restano invariati.

Richiamo facoltativo / progressione geometrica
Con N > 1, le larghezze di celle vicine hanno rapporto q = E^1/(N−1). Per q ≠ 1, Δ_prima = H(q − 1)/(q^N − 1). Per E = 1 si usa Δ = H/N. In questo esempio q ≈ 1,1665, non 4.

Una previsione utile

Passare da (1 1 1) a (1 4 1) infittisce vicino a y = 0 e dirada vicino a y = H. Non infittisce entrambe le pareti. Passare a (1 0.25 1) inverte quella distribuzione.

Documentazione: [R1], §5.4.5. Le larghezze delle celle e la Figura 3 seguono la progressione geometrica qui sopra.

7. Facoltativo: infittire verso entrambe le pareti

Un solo rapporto dà un grading in un verso solo. Per restare con un unico blocco ma infittire verso entrambe le pareti y, si divide la direzione y in due sezioni di grading. Questo esempio facoltativo usa 20 celle in y invece delle 10 del riferimento.

blocks
(
    hex (0 1 2 3 4 5 6 7) (40 20 5)
    simpleGrading
    (
        1
        (
            (0.5 0.5 4)
            (0.5 0.5 0.25)
        )
        1
    )
);

Ogni terna interna significa (frazione di lunghezza, frazione di celle, rapporto di espansione). La metà inferiore occupa il 50% dell’altezza e riceve il 50% delle 20 celle in y. La metà superiore fa lo stesso, con l’espansione reciproca.

Che cosa verificare

La nuova mesh contiene 4.000 celle e ha lo stesso bounding box. Le celle vicine a ciascuna parete y sono larghe circa 0,2271 mm; le due celle adiacenti al centro circa 0,9085 mm. Questi valori valgono solo per questo esempio.

Mantieni semplice il percorso principale
Per il primo build riuscito usa il riferimento uniforme della sezione 10. Questa estensione introduce liste annidate e il grading verso due pareti opposte; non introduce i requisiti di risoluzione vicino alla parete dei modelli di turbolenza.

Documentazione: [R1], §5.4.6. L’esempio a due sezioni e i valori numerici sono costruiti per questa parte.

8. Una patch ha un nome e un tipo di mesh

Una patch di contorno raggruppa facce esterne. Il nome è un identificatore che scegli tu; il tipo di mesh descrive il genere di patch. Nessuno dei due, da solo, prescrive la velocità in ingresso o la pressione in uscita.

Nome della patch	Tipo di mesh	Facce incluse
inlet	patch	La faccia di estremità a x = 0
outlet	patch	La faccia di estremità a x = L
walls	wall	Entrambe le facce y ed entrambe le facce z

Un frammento dentro la lista boundary, non un file completo:

inlet
{
    type patch;
    faces ((0 4 7 3));
}

Le parentesi esterne dopo faces contengono una lista di facce. Quelle interne contengono le quattro etichette di vertice di questa faccia del blocco. La patch walls usa la stessa sintassi ma contiene quattro facce.

Descrizione della mesh e condizione del campo

Nel dizionario della mesh	Più avanti, in un file di campo
walls { type wall; ... }	U può imporre noSlip sulla patch walls.
inlet { type patch; ... }	U può prescrivere lì una velocità; p ha una propria condizione.

I futuri file 0/U e 0/p faranno riferimento a questi nomi di patch. La Parte 3 spiega quelle condizioni di campo. Per ora non creare un file di velocità o di pressione solo per far girare un comando di mesh.

Perché raggruppare quattro facce?
Le quattro facce lunghe hanno lo stesso tipo di mesh e all’inizio avranno le stesse condizioni di campo. Separale in patch distinte più avanti solo quando una condizione al contorno o una misura richiede quella distinzione. Il raggruppamento cambia l’identità, non la risoluzione delle celle.

Documentazione: [R1], §5.4.7; vincoli e tipi della mesh: [R3].

9. Percorri ogni faccia lungo i suoi spigoli

Una voce di faccia è un giro attraverso quattro angoli collegati, non un insieme di quattro etichette in ordine qualsiasi. La tabella usa giri orientati verso l’esterno per chiarezza. Insieme coprono tutte e sei le facce esterne del blocco.

Posizione	Giro nel blockMeshDict	Normale uscente	Patch
x = 0	(0 4 7 3)	−x	inlet
x = L	(1 2 6 5)	+x	outlet
y = 0	(0 1 5 4)	−y	walls
y = H	(3 7 6 2)	+y	walls
z = 0	(0 3 2 1)	−z	walls
z = W	(4 5 6 7)	+z	walls

Distinzione importante della v14
La guida v14 ammette entrambi i versi di percorrenza di una faccia di contorno del blockMeshDict, purché i vertici consecutivi seguano spigoli collegati. L’ordine verso l’esterno qui è una convenzione didattica, non un requisito aggiuntivo del parser. La polyMesh generata usa una propria orientazione coerente owner/neighbour delle facce.

Per un controllo su questo esempio rettangolare: il prodotto vettoriale di spigoli successivi nel giro dell’ingresso punta verso −x. Invertire tutto il giro cambia il calcolo a mano della sua normale, ma non giustifica la previsione di un fallimento di blockMesh. Incrociare le diagonali, omettere una faccia o usare etichette sbagliate è un problema diverso.

Documentazione: [R1], §5.4.7, in particolare la convenzione sul verso; orientazione delle facce generate: [R2].

10. Il blockMeshDict completo

Salva l’intero listato come system/blockMeshDict. Non ha sezioni omesse né numeri di riga. Il controlDict minimo è nella sezione successiva.

FoamFile
{
    format      ascii;
    class       dictionary;
    object      blockMeshDict;
}

units [mm];

vertices
(
    (  0   0  0)   // 0
    (100   0  0)   // 1
    (100  10  0)   // 2
    (  0  10  0)   // 3
    (  0   0  5)   // 4
    (100   0  5)   // 5
    (100  10  5)   // 6
    (  0  10  5)   // 7
);

blocks
(
    hex (0 1 2 3 4 5 6 7) (40 10 5)
    simpleGrading (1 1 1)
);

boundary
(
    inlet
    {
        type patch;
        faces ((0 4 7 3));
    }

    outlet
    {
        type patch;
        faces ((1 2 6 5));
    }

    walls
    {
        type wall;
        faces
        (
            (0 1 5 4)
            (3 7 6 2)
            (0 3 2 1)
            (4 5 6 7)
        );
    }
);

Documentazione: [R1], sintassi standard v14. Questo dizionario di riferimento completo è un esempio didattico originale.

11. Fornire un contesto di esecuzione minimo

Le utility di OpenFOAM inizializzano un oggetto di run-time. Fornisci system/controlDict anche se non stai risolvendo un flusso. I valori seguenti sono un’impalcatura solo per la mesh, non la scelta del passo temporale per la futura simulazione CFD.

FoamFile
{
    format      ascii;
    class       dictionary;
    object      controlDict;
}

application       blockMesh;
startFrom         startTime;
startTime         0;
stopAt            endTime;
endTime           1;
deltaT            1;
writeControl      timeStep;
writeInterval     1;
writeFormat       ascii;
writePrecision    10;
writeCompression  off;
timeFormat        general;
timePrecision     6;
runTimeModifiable yes;

Che cosa viene selezionato?

Il comando di shell seleziona il programma che esegui. La voce application blockMesh; documenta lo scopo di questa impalcatura; non fa sì che checkMesh esegua blockMesh. I controlli dettagliati di tempo e output appartengono alla Parte 4.

Che cosa manca ancora?

Il flusso di lavoro autonomo blockMesh più checkMesh di base non richiede fvSchemes, fvSolution, proprietà fisiche, U o p. Quei file verranno aggiunti quando l’applicazione che li usa ne avrà bisogno.

Non eseguire ancora foamRun
Una mesh valida non è un caso di flusso completo. L’obiettivo in questa fase è generare e ispezionare la polyMesh, poi portare i suoi nomi di patch nella parte successiva.

Documentazione: [R5]; costruzione del run-time delle utility e letture solo-mesh: [R8]–[R9].

12. Generare, poi ispezionare il log reale

Preparare una nuova cartella di lavoro

Usa la tua home, non l’albero dei tutorial installati. Esegui ogni passo separatamente e fermati al primo errore. Se il caso con quel nome esiste già, ispezionalo prima di modificarlo oppure scegli un nome nuovo.

foamVersion
command -v blockMesh checkMesh foamDictionary
mkdir -p ~/cases/dictionary-training
cd ~/cases/dictionary-training
mkdir trainingChannel
cd trainingChannel
mkdir 0 constant system
vi system/blockMeshDict
vi system/controlDict

La versione deve indicare la release 14 della Foundation. Inserisci i listati completi delle sezioni 10 e 11. In vi si salva e si esce con :wq. In questa fase basta una cartella 0/ vuota.

Esegui un comando alla volta dalla radice del caso

set -o pipefail
blockMesh 2>&1 | tee log.blockMesh
checkMesh -constant 2>&1 | tee log.checkMesh

Esegui checkMesh solo dopo che la generazione della mesh è riuscita. Leggi il rapporto vero per conteggi, dimensioni e riepilogo finale dei controlli. Per la mesh rettangolare uniforme di riferimento l’obiettivo è Mesh OK. più i valori della sezione 13.

Un exit status zero non basta
Nel sorgente di checkMesh v14, un rapporto con controlli falliti può comunque essere seguito dal codice di ritorno 0. Leggi il risultato testuale. pipefail in Bash aiuta a rilevare i fallimenti della pipeline, ma non può trasformare in uno stato non nullo un fallimento di qualità della mesh segnalato nel rapporto.

Controlli extra facoltativi: checkMesh -constant -allTopology -allGeometry. Non aggiungere -meshQuality senza il system/meshQualityDict che richiede.

Documentazione: [R8]–[R9]. I comandi sono stati controllati sui sorgenti v14; eseguili sulla tua installazione.

13. Confrontare con le previsioni indipendenti

Questa sezione contiene i conteggi topologici esatti e i valori geometrici del caso di riferimento a un blocco. Confrontali con l’output generato sul tuo server.

Grandezza	Valore atteso	Come si ottiene
Bounding box in SI	(0 0 0) – (0.1 0.01 0.005) m	Converti i millimetri in metri una volta sola.
Celle	2.000	40 × 10 × 5
Punti	2.706	41 × 11 × 6
Facce interne	5.350	39×10×5 + 40×9×5 + 40×10×4
Facce di contorno	1.300	2(10×5 + 40×5 + 40×10)
Facce totali	6.650	Interne + di contorno
Volume totale	5 × 10⁻⁶ m³	0,1 × 0,01 × 0,005
Volume di una cella uniforme	2,5 × 10⁻⁹ m³	Volume totale / 2.000

Rendere conto di ogni faccia di contorno

Patch	Facce generate	Suddivisione della faccia del blocco
inlet	50	10 × 5
outlet	50	10 × 5
walls	1.200	2(40 × 5) + 2(40 × 10)

Il riferimento deve risultare tridimensionale, con volumi di cella positivi e nessuna patch inattesa non vuota. Le sue celle allineate agli assi hanno ortogonalità ideale, a meno degli arrotondamenti. Non confrontare un caso modificato o con grading con la riga del volume di cella uniforme.

Interpretare correttamente «Mesh OK»
Dice che i controlli eseguiti non sono falliti. Non stabilisce condizioni al contorno fisiche, una risoluzione adeguata vicino alle pareti, risultati indipendenti dalla mesh o accordo con gli esperimenti.

Documentazione: i conteggi derivano dalla griglia prodotto cartesiana. Controlli riportati e loro interpretazione: [R9].

14. Leggere che cosa ha generato blockMesh

ls constant/polyMesh
less constant/polyMesh/boundary

File	Informazione memorizzata	Domanda a cui risponde
points	Coordinate dei punti generati	Dove sono i vertici della mesh?
faces	Liste di etichette dei punti generati	Quali vertici circondano ogni faccia?
owner	Una cella proprietaria per ogni faccia	Quale cella possiede questa faccia?
neighbour	Una seconda cella per ogni faccia interna	Che cosa c’è dall’altra parte di una faccia interna?
boundary	Tipi delle patch e intervalli di facce	Quali facce esterne formano ciascuna patch?

Nel file boundary generato, nFaces è il numero di facce di cella assegnate a una patch e startFace è il suo indice di partenza nell’elenco delle facce della mesh. Le facce interne precedono quelle di contorno. Intervallo di facce atteso con l’ordine delle patch di riferimento (possono comparire anche altri metadati):

inlet
{
    type        patch;
    nFaces      50;
    startFace   5350;
}

Due spazi di etichette diversi
Le etichette 0-7 del tuo dizionario nominano i vertici di controllo del blocco. Il file points generato contiene 2.706 punti con la numerazione della mesh. Non interpretare le prime otto etichette dei punti generati come se fossero le otto etichette degli angoli del blocco.

Modifica il dizionario di costruzione e rigenera la mesh didattica invece di cambiare a mano i file di connettività. Per impostazione predefinita blockMesh può sostituire la polyMesh esistente: conserva un caso separato prima di provare varianti su una simulazione completata.

Documentazione: [R2]; comportamento di sostituzione: [R8]. Il conteggio e l’indice di partenza mostrati seguono la topologia di riferimento.

15. Ispezionare la geometria, non una soluzione di flusso

Usa il lettore di ParaView e la connessione client/server stabiliti nei primi casi pratici. Il caso deve essere accessibile al processo che lo legge: il server in una sessione client/server, o la macchina locale in una sessione locale.

Crea solo il marcatore richiesto da quel lettore

# Lettore nativo OpenFOAM: non viene avviata nessuna interfaccia grafica
paraFoam -touch
# Alternativa: solo per il lettore integrato di ParaView
paraFoam -builtin -touch

Il percorso nativo crea trainingChannel.OpenFOAM; quello integrato crea trainingChannel.foam. Scegli il percorso che corrisponde al lettore che hai configurato, invece di provare ad aprirli entrambi. Il marcatore è un punto d’ingresso, non una copia convertita della mesh.

Una breve ispezione visiva

Azione	Che cosa controllare
Apri il marcatore e applica il lettore	Il caso si carica anche se non sono stati creati campi di flusso.
Seleziona la mesh di volume / le parti della mesh	Conferma che c’è un unico condotto connesso, non solo patch di estremità isolate.
Mostra gli spigoli o il wireframe	Distingui le singole celle dagli spigoli esterni del blocco.
Controlla bounding box e orientazione	Verifica x, y e z con la sezione 13; ruotare la telecamera non è un controllo delle unità.
Seleziona separatamente inlet, outlet e walls	Conferma il raggruppamento delle due facce di estremità e delle quattro facce lunghe.
Ispeziona una sezione a metà profondità	Confronta il riferimento uniforme con la variante con grading.

Per il caso con grading, una sezione x-y a z = 0,0025 m mostra la distribuzione delle celle in y. Usa la modalità di visualizzazione che mostra gli spigoli delle celle. Se dopo una nuova generazione la vista sembra invariata, ricarica i dati con il meccanismo di aggiornamento del tuo lettore.

Che cosa non vedrai ancora
Dalla sola mesh non si possono dedurre velocità, pressione, linee di flusso o direzione del flusso. I nomi inlet e outlet esprimono la tua intenzione per la configurazione futura; il generatore di mesh non ha risolto quelle condizioni.

Documentazione: [R7]; opzioni esatte dei marcatori ed estensioni dei file: [R10].

16. Cambia una cosa, poi spiegala

Mantieni intatto il riferimento uniforme. Crea un caso nuovo con solo i due dizionari sorgente: così eviti di mescolare mesh o risultati precedenti nell’esperimento. Parti dalla cartella del caso di riferimento.

mkdir ../trainingChannel_xFine
mkdir ../trainingChannel_xFine/{0,constant,system}
cp system/blockMeshDict system/controlDict ../trainingChannel_xFine/system/
cd ../trainingChannel_xFine

Esperimento A / infittire solo x

Cambia (40 10 5) in (80 10 5). Prima di eseguire, annota il numero di celle, la larghezza delle celle in x e il numero di facce dell’ingresso. Genera e controlla la nuova mesh. Spiega perché una risoluzione più fine in x non cambia il numero di facce dell’ingresso.

Esperimento B / infittire verso la parete inferiore

Fai un’altra copia pulita del riferimento uniforme. Mantieni (40 10 5) e sostituisci il grading con (1 4 1). Prevedi quale lato diventa fine e quale grossolano. Ispeziona una sezione. Conferma che punti, facce, celle e bounding box mantengono i conteggi o le dimensioni del riferimento.

Esperimento C / cambiare la geometria, non la risoluzione

In una terza copia nuova, cambia tutte e quattro le coordinate x = 100 in x = 200, mantenendo i conteggi e il grading uniforme. Prevedi il volume e la larghezza delle celle in x. Spiega perché modificare solo due vertici dell’uscita cambierebbe la forma invece di raddoppiarne semplicemente la lunghezza.

Le tre domande dopo ogni modifica
Che cosa è cambiato nel dizionario? Che cosa avevo previsto? Che cosa ha mostrato davvero la mesh generata? Basta una risposta breve a queste tre domande; non serve un rapporto di validazione formale.

Usa nomi di cartella nuovi per ogni variante. Non riusare un comando che copia dentro un caso già completato senza prima controllare la destinazione. Riusa i comandi di generazione e controllo della sezione 12. I valori attesi sono calcolati nella sezione 20.

Documentazione: i comandi agiscono sulle tue copie didattiche. Effetti del dizionario: [R1].

17. Esercizi di lettura: spiegare il file

A / leggere senza eseguire

1. Nel file di riferimento, quale voce controlla l’altezza fisica? Quale voce controlla il numero di celle lungo quell’altezza? Perché non sono la stessa impostazione?
2. Quante facce del blocco vengono messe in walls? Quante facce di cella generate contiene quella patch? Spiega la differenza.
3. Che cosa cambia quando sostituisci simpleGrading (1 4 1) con simpleGrading (1 0.25 1)? Che cosa non cambia?
4. Che cosa c’è di sbagliato nel cambiare type patch; in type fixedValue; nella patch inlet della mesh? Dove va invece una velocità prescritta?
5. Il giro valido (3 7 4 0) descrive la stessa faccia del blocco di (0 4 7 3)? L’inversione da sola è un errore per una faccia di contorno di blockMesh v14?

B / classificare la modifica

Modifica proposta	La tua classificazione
Cambiare tutte le coordinate x = 100 in x = 80.	Geometria / topologia / distribuzione / identità?
Sostituire (40 10 5) con (80 10 5).	Geometria / topologia / distribuzione / identità?
Sostituire il grading in y da 1 a 4.	Geometria / topologia / distribuzione / identità?
Rinominare inlet in feed senza cambiare le facce.	Geometria / topologia / distribuzione / identità?

Cerca la conseguenza, non una parola d’ordine
Alcune modifiche toccano più di un livello. Aumentare un numero di celle cambia la topologia della mesh generata oltre alla sua risoluzione spaziale. La risposta utile dice che cosa si conserva e che cosa va rigenerato.

C / trovare un fatto nella guida ufficiale

Trova la sottosezione v14 che definisce il rapporto di espansione e quella che stabilisce la regola sul verso delle facce di contorno. Annota i numeri delle sottosezioni e spiega ogni regola con parole tue. Usa la sezione 21 per orientarti, poi confronta con la sezione 20.

18. Compito autonomo: un secondo canale

Crea trainingChannel_independent in una cartella nuova. Parti dalla specifica geometrica qui sotto, non sostituendo numeri alla cieca nel riferimento completato. Disegna gli otto angoli etichettati prima di scrivere.

Requisito	Specifica
Dimensioni fisiche	L = 80 mm; H = 8 mm; W = 4 mm
Numero di celle	40 in x; 16 in y; 8 in z
Distribuzione delle celle	Uniforme in x e z; in y rapporto larghezza finale/iniziale = 4
Patch di contorno	inlet a x = 0; outlet a x = L; tutte le altre facce in walls
Dimensionalità	Tridimensionale; nessuna patch empty
File da costruire	system/blockMeshDict e il controlDict solo-mesh

Prima di generare la mesh

Prevedi il bounding box in metri, le celle totali, i punti totali, le facce dell’ingresso e il volume totale. Individua la parete y più fine. Usa la formula della sezione 6 per stimare la larghezza minima e massima delle celle in y.

Poi metti alla prova la tua costruzione

Esegui blockMesh, leggi il suo output, poi esegui checkMesh. Confronta con le previsioni e ispeziona una sezione. Spiega il file dall’inizio alla fine senza appoggiarti ai suoi commenti.

Criterio di completamento
Viene generato il condotto voluto; i controlli della mesh non riportano fallimenti; conteggi e dimensioni coincidono con le previsioni; ogni faccia esterna appartiene alla patch voluta; e sai spiegare tutte e cinque le sezioni principali del dizionario.

Un’estensione facoltativa

Dividi walls in lowerWall per y = 0 e otherWalls per le altre tre facce lunghe. Non duplicare né omettere facce. Prevedi quali conteggi della mesh restano invariati e quali conteggi delle patch cambiano.

L’esercizio volutamente non chiede un campo di velocità, un modello di turbolenza o prove di indipendenza dalla mesh: sono obiettivi di apprendimento separati. I valori di controllo sono nella sezione 20.

19. Diagnosticare una causa alla volta

Leggi il primo errore rilevante nel suo contesto: applicazione, file, voce e tipo atteso. Correggi una causa e rilancia la stessa utility. Le descrizioni qui sotto sono categorie diagnostiche, non messaggi di console inventati parola per parola.

Sintomo	Prima cosa da controllare
Il dizionario non si trova	Esegui dalla radice del caso; verifica system/blockMeshDict e le maiuscole esatte del nome.
controlDict non leggibile	Crea il contesto solo-mesh della sezione 11; non aggiungere file del solutore a caso.
Token inatteso o fine del file	Controlla graffe e parentesi appaiate e il punto e virgola dopo ogni voce di lista.
Etichetta di punto fuori intervallo	In questa lista vertices esistono solo le etichette 0-7; controlla ogni faccia e la voce hex.
Blocco capovolto, torto o non valido	Confronta le coordinate dei vertici e la connettività hex con la sezione 4.
Una patch defaultFaces inattesa	Trova una faccia esterna mancante in boundary. Controlla il suo tipo e il numero di facce.
Dimensioni sbagliate ma conteggi giusti	Controlla units e scale; i conteggi non rivelano un errore di conversione delle lunghezze.
Viene infittita la parete sbagliata	Leggi il grading nella direzione locale; E è larghezza ultima / larghezza prima.
La mesh visualizzata non è cambiata	Controlla il percorso del caso, rilancia blockMesh e ricarica i dati giusti nel lettore.

Una faccia mancante può essere più pericolosa di un errore di sintassi
Le facce omesse possono essere raccolte in una patch predefinita. Una mesh generata non è quindi la prova che il contorno corrisponda alla tua intenzione. Questo riferimento elenca esplicitamente tutte e sei le facce esterne del blocco.

Esercizio con errori voluti

Solo in una copia didattica nuova, sostituisci l’etichetta di vertice 7 con 8 in una faccia di patch. Esegui blockMesh, individua la patch e l’etichetta che falliscono, poi correggi. Come esercizio separato, ometti una faccia esterna e osserva l’avviso e il comportamento della patch predefinita. Ripristina poi il contorno completo.

Documentazione: [R1], §5.4.7; implementazione e diagnostica: [R8]–[R9].

20. Note con le risposte e controlli numerici

I tre esperimenti guidati

Caso	Cambiamenti attesi principali
A: infittimento in x	4.000 celle; Δx = 1,25 mm; ingresso sempre con 50 facce; bounding box invariato.
B: grading in y = 4	2.000 celle e topologia invariata; più fine vicino a y = 0; Δy da circa 0,4542 a 1,8170 mm.
C: L raddoppiata	2.000 celle; Δx = 5 mm; volume = 1 × 10⁻⁵ m³; x massima = 0,2 m.

Risposte agli esercizi di lettura

1. Le coordinate y fissano H; il secondo valore del numero di celle fissa N_y.
2. Quattro facce del blocco diventano 1.200 facce di cella.
3. Il grading si inverte mentre conteggi, dominio e assegnazione delle patch restano fissi.
4. fixedValue è una condizione di campo, non il tipo generico di patch della mesh che si intende; la condizione di velocità va in 0/U.
5. Entrambi i giri identificano la faccia di ingresso; l’inversione da sola è ammessa nella lista boundary di blockMesh.

Cambiare la lunghezza cambia la geometria. Aumentare N_x cambia la risoluzione e la topologia generata. Cambiare il grading cambia la posizione dei punti conservando la connettività di questa mesh. Rinominare una patch ne cambia l’identità; i file di campo successivi dovranno usare il nuovo nome. Le sezioni della guida richieste sono la 5.4.5 e la 5.4.7.

Canale autonomo (sezione 18)

Controllo	Risultato atteso
Bounding box in SI	(0 0 0) – (0.08 0.008 0.004) m
Celle / punti	5.120 / 6.273
Facce interne / di contorno / totali	14.272 / 2.176 / 16.448
Facce per patch	inlet: 128; outlet: 128; walls: 1.920
Volume / larghezza delle celle in x	2,56 × 10⁻⁶ m³ / 2 mm
Larghezze in y, dall’inizio alla fine	da 0,2287 a 0,9147 mm; più fine vicino a y = 0
Divisione facoltativa delle patch	lowerWall: 320; otherWalls: 1.600; nessun cambiamento dei conteggi totali

Sono i valori di controllo del canale autonomo. Gli arrotondamenti possono toccare le ultime cifre dei valori geometrici; i conteggi topologici esatti devono coincidere.

21. Usare la guida come strumento di lavoro

Parti dal requisito, individua la voce pertinente, leggi la sottosezione v14 e confronta un tutorial con lo stesso schema. Non sostituire l’intero dizionario quando solo una funzione ti è sconosciuta.

La tua domanda	OpenFOAM v14 User Guide
Dove sono memorizzati i dati della mesh?	§5.2 – Mesh files [R2]
Quali unità si applicano alle coordinate?	§5.4.2 – Units and scaling [R1]
Come si ordinano vertici e blocchi?	§§5.4.3 e 5.4.5 [R1]
Che cosa significa il grading?	§§5.4.5–5.4.6 [R1]
Come si assegnano le facce di contorno?	§5.4.7, più §5.3 per i tipi di patch [R1, R3]
Come ispeziono le voci di un dizionario?	§4.7.2 – foamDictionary [R6]

Ispezionare il caso strutturalmente

foamDictionary system/blockMeshDict -entry units -value
foamDictionary system/blockMeshDict -entry vertices -value
foamDictionary system/blockMeshDict -entry blocks -value
foamDictionary system/blockMeshDict -entry boundary -value

foamDictionary conferma che cosa contiene una voce. Non sostituisce la costruzione topologica di blockMesh né i controlli geometrici di checkMesh.

Trovare esempi nell’albero dei tutorial installati

find "$FOAM_TUTORIALS" -type f -name blockMeshDict
blockMesh -help
checkMesh -help

Apri un file pertinente con less e individua solo lo schema che ti serve. Alcune mesh dei tutorial usano file di risorse condivisi invece di un blockMeshDict locale: controlla il loro script di esecuzione o l’argomento -dict dell’utility. Non modificare gli esempi installati.

Documentazione: [R1], §5.4.12; interrogazione dei dizionari: [R6]; opzioni disponibili delle utility: [R8]–[R9].

Riferimenti e passo successivo

Per questa serie usa i riferimenti della Foundation v14. I link qui sotto puntano alle pagine o ai file sorgente consultati per preparare questa parte; altre distribuzioni di OpenFOAM possono avere opzioni diverse.

• [R1] User Guide §5.4 – blockMesh
• [R2] User Guide §5.2 – Mesh files
• [R3] User Guide §5.3 – Mesh boundary
• [R4] User Guide §4.2 – Input/output file format
• [R5] User Guide §4.4 – Time and data input/output control
• [R6] User Guide §4.7 – Case management tools
• [R7] User Guide §7.1 – ParaView / paraFoam
• [R8] Foundation v14 source – blockMesh.C
• [R9] Foundation v14 source – checkMesh.C
• [R10] Foundation v14 source – bin/paraFoam

Pronti per la Parte 3
Conserva il riferimento uniforme come trainingChannel con inlet, outlet e walls. La Parte 3 introdurrà i file di campo e le condizioni iniziali e al contorno. Adesso hai una mesh a cui quei campi possono fare riferimento.

Diagrammi, esempi numerici e spiegazioni didattiche originali. Parte precedente: OpenFOAM 14 – anatomia di un caso e linguaggio dei dizionari. Non è una pubblicazione ufficiale di OpenFOAM. Tutte le parti sono nel progetto Imparare OpenFOAM 14.