ANSYS FLUENT ist ein Finite-Volumen-Programm zur Berechnung von Strömungsproblemen aller Art. Einige der Programmfeatures sind: 

• stationär, instationär
• inkompressibel, kompressibel
• laminar, turbulent
• Mehrphasenströmung (Fluid-Fluid, Fluid-Solid)
• newtonsche und nicht-newtonsche Fluide
• freie Oberflächen
• gekoppelte Wärmeleitung und -konvektion
• bewegte Gitter
• chem. Reaktionen, Verbrennungen
• u.v.m.

FLUENT bietet eine Oberfläche, über die alle notwenigen Informationen für

• Randbedinungen
• Solvern
• Lösungskontrolle

eingegeben werden können. Gleichzeitig kann auch die Ergebnisdarstellung und Visualisierung durchgeführt werden.

FLUENT ist zusammen mit anderen ANSYS-Produkten wie ANSYS CFX, ANSYS Mechanical in der ANSYS Workbench integriert, die eine komplette Entwicklungsumgebung für CFD- oder Strukturmodelle darstellt. Die Funktionalitäten der Präprozessoren älterer Versionen, wie GAMBIT, TGrid u.a. sind in den Workbench-Modulen DesignModeler und ANSYS-Meshing übernommen worden. Anspruchsvolleres Postprozessing von ANSYS Berechnungsergebnissen kann mit CFD-Post, dem gemeinsamen Postprozessor für ANSYS CFX und ANSYS FLUENT durchgeführt werden.

Aktuelle lizenzierte Softwareversion

ANSYS 2026R1

ANSYS 2025R2

Installation

Die Installationsdateien und die Installationsanleitung für die neueste Version der Software sowie Informationen zur Netzwerklizenzierung sind auf unserem FTP-Server verfügbar. ANSYS FLUENT ist außerdem auf unseren Linux-Clustern BwUniCluster3.0 und Horeka installiert und steht dort zur Durchführung rechenintensiver Simulationen zur Verfügung.

Hinweis: Installationsdateien für Versionen, die oben nicht aufgeführt sind, können auf Anfrage unter scs-contact∂scc kit edu angefordert werden.

Lizenzierung

Netzwerklizenz: Es gibt zwei separate ANSYS-Netzwerklizenzserver, die derzeit beide aktiv sind. Die Konfigurationsdetails für beide Server finden Sie in der Netzwerklizenz-Konfigurationsdatei, die auf dem FTP-Server verfügbar ist. Geben Sie während der Installation bitte den entsprechenden Lizenzservernamen und die Portnummer an, wie in der Konfigurationsdatei angegeben, je nach der von Ihnen beabsichtigten Nutzung der Software. Die beiden Lizenzserver dienen unterschiedlichen Zwecken und müssen entsprechend verwendet werden:

• ANSYS Academic Research: Vorgesehen für nicht-kommerzielle akademische Forschungsaktivitäten am KIT, einschließlich Promotionsvorhaben, Master- und Bachelorarbeiten sowie sonstiger wissenschaftlicher Projekte.
• ANSYS Academic Teaching: Ausschließlich für Lehrveranstaltungen vorgesehen, wie Vorlesungen, Kurse und Übungen.

Bitte stellen Sie sicher, dass Sie den für Ihren Verwendungszweck geeigneten License Server auswählen. Die Nutzung einer der beiden Lizenzen für persönliche oder kommerzielle Zwecke ist strengstens untersagt. Für die Nutzung der Software ist eine aktive Internetverbindung erforderlich. Wenn Sie außerhalb des KIT-Netzwerks auf die Software zugreifen, stellen Sie bitte zunächst eine VPN-Verbindung her, um den License Server zu erreichen. Anweisungen zur Einrichtung und Nutzung des VPN finden Sie unter: Remote Access (VPN)

Inhaltsverzeichnis

Einleitung
FLUENT System
FLUENT Dateien
FLUENT-Aufruf
FLUENT-Aufruf auf den Linux-Clustern des SCC
Erstellen einer FLUENT Kommandodatei
User Defined Functions (UDF) in FLUENT
 

Einleitung

FLUENT ist ein Finite Volumen Programm zur Berechnung von Strömungsproblemen. Die Probleme, die behandelt werden können, lassen sich folgendermaßen umschreiben:

• isotherm: die Energiegleichung wird nicht gelöst
• nichtisotherm: die Energiegleichung wird gelöst
• kompressible und nichtkompressible Fluide
• laminare und turbulente Strömungen
• stationäre und instationäre Strömungen
• newtonsche und nichtnewtonsche Fluide
• Mehrphasenströmungen (Fluid-Fluid, Fluid-Solid)
• gekoppelte Wärmeleitung und -konvektion
• bewegte Gitter
• freie Oberflächen
• chemische Reaktionen, Verbrennungsprozesse

Für eine intensivere Beschreibung wird auf die FLUENT Dokumentation verwiesen.
 

FLUENT System

FLUENT kann als Standalone-Anwendung genutzt werden, aber auch als integrales Modul innerhalb der ANSYS Workbench. In dieser Kurzanleitung konzentrieren wir uns auf den ersten Aspekt. Die folgende Grafik skizziert den Workflow eines FLUENT-Projektes:

HyperMesh ist ein Modellierer und Vernetzer, der die wichtigsten Solver-Formate erzeugen bzw. importieren kann. Außerdem kann bis auf weiteres auch noch GAMBIT und TGrid benutzt werden, um FLUENT-Netze zu erzeugen. Informationen dazu fiden Sie hier. Es gibt noch weitere "Third Party"Systeme, wir beschränken uns hier aber auf die Verhältnisse am SCC.
 

FLUENT Dateien

FLUENT arbeitet mit folgenden Dateien:

FLUENT-Aufruf

Die Liste der Optionen beim FLUENT-Aufruf ist sehr lang, die meisten davon sind für uns nicht interessant oder gültig. Hier also nur diejenigen, die für und von Bedeutung sind:

mit der Bedeutung

Wenn die weder die -g noch die -gu Option gesetzt ist, öffnet sich der FLUENT Launcher, in dem wichtige Voreinstellungen vorgenommen werden können:

Klickt man auf "Start With Selected Options", erscheint die eigentliche FLUENT Grafikoberfläche.

FLUENT-Aufruf auf den Linux-Clustern des SCC

Auf dem Linux Cluster bwUniCluster wird ein Modulkonzept eingesetzt. Um ANSYS zu verwenden, müssen Sie zuerst das entsprechende Modul laden. Sie erhalten alle vorhandenen Software-Module, indem Sie

module avail
 
eintippen. Um das Modul der aktuellen Version von ANSYS zu laden, geben Sie auf dem bwUniCluster Folgendes ein:
 
module load cae/ansys
 
Sie können das Modul auch mit der gewünschten Versionsnummer laden, wie z.B.
 
module load cae/ansys/2023R2


Auf den Linux-Clustern des SCC sollte die Ausführung von FLUENT unter Kontrolle eines Job Management Systems stattfinden, welches die Rechnerressourcen für den FLUENT-Job bereitstellt. Um die Verwendung von FLUENT auf diesen Clustern zu vereinfachen, wurde das Startskript ‚fluentjob‘ bereit gestellt. Der Aufruf des Solvers für den bwUniCluster lautet demnach:

fluentjob -v version -j name -t cpu-zeit -m memory [-p procs][-n nodes][-q queue]

Die Bedeutung der Parameter ist die folgende:

Hier ein Beispiel, um eine Fluent Berechnung parallel auf zwei Knoten mit jeweils 40 Prozessoren und 90.000 MB Hauptspeicherbedarf für 120 Minuten zu starten:

fluentjob -v 3d -j test -t 120 -n 2 -p 40 -m 90000
 

Der Aufruf von FLUENT kann auch per Skript durchgeführt werden. Hier nachfolgend ein Skript "run_fluent.sh", wie man eine FLUENT Berechnung parallel auf zwei Knoten mit jeweils 40 Prozessoren auf dem bwUniCluster startet:

1. mit IntelMPI:

#!/bin/sh
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=40
#SBATCH --time=2:00:00
#SBATCH --mem=90gb
#SBATCH --partition=multiple
module load cae/ansys/2023R2
source fluentinit
scontrol show hostname ${SLURM_JOB_NODELIST} > fluent.hosts
time fluent 3d -mpi=intel -pib -g -t80 -cnf=fluent.hosts -i test.inp

2. mit OpenMPI:

#!/bin/sh
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=40
#SBATCH --time=2:00:00
#SBATCH --mem=90gb
#SBATCH --partition=multiple
module load cae/ansys/2023R2
source fluentinit
scontrol show hostname ${SLURM_JOB_NODELIST} > fluent.hosts
time fluent 3d -mpi=openmpi -g -t80 -cnf=fluent.hosts -i test.inp

Um das Skript an das Job Management Systems zu submittieren, führen Sie Folgendes aus
 

sbatch run_fluent.sh

Weitere Informationen zum Batchsystem der jeweiligen Clustern erhalten Sie unter diesen Links:

bwUniCluster
 

Erstellen einer FLUENT Kommandodatei

Das FLUENT-Fenster gestattet es, die FLUENT-Eingabe über mausgesteuerte Menüs durchzuführen, man kann aber auch, obwohl mühsamer, die Eingabe über die Tastatur im Kommando-Modus machen. Die Eingabe über Kommandos muß im Falle eines Batch-Laufes in einer Datei zur Verfügung gestellt werden. Dazu kann das Journal-File beitragen, das aber ebenfalls als Protokolldatei aus einer Sitzung im Kommando-Modus hervorgegangen sein muß, da sonst Informationen über die Benutzeroberfläche enthalten sind.

Die einfachste Vorgehensweise, die dann zu einer Standard-Kommandodatei führt, ist die folgende:

1. Man bereitet das Modell komplett, bis auf die Initialisierung über die Menüs Solver -> Initialize... --> Initialize und Solver --> Iterate... --> Iterate vor.
    
2. Das Einlesen der .cas Datei, die Initialisierung, den Start des Solvers und das Herausschreiben der Ergebnisse werden dann durch die Kommandodatei veranlaßt, die im fluentjob eingelesen wird.

3. Das Postprocessing wird dann wieder interaktiv durchgeführt.

Beispiel:

Das FLUENT-Modell heiße cavity.cas. Die folgenden Kommandos stehen in der Datei cavity.inp

Ein entsprechender Aufruf wäre dann z.B.

fluentjob -v 2d -j cavity.inp -n 1 -p 10 -t 10 -m 40000

Informationen über die FLUENT-Kommandos findet man im FLUENT Users Guide.
 

User Defined Functions (UDF) in FLUENT

In FLUENT besteht die Möglichkeit, während der Lösungsphase auf den Solver zuzugreifen. Dies geschieht über vom User zu erstellende C-Programme, die über Standardschnittstellen, den DEFINE Macros, unter Benutzung spezieller Datentypen direkt auf den Lösungsprozess Einfluss nehmen. UDFs stehen zur Verfügung für

• Randbedingungen: Profile für Geschwindigkeiten, Temperatur, Turbulenz, Spezies
• Quellen: Massen, Impuls, Energie, Turbulenz, Spezies
• Materialeigenschaften: Viskosität, Leitfähigkeit, Dichte etc.
• Anfangsbedingungen
• globale Funktionen
• skalare Funktionen
• modellspezifische Funktionen: Reaktionsraten, turbulente Viskosität, diskrete Phasenmodelle

Eine genaue Beschreibung und Beispiele findet man im UDF Manual.

UDFs können auf 2 Arten in ein Modelleingebunden werden, als interpreted UDF oder compiled UDF.

Unter der grafischen Obefläche werden die UDFs über die Menüfolge Define --> User-Defined --> Functions --> Compiled oder Interpreted eingebunden. In das Modell "eingeklinkt" werden sie, je nach Typ über das Define Menü und dann Boundary Conditions ..., Cell Zone Conditions ..., Materials ... usw. Es gibt auch ein spezielles Menü Define --> User-Defined --> Function Hooks ...,  über das Funktionen und Anfangsbedingungen eingebunden werden. Auch hier findet man eine genaue Beschreibung im UDF Manual.

Anschließend kann das FLUENT-Modell weiter vorbereitet und das .cas File gespeichert werden. Wenn dieses .cas File in folgenden FLUENT-Sitzungen geöffnet wird, sind die UDFs ohne weitere Aktionen einsatzbereit. Hat man bei der Vorbereitung ein Journal-File mitprotokollieren lassen, kann dieses wieder als Grundlage für ein Batch-Inputfile dienen, um den FLUENT-Job auf den Linux-Clustern des SCC unter fluentjob zu starten.

Die oben beschriebene Prozedur kann auch im Kommandozeilen-Format durchgeführt werden (s. Beispiel unten), so dass eine Eingabedatei für fluentjob erzeugt werden kann, um das Ganze im Batch auf den SCC-Clustern auszuführen.

Im Falle von Compiled UDFs kann die Übersetzung und das Laden auch außerhalb von FLUENT erfolgen. Das hat den Vorteil, dass speziell bei der Entwicklung und beim Testen des UDFs, alles auf Betriebssystemebene stattfindet, also schneller ist. Wenn die UDF fehlerfrei und in FLUENT eingebunden ist, benötigt man in der Batch-Eingabedatei keine UDF-spezifische Eingaben. Somit ist diese Variante die flexibelste.

Beispiel

Im folgenden Beispiel soll das oben Gesagte demonstriert werden. Es wird im UDF-Manual unter den Beispielen in Kap. 8.2.4 genau beschrieben. Es handelt sich um ein gebogenes Rohr, dessein eine Hälfte entlang der Achse aus einem porösen Material besteht, in dem ein Gas, welches aus einer Spezies a besteht und von links einströmt in ein Gas der Spezies b gemäß eine Reaktionsrate umgewandelt wird. Diese Reaktionsrate muss als UDF formuliert werden und soll als Compiled UDF in das Modell eingebunden weden. Das Modell ist 2-dimensional.

Das Modell liegt schon in der Datei rate.cas vor. Die UDF rate.c sieht folgendermaßen aus

/******************************************************************/
/* */
/* Custom Reaction Rate */
/* RALF 5.0 */
/* */
/* Authors: Heather Andrews and Eric Bish */
/* Date: February 1998 */
/* */
/******************************************************************/

#include "udf.h"

#define K1 2.0e-2
#define K2 5.

DEFINE_VR_RATE(user_rate, cell, thread, r, mole_weight, species_mf, rate, rr_t)
{
float s1 = species_mf[0];
float mw1 = mole_weight[0];

if (FLUID_THREAD_P(thread) && THREAD_VAR(thread).fluid.porous)
*rate = K1*s1/pow((1.+K2*s1),2.0)/mw1;
else
*rate = 0.;
}

Interaktiv über grafische Oberfläche

Nach Aufruf von FLUENT und Einlesen von rate.cas startet man Define --> User-Defined --> Compiled ...

Über den Add... Button wählt man rate.c aus und als Name für die Shared Library, die erzeugt werden soll, ist standardmäßig libudf eingetragen. Mit Build startet man den Compile/Load Vorgang und mit Load wird die soeben erzeugt shared Library libudf in das Modell geladen. Die weitere Vorgehensweise findet man im UDF Manual Kap. 6.2.33 Hooking DEFINE_VR_RATE UDFs. Über Models --> Species --> Edit sollte schon vorher folgende Einstellung vorgenommen worden und in rate.cas abgespeichert sein:

und über Define --> User-Defined --> Function Hooks ... wählt man die UDF user_rate aus, so wie der Name in rate.c festgelegt wurde.

Man beachte, dass die shared Library, in der user_rate enthalten ist, mit angezeigt wird. Es bleibt noch, im Solver Menü den Solver zu initialisieren und zu starten. Ein Ergebnis, den Anteil der Spezies a, sieht man im folgenden Konturplot:

Über Kommandozeilen

Die Leerzeilen entsprechen der Betätigung der Return-Taste. Falls der Job weitergerechnet werden soll, z.B. weitere Iterationen, oder mit anderen Anfangsbedingungen, reicht als Eingabedatei

file/rc rate.cas
solve/init
s-d
x 0.1
q
if
q
solve/iterate 50
q
file/wcd rate.cas
y
exit

Compile/Load auf Linux-Ebene

Die folgende Beschreibung bezieht sich auf die SCC-Cluster. Auf dem Arbeitsverzeichnis, das ist das Verzeichnis, in dem sich das Case-File rate.cas befindet, wird die folgende Verzeichnisstruktur aufgebaut und Makefiles kopiert:

mkdir libudf
cd libudf
cp /software/all/ansys_inc13/v130/fluent/fluent13.0.0/src/makefile.udf2 Makefile
mkdir src
cd src
cp /software/all/ansys_inc13/v130/fluent/fluent13.0.0/src/makefile.udf makefile
cd ..
mkdir lnamd64
cd lnamd64

Im Unterverzeichnis lnamd64 (der Name entspricht der Linux-Architektur) werden jetzt Unterverzeichnisse angelegt, je nach Dimensionalität und Genauigkeit, also eines von

2d    2ddp    3d    3ddp

und wenn parallelisiert gerechnet werden soll, auch noch

2d_host und 2d_node

oder

3d_host und 3d_node

Anschließend wird das UDF rate.c nach src kopiert und in makefile die beiden Variablen

SOURCE=rate.c
FLUENT_INC=/software/all/ansys_inc13/v130/fluent

gesetzt. Sodann geht man in das Unterverzeichnis libudf und startet

make "FLUENT_ARCH=lnamd64"

Die UDF wird compiliert und die Library libudf erzeugt. Anschließend siehrt die Verzeichnisstruktur wie folgt aus:

 Die shared Library libudf muss nur noch geladen und die Function Hooks eingerichtet werden (s.o.)