User Guide
For information on how to install PyFR see Installation.
Running PyFR
PyFR 1.15.0 uses three distinct file formats:
.ini
— configuration file.pyfrm
— mesh file.pyfrs
— solution file
The following commands are available from the pyfr
program:
pyfr import
— convert a Gmsh .msh file into a PyFR .pyfrm file.Example:
pyfr import mesh.msh mesh.pyfrm
pyfr partition
— partition an existing mesh and associated solution files.Example:
pyfr partition 2 mesh.pyfrm solution.pyfrs .
pyfr run
— start a new PyFR simulation. Example:pyfr run mesh.pyfrm configuration.ini
pyfr restart
— restart a PyFR simulation from an existing solution file. Example:pyfr restart mesh.pyfrm solution.pyfrs
pyfr export
— convert a PyFR.pyfrs
file into an unstructured VTK.vtu
or.pvtu
file. If a-k
flag is provided with an integer argument then.pyfrs
elements are converted to high-order VTK cells which are exported, where the order of the VTK cells is equal to the value of the integer argument. Example:pyfr export -k 4 mesh.pyfrm solution.pyfrs solution.vtu
If a
-d
flag is provided with an integer argument then.pyfrs
elements are subdivided into linear VTK cells which are exported, where the number of sub-divisions is equal to the value of the integer argument. Example:pyfr export -d 4 mesh.pyfrm solution.pyfrs solution.vtu
If no flags are provided then
.pyfrs
elements are converted to high-order VTK cells which are exported, where the order of the cells is equal to the order of the solution data in the.pyfrs
file.
Running in Parallel
PyFR can be run in parallel. To do so prefix pyfr
with
mpiexec -n <cores/devices>
. Note that the mesh must be
pre-partitioned, and the number of cores or devices must be equal to
the number of partitions.
Configuration File (.ini)
The .ini configuration file parameterises the simulation. It is written
in the INI format.
Parameters are grouped into sections. The roles of each section and
their associated parameters are described below. Note that both ;
and
#
may be used as comment characters. Additionally, all parameter
values support environment variable expansion.
Backends
The backend sections detail how the solver will be configured for a range of different hardware platforms. If a hardware specific backend section is omitted, then PyFR will fall back to built-in default settings.
[backend]
Parameterises the backend with
precision
— number precision:single
|double
rank-allocator
— MPI rank allocator:linear
|random
collect-wait-times
— If to track MPI request wait times or not:True
|False
collect-wait-times-len
— Size of the wait time history buffer:int
Example:
[backend]
precision = double
rank-allocator = linear
[backend-cuda]
Parameterises the CUDA backend with
device-id
— method for selecting which device(s) to run on:int |
round-robin
|local-rank
|uuid
mpi-type
— type of MPI library that is being used:standard
|cuda-aware
cflags
— additional NVIDIA realtime compiler (nvrtc
) flags:string
Example:
[backend-cuda]
device-id = round-robin
mpi-type = standard
[backend-hip]
Parameterises the HIP backend with
device-id
— method for selecting which device(s) to run on:int |
local-rank
|uuid
mpi-type
— type of MPI library that is being used:standard
|hip-aware
Example:
[backend-hip]
device-id = local-rank
mpi-type = standard
[backend-opencl]
Parameterises the OpenCL backend with
platform-id
— for selecting platform id:int | string
device-type
— for selecting what type of device(s) to run on:all
|cpu
|gpu
|accelerator
device-id
— for selecting which device(s) to run on:int | string |
local-rank
|uuid
gimmik-max-nnz
— cutoff for GiMMiK in terms of the number of non-zero entires in a constant matrix:int
Example:
[backend-opencl]
platform-id = 0
device-type = gpu
device-id = local-rank
gimmik-max-nnz = 512
[backend-openmp]
Parameterises the OpenMP backend with
cc
— C compiler:string
cflags
— additional C compiler flags:string
alignb
— alignment requirement in bytes; must be a power of two and at least 32:int
schedule
— OpenMP loop scheduling scheme:static
|dynamic
|dynamic, n
|guided
|guided, n
where n is a positive integer.
Example:
[backend-openmp]
cc = gcc
Systems
These sections of the input file setup and control the physical system being solved, as well as charateristics of the spatial and temporal schemes to be used.
[constants]
Sets constants used in the simulation
gamma
— ratio of specific heats foreuler
|navier-stokes
:float
mu
— dynamic viscosity fornavier-stokes
:float
nu
— kinematic viscosity forac-navier-stokes
:float
Pr
— Prandtl number fornavier-stokes
:float
cpTref
— product of specific heat at constant pressure and reference temperature fornavier-stokes
with Sutherland’s Law:float
cpTs
— product of specific heat at constant pressure and Sutherland temperature fornavier-stokes
with Sutherland’s Law:float
ac-zeta
— artificial compressibility factor forac-euler
|ac-navier-stokes
float
Other constant may be set by the user which can then be used throughout the
.ini
file.
Example:
[constants]
; PyFR Constants
gamma = 1.4
mu = 0.001
Pr = 0.72
; User Defined Constants
V_in = 1.0
P_out = 20.0
[solver]
Parameterises the solver with
system
— governing system:euler
|navier-stokes
|ac-euler
|ac-navier-stokes
where
navier-stokes
requiresviscosity-correction
— viscosity correction:none
|sutherland
shock-capturing
— shock capturing scheme:none
|artificial-viscosity
order
— order of polynomial solution basis:int
anti-alias
— type of anti-aliasing:flux
|surf-flux
|flux, surf-flux
Example:
[solver]
system = navier-stokes
order = 3
anti-alias = flux
viscosity-correction = none
shock-capturing = artificial-viscosity
[solver-time-integrator]
Parameterises the time-integration scheme used by the solver with
formulation
— formulation:std
|dual
where
std
requiresscheme
— time-integration schemeeuler
|rk34
|rk4
|rk45
|tvd-rk3
tstart
— initial timefloat
tend
— final timefloat
dt
— time-stepfloat
controller
— time-step controllernone
|pi
where
pi
only works withrk34
andrk45
and requiresatol
— absolute error tolerancefloat
rtol
— relative error tolerancefloat
errest-norm
— norm to use for estimating the erroruniform
|l2
safety-fact
— safety factor for step size adjustment (suitable range 0.80-0.95)float
min-fact
— minimum factor by which the time-step can change between iterations (suitable range 0.1-0.5)float
max-fact
— maximum factor by which the time-step can change between iterations (suitable range 2.0-6.0)float
dt-max
— maximum permissible time-stepfloat
dual
requiresscheme
— time-integration schemebackward-euler
|sdirk33
|sdirk43
pseudo-scheme
— pseudo time-integration schemeeuler
|rk34
|rk4
|rk45
|tvd-rk3
|vermeire
tstart
— initial timefloat
tend
— final timefloat
dt
— time-stepfloat
controller
— time-step controllernone
pseudo-dt
— pseudo time-stepfloat
pseudo-niters-max
— minimum number of iterationsint
pseudo-niters-min
— maximum number of iterationsint
pseudo-resid-tol
— pseudo residual tolerancefloat
pseudo-resid-norm
— pseudo residual normuniform
|l2
pseudo-controller
— pseudo time-step controllernone
|local-pi
where
local-pi
only works withrk34
andrk45
and requiresatol
— absolute error tolerancefloat
safety-fact
— safety factor for pseudo time-step size adjustment (suitable range 0.80-0.95)float
min-fact
— minimum factor by which the local pseudo time-step can change between iterations (suitable range 0.98-0.998)float
max-fact
— maximum factor by which the local pseudo time-step can change between iterations (suitable range 1.001-1.01)float
pseudo-dt-max-mult
— maximum permissible local pseudo time-step given as a multiplier ofpseudo-dt
(suitable range 2.0-5.0)float
Example:
[solver-time-integrator]
formulation = std
scheme = rk45
controller = pi
tstart = 0.0
tend = 10.0
dt = 0.001
atol = 0.00001
rtol = 0.00001
errest-norm = l2
safety-fact = 0.9
min-fact = 0.3
max-fact = 2.5
[solver-dual-time-integrator-multip]
Parameterises multi-p for dual time-stepping with
pseudo-dt-fact
— factor by which the pseudo time-step size changes between multi-p levels:float
cycle
— nature of a single multi-p cycle:[(order,nsteps), (order,nsteps), ... (order,nsteps)]
where
order
in the first and last bracketed pair must be the overall polynomial order used for the simulation, andorder
can only change by one between subsequent bracketed pairs
Example:
[solver-dual-time-integrator-multip]
pseudo-dt-fact = 2.3
cycle = [(3, 1), (2, 1), (1, 1), (0, 2), (1, 1), (2, 1), (3, 3)]
[solver-interfaces]
Parameterises the interfaces with
riemann-solver
— type of Riemann solver:rusanov
|hll
|hllc
|roe
|roem
where
hll
|hllc
|roe
|roem
do not work withac-euler
|ac-navier-stokes
ldg-beta
— beta parameter used for LDG:float
ldg-tau
— tau parameter used for LDG:float
Example:
[solver-interfaces]
riemann-solver = rusanov
ldg-beta = 0.5
ldg-tau = 0.1
[solver-source-terms]
Parameterises solution, space (x, y, [z]), and time (t) dependent source terms with
rho
— density source term foreuler
|navier-stokes
:string
rhou
— x-momentum source term foreuler
|navier-stokes
:string
rhov
— y-momentum source term foreuler
|navier-stokes
:string
rhow
— z-momentum source term foreuler
|navier-stokes
:string
E
— energy source term foreuler
|navier-stokes
:string
p
— pressure source term forac-euler
|ac-navier-stokes
:string
u
— x-velocity source term forac-euler
|ac-navier-stokes
:string
v
— y-velocity source term forac-euler
|ac-navier-stokes
:string
w
— w-velocity source term forac-euler
|ac-navier-stokes
:string
Example:
[solver-source-terms]
rho = t
rhou = x*y*sin(y)
rhov = z*rho
rhow = 1.0
E = 1.0/(1.0+x)
[solver-artificial-viscosity]
Parameterises artificial viscosity for shock capturing with
max-artvisc
— maximum artificial viscosity:float
s0
— sensor cut-off:float
kappa
— sensor range:float
Example:
[solver-artificial-viscosity]
max-artvisc = 0.01
s0 = 0.01
kappa = 5.0
[soln-filter]
Parameterises an exponential solution filter with
nsteps
— apply filter everynsteps
:int
alpha
— strength of filter:float
order
— order of filter:int
cutoff
— cutoff frequency below which no filtering is applied:int
Example:
[soln-filter]
nsteps = 10
alpha = 36.0
order = 16
cutoff = 1
Boundary and Initial Conditions
These sections allow users to set the boundary and initial conditions of calculations.
[soln-bcs-name]
Parameterises constant, or if available space (x, y, [z]) and time (t) dependent, boundary condition labelled name in the .pyfrm file with
type
— type of boundary condition:ac-char-riem-inv
|ac-in-fv
|ac-out-fp
|char-riem-inv
|no-slp-adia-wall
|no-slp-isot-wall
|no-slp-wall
|slp-adia-wall
|slp-wall
|sub-in-frv
|sub-in-ftpttang
|sub-out-fp
|sup-in-fa
|sup-out-fn
where
ac-char-riem-inv
only works withac-euler
|ac-navier-stokes
and requiresac-zeta
— artificial compressibility factor for boundary (increasingac-zeta
makes the boundary less reflective allowing larger deviation from the target state)float
niters
— number of Newton iterationsint
p
— pressurefloat | string
u
— x-velocityfloat | string
v
— y-velocityfloat | string
w
— z-velocityfloat | string
ac-in-fv
only works withac-euler
|ac-navier-stokes
and requiresu
— x-velocityfloat | string
v
— y-velocityfloat | string
w
— z-velocityfloat | string
ac-out-fp
only works withac-euler
|ac-navier-stokes
and requiresp
— pressurefloat | string
char-riem-inv
only works witheuler
|navier-stokes
and requiresrho
— densityfloat | string
u
— x-velocityfloat | string
v
— y-velocityfloat | string
w
— z-velocityfloat | string
p
— static pressurefloat | string
no-slp-adia-wall
only works withnavier-stokes
no-slp-isot-wall
only works withnavier-stokes
and requiresu
— x-velocity of wallfloat
v
— y-velocity of wallfloat
w
— z-velocity of wallfloat
cpTw
— product of specific heat capacity at constant pressure and temperature of wallfloat
no-slp-wall
only works withac-navier-stokes
and requiresu
— x-velocity of wallfloat
v
— y-velocity of wallfloat
w
— z-velocity of wallfloat
slp-adia-wall
only works witheuler
|navier-stokes
slp-wall
only works withac-euler
|ac-navier-stokes
sub-in-frv
only works withnavier-stokes
and requiresrho
— densityfloat | string
u
— x-velocityfloat | string
v
— y-velocityfloat | string
w
— z-velocityfloat | string
sub-in-ftpttang
only works withnavier-stokes
and requirespt
— total pressurefloat
cpTt
— product of specific heat capacity at constant pressure and total temperaturefloat
theta
— azimuth angle (in degrees) of inflow measured in the x-y plane relative to the positive x-axisfloat
phi
— inclination angle (in degrees) of inflow measured relative to the positive z-axisfloat
sub-out-fp
only works withnavier-stokes
and requiresp
— static pressurefloat | string
sup-in-fa
only works witheuler
|navier-stokes
and requiresrho
— densityfloat | string
u
— x-velocityfloat | string
v
— y-velocityfloat | string
w
— z-velocityfloat | string
p
— static pressurefloat | string
sup-out-fn
only works witheuler
|navier-stokes
Example:
[soln-bcs-bcwallupper]
type = no-slp-isot-wall
cpTw = 10.0
u = 1.0
Simple periodic boundary conditions are supported; however, their behaviour
is not controlled through the .ini
file, instead it is handled at
the mesh generation stage. Two faces may be taged with
periodic_x_l
and periodic_x_r
, where x
is a unique
identifier for the pair of boundaries. Currently, only periodicity in a
single cardinal direction is supported, for example, the planes
(x,y,0)`
and (x,y,10)
.
[soln-ics]
Parameterises space (x, y, [z]) dependent initial conditions with
rho
— initial density distribution foreuler
|navier-stokes
:string
u
— initial x-velocity distribution foreuler
|navier-stokes
|ac-euler
|ac-navier-stokes
:string
v
— initial y-velocity distribution foreuler
|navier-stokes
|ac-euler
|ac-navier-stokes
:string
w
— initial z-velocity distribution foreuler
|navier-stokes
|ac-euler
|ac-navier-stokes
:string
p
— initial static pressure distribution foreuler
|navier-stokes
|ac-euler
|ac-navier-stokes
:string
Example:
[soln-ics]
rho = 1.0
u = x*y*sin(y)
v = z
w = 1.0
p = 1.0/(1.0+x)
Nodal Point Sets
Solution point sets must be specified for each element type that is used and flux point sets must be specified for each interface type that is used. If anti-aliasing is enabled then quadrature point sets for each element and interface type that is used must also be specified. For example, a 3D mesh comprised only of prisms requires a solution point set for prism elements and flux point set for quadrilateral and triangular interfaces.
[solver-interfaces-line{-mg-porder}]
Parameterises the line interfaces, or if -mg-porder is suffixed the line interfaces at multi-p level order, with
flux-pts
— location of the flux points on a line interface:gauss-legendre
|gauss-legendre-lobatto
quad-deg
— degree of quadrature rule for anti-aliasing on a line interface:int
quad-pts
— name of quadrature rule for anti-aliasing on a line interface:gauss-legendre
|gauss-legendre-lobatto
Example:
[solver-interfaces-line]
flux-pts = gauss-legendre
quad-deg = 10
quad-pts = gauss-legendre
[solver-interfaces-tri{-mg-porder}]
Parameterises the triangular interfaces, or if -mg-porder is suffixed the triangular interfaces at multi-p level order, with
flux-pts
— location of the flux points on a triangular interface:williams-shunn
quad-deg
— degree of quadrature rule for anti-aliasing on a triangular interface:int
quad-pts
— name of quadrature rule for anti-aliasing on a triangular interface:williams-shunn
|witherden-vincent
Example:
[solver-interfaces-tri]
flux-pts = williams-shunn
quad-deg = 10
quad-pts = williams-shunn
[solver-interfaces-quad{-mg-porder}]
Parameterises the quadrilateral interfaces, or if -mg-porder is suffixed the quadrilateral interfaces at multi-p level order, with
flux-pts
— location of the flux points on a quadrilateral interface:gauss-legendre
|gauss-legendre-lobatto
quad-deg
— degree of quadrature rule for anti-aliasing on a quadrilateral interface:int
quad-pts
— name of quadrature rule for anti-aliasing on a quadrilateral interface:gauss-legendre
|gauss-legendre-lobatto
|witherden-vincent
Example:
[solver-interfaces-quad]
flux-pts = gauss-legendre
quad-deg = 10
quad-pts = gauss-legendre
[solver-elements-tri{-mg-porder}]
Parameterises the triangular elements, or if -mg-porder is suffixed the triangular elements at multi-p level order, with
soln-pts
— location of the solution points in a triangular element:williams-shunn
quad-deg
— degree of quadrature rule for anti-aliasing in a triangular element:int
quad-pts
— name of quadrature rule for anti-aliasing in a triangular element:williams-shunn
|witherden-vincent
Example:
[solver-elements-tri]
soln-pts = williams-shunn
quad-deg = 10
quad-pts = williams-shunn
[solver-elements-quad{-mg-porder}]
Parameterises the quadrilateral elements, or if -mg-porder is suffixed the quadrilateral elements at multi-p level order, with
soln-pts
— location of the solution points in a quadrilateral element:gauss-legendre
|gauss-legendre-lobatto
quad-deg
— degree of quadrature rule for anti-aliasing in a quadrilateral element:int
quad-pts
— name of quadrature rule for anti-aliasing in a quadrilateral element:gauss-legendre
|gauss-legendre-lobatto
|witherden-vincent
Example:
[solver-elements-quad]
soln-pts = gauss-legendre
quad-deg = 10
quad-pts = gauss-legendre
[solver-elements-hex{-mg-porder}]
Parameterises the hexahedral elements, or if -mg-porder is suffixed the hexahedral elements at multi-p level order, with
soln-pts
— location of the solution points in a hexahedral element:gauss-legendre
|gauss-legendre-lobatto
quad-deg
— degree of quadrature rule for anti-aliasing in a hexahedral element:int
quad-pts
— name of quadrature rule for anti-aliasing in a hexahedral element:gauss-legendre
|gauss-legendre-lobatto
|witherden-vincent
Example:
[solver-elements-hex]
soln-pts = gauss-legendre
quad-deg = 10
quad-pts = gauss-legendre
[solver-elements-tet{-mg-porder}]
Parameterises the tetrahedral elements, or if -mg-porder is suffixed the tetrahedral elements at multi-p level order, with
soln-pts
— location of the solution points in a tetrahedral element:shunn-ham
quad-deg
— degree of quadrature rule for anti-aliasing in a tetrahedral element:int
quad-pts
— name of quadrature rule for anti-aliasing in a tetrahedral element:shunn-ham
|witherden-vincent
Example:
[solver-elements-tet]
soln-pts = shunn-ham
quad-deg = 10
quad-pts = shunn-ham
[solver-elements-pri{-mg-porder}]
Parameterises the prismatic elements, or if -mg-porder is suffixed the prismatic elements at multi-p level order, with
soln-pts
— location of the solution points in a prismatic element:williams-shunn~gauss-legendre
|williams-shunn~gauss-legendre-lobatto
quad-deg
— degree of quadrature rule for anti-aliasing in a prismatic element:int
quad-pts
— name of quadrature rule for anti-aliasing in a prismatic element:williams-shunn~gauss-legendre
|williams-shunn~gauss-legendre-lobatto
|witherden-vincent
Example:
[solver-elements-pri]
soln-pts = williams-shunn~gauss-legendre
quad-deg = 10
quad-pts = williams-shunn~gauss-legendre
[solver-elements-pyr{-mg-porder}]
Parameterises the pyramidal elements, or if -mg-porder is suffixed the pyramidal elements at multi-p level order, with
soln-pts
— location of the solution points in a pyramidal element:gauss-legendre
|gauss-legendre-lobatto
quad-deg
— degree of quadrature rule for anti-aliasing in a pyramidal element:int
quad-pts
— name of quadrature rule for anti-aliasing in a pyramidal element:witherden-vincent
Example:
[solver-elements-pyr]
soln-pts = gauss-legendre
quad-deg = 10
quad-pts = witherden-vincent
Plugins
Plugins allow for powerful additional functionality to be swapped in and out. It is possible to load multiple instances of the same plugin by appending a tag, for example:
[soln-plugin-writer]
...
[soln-plugin-writer-2]
...
[soln-plugin-writer-three]
...
[soln-plugin-writer]
Periodically write the solution to disk in the pyfrs format. Parameterised with
dt-out
— write to disk everydt-out
time units:float
basedir
— relative path to directory where outputs will be written:string
basename
— pattern of output names:string
post-action
— command to execute after writing the file:string
post-action-mode
— how the post-action command should be executed:blocking
|non-blocking
region
— region to be written, specified as either the entire domain using*
, a combination of the geometric shapes specified in Regions, or a sub-region of elements that have faces on a specific domain boundary via the name of the domain boundary:*
|shape(args, ...)
| string
Example:
[soln-plugin-writer]
dt-out = 0.01
basedir = .
basename = files-{t:.2f}
post-action = echo "Wrote file {soln} at time {t} for mesh {mesh}."
post-action-mode = blocking
region = box((-5, -5, -5), (5, 5, 5))
[soln-plugin-fluidforce-name]
Periodically integrates the pressure and viscous stress on the boundary
labelled name
and writes out the resulting force and moment (if requested)
vectors to a CSV file. Parameterised with
nsteps
— integrate everynsteps
:int
file
— output file path; should the file already exist it will be appended to:string
header
— if to output a header row or not:boolean
morigin
— origin used to compute moments (optional):(x, y, [z])
Example:
[soln-plugin-fluidforce-wing]
nsteps = 10
file = wing-forces.csv
header = true
morigin = (0.0, 0.0, 0.5)
[soln-plugin-nancheck]
Periodically checks the solution for NaN values. Parameterised with
nsteps
— check everynsteps
:int
Example:
[soln-plugin-nancheck]
nsteps = 10
[soln-plugin-residual]
Periodically calculates the residual and writes it out to a CSV file. Parameterised with
nsteps
— calculate everynsteps
:int
file
— output file path; should the file already exist it will be appended to:string
header
— if to output a header row or not:boolean
Example:
[soln-plugin-residual]
nsteps = 10
file = residual.csv
header = true
[soln-plugin-dtstats]
Write time-step statistics out to a CSV file. Parameterised with
flushsteps
— flush to disk everyflushsteps
:int
file
— output file path; should the file already exist it will be appended to:string
header
— if to output a header row or not:boolean
Example:
[soln-plugin-dtstats]
flushsteps = 100
file = dtstats.csv
header = true
[soln-plugin-pseudostats]
Write pseudo-step convergence history out to a CSV file. Parameterised with
flushsteps
— flush to disk everyflushsteps
:int
file
— output file path; should the file already exist it will be appended to:string
header
— if to output a header row or not:boolean
Example:
[soln-plugin-pseudostats]
flushsteps = 100
file = pseudostats.csv
header = true
[soln-plugin-sampler]
Periodically samples specific points in the volume and writes them out to a CSV file. The point location process automatically takes advantage of scipy.spatial.cKDTree where available. Parameterised with
nsteps
— sample everynsteps
:int
samp-pts
— list of points to sample:[(x, y), (x, y), ...]
|[(x, y, z), (x, y, z), ...]
format
— output variable format:primitive
|conservative
file
— output file path; should the file already exist it will be appended to:string
header
— if to output a header row or not:boolean
Example:
[soln-plugin-sampler]
nsteps = 10
samp-pts = [(1.0, 0.7, 0.0), (1.0, 0.8, 0.0)]
format = primitive
file = point-data.csv
header = true
[soln-plugin-tavg]
Time average quantities. Parameterised with
nsteps
— accumulate the average everynsteps
time steps:int
dt-out
— write to disk everydt-out
time units:float
tstart
— time at which to start accumulating average data:float
mode
— output file accumulation mode:continuous
|windowed
Windowed outputs averages over each
dt- out
period. Whereas, continuous outputs averages over alldt-out
periods thus far completed within a given invocation of PyFR. The default iswindowed
.basedir
— relative path to directory where outputs will be written:string
basename
— pattern of output names:string
precision
— output file number precision:single
|double
region
— region to be written, specified as either the entire domain using*
, a combination of the geometric shapes specified in Regions, or a sub-region of elements that have faces on a specific domain boundary via the name of the domain boundary:*
|shape(args, ...)
| stringavg
-name — expression to time average, written as a function of the primitive variables and gradients thereof; multiple expressions, each with their own name, may be specified:string
fun-avg
-name — expression to compute at file output time, written as a function of any ordinary average terms; multiple expressions, each with their own name, may be specified:string
As
fun-avg
terms are evaluated at write time, these are only indirectly effected by the averaging mode.
Example:
[soln-plugin-tavg]
nsteps = 10
dt-out = 2.0
mode = windowed
basedir = .
basename = files-{t:06.2f}
avg-u = u
avg-v = v
avg-uu = u*u
avg-vv = v*v
avg-uv = u*v
fun-avg-upup = uu - u*u
fun-avg-vpvp = vv - v*v
fun-avg-upvp = uv - u*v
fun-avg-urms = sqrt(uu - u*u + vv - v*v)
[soln-plugin-integrate]
Integrate quantities over the compuational domain. Parameterised with:
nsteps
— calculate the integral everynsteps
time steps:int
file
— output file path; should the file already exist it will be appended to:string
header
— if to output a header row or not:boolean
quad-deg
— degree of quadrature rule (optional):quad-pts-{etype}
— name of quadrature rule (optional):region
— region to integrate, specified as either the entire domain using*
or a combination of the geometric shapes specified in Regions:*
|shape(args, ...)
int
-name — expression to integrate, written as a function of the primitive variables and gradients thereof, the physical coordinates [x, y, [z]] and/or the physical time [t]; multiple expressions, each with their own name, may be specified:string
Example:
[soln-plugin-integrate]
nsteps = 50
file = integral.csv
header = true
quad-deg = 9
vor1 = (grad_w_y - grad_v_z)
vor2 = (grad_u_z - grad_w_x)
vor3 = (grad_v_x - grad_u_y)
int-E = rho*(u*u + v*v + w*w)
int-enst = rho*(%(vor1)s*%(vor1)s + %(vor2)s*%(vor2)s + %(vor3)s*%(vor3)s)
Regions
Certain plugins are capable of performing operations on a subset of the elements inside the domain. One means of constructing these element subsets is through parameterised regions. Note that an element is considered part of a region if any of its nodes are found to be contained within the region. Supported regions:
- Rectangular cuboid
box(x0, x1)
A rectangular cuboid defined by two diametrically opposed vertices. Valid in both 2D and 3D.
- Conical frustum
conical_frustum(x0, x1, r0, r1)
A conical frustum whose end caps are at x0 and x1 with radii r0 and r1, respectively. Only valid in 3D.
- Cone
cone(x0, x1, r)
A cone of radius r whose centre-line is defined by x0 and x1. Equivalent to
conical_frustum(x0, x1, r, 0)
. Only valid in 3D.- Cylinder
cylinder(x0, x1, r)
A circular cylinder of radius r whose centre-line is defined by x0 and x1. Equivalent to
conical_frustum(x0, x1, r, r)
. Only valid in 3D.- Cartesian ellipsoid
ellipsoid(x0, a, b, c)
An ellipsoid centred at x0 with Cartesian coordinate axes whose extents in the x, y, and z directions are given by a, b, and c, respectively. Only valid in 3D.
- Sphere
sphere(x0, r)
A sphere centred at x0 with a radius of r. Equivalent to
ellipsoid(x0, r, r, r)
. Only valid in 3D.
Region expressions can also be added and subtracted together
arbitrarily. For example
box((-10, -10, -10), (10, 10, 10)) - sphere((0, 0, 0), 3)
will
result in a cube-shaped region with a sphere cut out of the middle.
Additional Information
The INI file format is very versatile. A feature that can be useful in defining initial conditions is the substitution feature and this is demonstrated in the [soln-plugin-integrate] example.
To prevent situations where you have solutions files for unknown
configurations, the contents of the .ini
file are added as an attribute
to .pyfrs
files. These files use the HDF5 format and can be
straightforwardly probed with tools such as h5dump.
In several places within the .ini
file expressions may be used. As well as
the constant pi
, expressions containing the following functions are
supported:
+, -, *, /
— basic arithmeticsin, cos, tan
— basic trigonometric functions (radians)asin, acos, atan, atan2
— inverse trigonometric functionsexp, log
— exponential and the natural logarithmtanh
— hyperbolic tangentpow
— power, note**
is not supportedsqrt
— square rootabs
— absolute valuemin, max
— two variable minimum and maximum functions, arguments can be arrays