OpenFOAM on a Linux server, working from Windows: SSH, FileZilla, PowerShell, logs and ParaView client/server

OpenFOAM Foundation is developed and distributed for Linux. Windows has indirect routes (WSL2 with Ubuntu, Docker containers, virtual machines) that are handy for studying on a laptop, but the server remains the right place for computation: more cores and more RAM, storage sized for time directories, and the ability to leave a run going for hours or days without keeping the PC switched on.

The workflow described here separates the roles clearly. Windows keeps the graphical tools and the working copy of the configuration files; the server holds the executed copy of the case, the results and the logs. Three channels connect them, all encrypted and all based on SSH:

• SFTP (the SSH port, usually 22): file transfer, used by FileZilla;
• interactive SSH (same port): a Linux terminal inside PowerShell;
• SSH tunnel (local port forwarding): carries ParaView traffic from Windows localhost:11111 to the server’s pvserver without opening ports to the network.

One service to authorize (SSH) and one secret to protect (password or key): this is the setup system administrators prefer, and the reason this guide does not use plain FTP, remote desktops or exposed ParaView ports.

On Windows 10 (from version 1809) and Windows 11 the OpenSSH client is an optional feature that is usually already present. From the interface: Settings → Apps → Optional features → Add a feature → OpenSSH Client. From PowerShell run as administrator:

# state of the OpenSSH features
Get-WindowsCapability -Online | Where-Object Name -like 'OpenSSH*'

# install the client only
Add-WindowsCapability -Online -Name OpenSSH.Client~~~~0.0.1.0

# check (new PowerShell window)
ssh -V

If Get-WindowsCapability reports State : Installed for OpenSSH.Client, there is nothing else to do. The Windows OpenSSH server is not needed: the PC only acts as a client.

With a key pair you do not type the password at every connection, and FileZilla and PowerShell use the same identity. Generate the key on the PC (the private part never leaves Windows) and copy only the public part to the server. Before doing so, check that the administrator allows key authentication.

# PowerShell: generate the key pair (Enter for the proposed path,
# then a passphrase to protect the private key)
ssh-keygen -t ed25519

# Windows has no ssh-copy-id: append the public key with a single command
type $env:USERPROFILE\.ssh\id_ed25519.pub | ssh USER@SERVER "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

# test: the connection now asks for the key passphrase, not the password
ssh USER@SERVER

In FileZilla’s Site Manager choose Logon Type: Key file and point it to C:\Users\NAME\.ssh\id_ed25519: FileZilla offers to convert it to its own .ppk format and uses it from then on. Permissions 700 on ~/.ssh and 600 on authorized_keys are mandatory: with looser permissions the SSH server ignores the key and falls back to asking for the password.

The Windows OpenSSH client reads C:\Users\NAME\.ssh\config (a text file with no extension). An alias collects host, user, port, key and even the ParaView tunnel:

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

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

From then on ssh cfd opens the terminal and ssh cfd-paraview opens the terminal with the tunnel of section 9. ServerAliveInterval 60 sends a keep-alive every minute and reduces disconnections caused by routers or firewalls that drop idle sessions.

The fingerprint identifies the server: if it matches the expected one, you are talking to the right server and not to an intermediary. The administrator obtains it on the server with:

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

The same fingerprint appears in FileZilla’s dialog and on the first ssh connection from PowerShell. Once accepted, Windows stores it in C:\Users\NAME\.ssh\known_hosts and FileZilla in its own configuration. If you later get a warning that the host key has changed, stop and ask the administrator: it may be a server reinstallation, but it may also be an interception attempt.

FileZilla has a Transfer type setting (Auto/ASCII/Binary), but line-ending conversion only applies to FTP. Over SFTP files always travel byte for byte: a file saved with Windows line endings (CRLF) reaches the server with CRLF. That is why Unix line endings (LF) must be set in the editor, as section 4 explains, rather than left to the transfer program.

The Windows OpenSSH client also includes scp, useful for repetitive transfers or scripts. From PowerShell, in C:\CFD\cases:

# upload the whole case (configuration only, a small directory)
scp -r .\myCase USER@SERVER:~/cases/

# upload a single edited dictionary
scp .\myCase\system\controlDict USER@SERVER:~/cases/myCase/system/

# download a log into the logs directory
scp USER@SERVER:~/cases/myCase/log.foamRun C:\CFD\logs\myCase\

When you need many small files (for example postProcessing/ data or all logs), pack them into one archive on the server and download a single file:

cd ~/cases/myCase
tar czf ~/myCase_logs_post.tgz log.* postProcessing/
ls -lh ~/myCase_logs_post.tgz

Windows 10/11 includes tar and extracts the archive with tar xzf myCase_logs_post.tgz from PowerShell.

Since Foundation version 11 the individual executables such as icoFoam or simpleFoam have been replaced by foamRun, which loads a solver module. The module is named by the solver entry in system/controlDict:

application     foamRun;
solver          incompressibleFluid;

That is why the guide’s excerpt must be read as a fragment: in a real case the solver entry sits next to application, and the other entries (endTime, deltaT, writeControl) have values tied to the physics of the case. Each entry is explained in Part 4: controlDict and simulation control. To read the current value without opening the file:

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

In Notepad++ View → Show Symbol → Show All Characters displays the line terminators: CR LF means Windows, LF means Unix. The status bar always shows the current format (Windows (CR LF) or Unix (LF)) and the encoding.

On the server, diagnosis and correction are immediate:

file Allrun
# Allrun: POSIX shell script, ASCII text, with CRLF line terminators   <- needs fixing
# Allrun: POSIX shell script, ASCII text                               <- correct

sed -i 's/\r$//' Allrun      # removes the CRs (equivalent to dos2unix)
head -c 3 Allrun | od -c     # 357 273 277 means the file starts with a UTF-8 BOM

The first line of a script must be exactly #!/bin/sh (or #!/bin/bash), with no space between # and ! and no BOM in front: this line tells the system which interpreter to use. Foundation tutorial scripts start with #!/bin/sh followed by cd ${0%/*} || exit 1, which moves the script into its own directory whatever directory it is launched from.

The Windows file system is case-insensitive, Linux is case-sensitive. On Windows U and u cannot coexist in the same folder; on Linux they are two different files, and OpenFOAM looks for exactly 0/U, 0/p, system/fvSchemes. If a file reaches the server as fvschemes or fvSchemes.txt, the error will read like cannot find file "system/fvSchemes". Check with ls -l system/ after every upload, and turn off the File Explorer option that hides known extensions, so an accidental .txt stays visible.

The Foundation Ubuntu packages install OpenFOAM 14 in /opt/openfoam14 (all lower case, no hyphen); a source build usually sits in $HOME/OpenFOAM/OpenFOAM-14; other servers use their own paths or the modules of the computing environment. To find the right file:

ls -d /opt/openfoam* /opt/OpenFOAM* $HOME/OpenFOAM/OpenFOAM-* 2>/dev/null
module avail 2>&1 | grep -i foam        # only if the server uses Environment Modules

If the environment is not loaded automatically, add one line at the end of ~/.bashrc (once), after testing it by hand:

echo 'source /opt/openfoam14/etc/bashrc' >> ~/.bashrc
# new SSH connection, then:
foamVersion          # must print version 14

Do not add the line if the administrator has already set up another mechanism: loading two different environments produces inconsistent PATH values and errors that are hard to read.

Two worlds share the same window. Before ssh, PowerShell commands and Windows paths apply (C:\CFD, separator \); after login, bash and Linux paths apply (/home/USER, separator /, ~ for home). Some names exist in both (ls, cd, pwd are aliases in PowerShell) but behave differently: options such as -lh only work with Linux ls.

• Pasting: in the Windows terminal paste with a right click or Ctrl+V (Windows Terminal); selecting with the mouse copies.
• Interrupting: Ctrl+C interrupts the running Linux command, not the connection.
• Reading a long file: less log.foamRun (arrows to scroll, /text to search, q to quit); head -n 50 and tail -n 50 for the beginning and the end.
• Completion: Tab completes file and command names; two Tabs list the options.
• History: up arrow recalls previous commands, history | tail -n 30 lists them.

2>&1 merges the error stream (stream 2) into the normal output (stream 1): without it, FOAM FATAL ERROR messages would appear on screen but not in the log. tee duplicates the stream: it shows it in the terminal and writes it to the named file.

Foundation tutorial Allrun scripts often use the functions in $WM_PROJECT_DIR/bin/tools/RunFunctions:

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

runApplication blockMesh        # writes log.blockMesh
runApplication foamRun          # writes log.foamRun

runApplication creates log.<program> by itself and refuses to rerun a step whose log already exists, printing a message like blockMesh already run on ... remove log file 'log.blockMesh' to re-run. It is a safeguard, not an error: to start again use ./Allclean (if present) or remove the logs concerned. Reading the script before running it tells you exactly which logs it will produce and where to look.

A tmux session lives on the server: it survives closing PowerShell, switching off the PC and network drops. It does not survive a server reboot. If tmux is not installed, screen provides the same function (screen -S name, detach with Ctrl+A then D, reattach with screen -r name).

A server is usually shared. Before starting a heavy run, find out how many CPUs and how much memory there are and how busy they are:

nproc                 # number of available cores
free -h               # total and free memory
uptime                # load average over 1, 5, 15 minutes
top                   # active processes (q to quit); htop if installed

The OpenFOAM parallel workflow, covered in case 05: parallel computing with MPI, runs like this, with the number of subdomains set 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

The -np value must equal numberOfSubdomains. Follow the server’s rules: some impose a maximum number of cores per user or require a job scheduler (for example Slurm, with sbatch); in that case the run is not started in tmux but with the job script provided by the administrator.

Each time step (or iteration, in steady cases) produces a block like this; the exact form depends on the solver module and on the algorithms chosen 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: ratio between the distance the fluid moves in one step and the cell size; compare the maximum with maxCo when the time step is adaptive.
• Initial residual: how far the previous field is from satisfying the equation at the start of the step; this is the value to follow over time.
• Final residual and No Iterations: where the linear solver stopped and how many iterations it took, according to tolerance and relTol.
• continuity errors: mass conservation error after the pressure correction.
• ExecutionTime / ClockTime: CPU time and elapsed wall time; the gap grows when the server is busy or the disk is slow.

Residuals, tolerances and algorithms are developed in Part 6: fvSolution, linear solvers and algorithms.

Interrupting with Ctrl+C or kill stops the process without writing the last time. If runTimeModifiable is on (the default), OpenFOAM rereads controlDict during the run, so you can request a clean stop:

cd ~/cases/myCase
foamDictionary -entry stopAt -set writeNow system/controlDict
# the solver writes the current time and exits at the next step
tail -f log.foamRun

After the stop, set stopAt back to endTime before restarting. Use kill PID only if the process is stuck (read the PID with ps); kill -9 is the last resort. Stop and restart options are described in Part 4.

Each written time contains every field on every cell; with large meshes and frequent writes the disk fills quickly, and a full disk stops the run with write errors. Check often:

df -h ~                     # free space on the home file system
du -sh ~/cases/myCase       # size of the case
du -sh ~/cases/myCase/* | sort -h | tail   # the largest directories

In controlDict, purgeWrite N keeps only the last N times; writeCompression on compresses the written fields. Before deleting results, ask whether they are needed for comparison or validation: deletion on Linux does not go through a recycle bin.

• Opening: klogg indexes the file in the background and opens logs of hundreds of megabytes without trouble, which Notepad++ handles with difficulty.
• Searching: the box at the bottom accepts regular expressions; matches appear in a separate pane and one click jumps to the line in the full file.
• Highlighters: define fixed colours for FOAM FATAL, Courant Number, Time =, so the important lines stand out while scrolling.
• Follow: in follow mode klogg rereads the file when it changes; useful on a local copy you refresh periodically, but it does not replace tail -f on the server.

The project website is https://klogg.filimonov.dev/; source code and release notes are on GitHub.

OpenFOAM includes the foamLog utility, which reads a log and creates a logs/ directory with a two-column file (time, value) for each quantity: for example logs/Ux_0, logs/p_0, logs/CourantMax_0. On the server:

cd ~/cases/myCase
foamLog log.foamRun
ls logs/
tar czf logs_residuals.tgz logs/    # a single file to download with FileZilla

Alternatively, on Windows, a Python script reads the downloaded log and writes a CSV that opens in Excel or feeds a plot:

# residuals.py  -  usage: python residuals.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:   # first residual of the step
            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), 'rows written to', sys.argv[1] + '.csv')

The script keeps only the first Initial residual of each field in each step, which is the meaningful value when pressure is solved several times within the same step. In Excel, build a scatter chart with a logarithmic vertical axis and filter by field.

The option -L 11111:127.0.0.1:11111 reads: local port 11111 on the Windows PC → destination 127.0.0.1:11111 as seen from the server. ParaView connects to localhost:11111 on the PC; the SSH client takes that traffic, encrypts it inside the already authenticated SSH connection, and the SSH server delivers it to pvserver, which listens only on its own loopback thanks to --bind-address=127.0.0.1. Nobody outside sees port 11111.

If you prefer to keep tunnel and terminal apart, open the tunnel alone with -N (no remote command) in a dedicated window, and start pvserver from a second SSH session or inside tmux:

# window 1 (stays open, shows no prompt)
ssh -N -L 11111:127.0.0.1:11111 USER@SERVER

# window 2
ssh USER@SERVER
pvserver --server-port=11111 --bind-address=127.0.0.1

With the ~/.ssh/config file from section 2, ssh cfd-paraview is all you need.

ParaView client and server must have the same major and minor version (for example 5.13 with 5.13): with different versions the connection is refused with an incompatibility message. On the server read the version with pvserver --version; on Windows in Help → About.

If the port is busy (Address already in use), find out what is using it:

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

Often it is a pvserver left running from an earlier session: stop it with Ctrl+C in its session, or with kill PID if the session is lost. On a multi-user server it is better for each user to have their own port, for example 11112: ssh -L 11112:127.0.0.1:11112, pvserver --server-port=11112 and port 11112 in the ParaView configuration. All three must match.

• Case Type: Reconstructed Case reads the time directories in the case root; Decomposed Case reads processor*/ directly and in parallel, if pvserver runs with several processes.
• Mesh Regions: internalMesh is the volume; individual patches (inlet, outlet, walls) are enabled separately and show quantities on the boundaries.
• Cell Arrays: the fields to load; loading only those you need saves memory and time.
• Skip Zero Time: on by default, it hides the 0/ directory with the initial conditions; turn it off to see them.
• Refresh (or Reload Files): while a run is still going, it updates the list of written times without reopening the case.

Parallel cases and the choice between decomposed reading and reconstruction are covered in case 05.

ParaView builds for servers without a screen use EGL (graphics card) or OSMesa (software rendering on the CPU). With a build that supports them, --force-offscreen-rendering avoids looking for an X11 display:

pvserver --server-port=11111 --bind-address=127.0.0.1 --force-offscreen-rendering
# several processes for large datasets (MPI-enabled build):
mpiexec -np 4 pvserver --server-port=11111 --bind-address=127.0.0.1

If the server has no usable pvserver, two routes remain. The first is to extract on the server only what you need and download it: for example foamToVTK -latestTime writes VTK files of the last time, which ParaView opens locally after the download. The second is to automate images with pvbatch or pvpython on the server and download only the PNGs. Either way, check the volume of data first with du -sh.

To do the exercise without a case of your own, copy a tutorial into your working area. With the OpenFOAM environment loaded:

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

The case is small, runs in seconds and contains a complete mesh, fields and dictionaries. To work on it from Windows, download the whole directory once with FileZilla into the local copy C:\CFD\cases\myCase (before any time directories exist) and follow the procedure from there. If the tutorial path differs in your installation, ls $FOAM_TUTORIALS/incompressibleFluid lists those available.

# environment and checks
source /opt/openfoam14/etc/bashrc      # Foundation Ubuntu package path
command -v foamRun ; foamVersion

# scripts and files
file Allrun ; sed -i 's/\r$//' Allrun  # diagnose and fix CRLF
foamDictionary -entry endTime system/controlDict

# resources and space
nproc ; free -h ; uptime ; df -h ~ ; du -sh ~/cases/myCase

# clean stop
foamDictionary -entry stopAt -set writeNow system/controlDict

# residuals in columns
foamLog log.foamRun ; tar czf logs_residuals.tgz logs/

# ports in use
ss -ltnp | grep 11111                  # Linux
netstat -ano | findstr :11111          # Windows