Typhon CFD Solver

Mesh generation

GRESSIER Jérémie — 2013-06-10T14:00:00Z

`ty2dmesh`

This tool can generate quad or tri based (regular) mesh. It includes morphing function and boundaries splitting.

generation of a bump (HiOCFD case C1.1) with tri regular splitting

ty2dmesh -nx 100 -ny 80 -fx "3*(x-.5)" -fy "0.8*(y+(1-y)*.0625*exp(-25*sqr(3*(x-.5))))" -tri4 bumptri4-100x80.tym

`ty3dmesh`

the same kind of tool for 3D hexa mesh.

TYPHON solution format

GRESSIER Jérémie — 2011-09-11T14:00:00Z

Typhon solution format uses CFDTOOLS XBIN format. As Typhon format, it needs a TYPHON header which defines the number of expected mesh and solution. The mesh should be defined (see mesh definition) or linked to another mesh file. Each following solution is written with a set of XBIN sections:

solution header

number of elements
number of scalars
number of vectors
number of face sections
number of cell marks sections
number of face marks sections

a set of scalar sections

scalar id
scalar array

a set of vector sections

vector id
(3 components) vector array

TYPHON mesh format

GRESSIER Jérémie — 2011-09-11T13:30:00Z

Typhon mesh format uses CFDTOOLS XBIN format. As Typhon format, it needs a TYPHON header which defines the number of expected mesh and solution. For each mesh, a ordered set of XBIN data sections is needed:

mesh header

mesh type (currently only unstructured mesh)
number of cells, faces and nodes
number of cell sections
number of face sections
number of cell marks sections
number of face marks sections

a set of cell sections

size etc

a set of face sections

size etc

node coordinates section

(number of nodes) x (3 coordinates)

a set of cell marks sections

mark name
indirect ordered array of face index in face sections

a set of face marks sections

mark name
indirect ordered array of face index in face sections

TYPHON internal formats

GRESSIER Jérémie — 2011-09-11T13:00:00Z

Typhon internal formats use CFDTOOLS XBIN format. It can be used for mesh and/or solutions. All Typhon formats start with a XBIN section (name is FILE_HEADER) which defines

Typhon format version number
Typhon type of file (mesh, solution, monitor...)
number of meshes
number of solutions

If this file only has meshes, it is considered as a mesh file and is described in this article.

If there are solutions, it must contain meshes too. The structure of such Typhon solution files is detailed in this article.

Versions

version 2: shared mesh

add cell marks in mesh
mesh definition tag in typhon header (full, shared, shared connectivity)

version 3: spectral solutions (rev742)

number of degree of freedom (dof) per cell
solution structure tag

XBIN open format

GRESSIER Jérémie — 2011-09-11T12:00:00Z

A XBIN file starts with a header. It is then followed by an undertermined number of data sections up to the end of file.

Header

In order to check the file format, one must find a header defined as follows:

4 (1-byte) characters 'XBIN'
a big endian 2-byte integer of XBIN version number
a 4-byte integer to check endianness (1234)

Data sections

Data sections are composed by

a data header
data arrays
a 3-byte end of section ('END' string)

Data header

A data header defines the data section. It includes

a data section name
XBIN data type
user defined type
real and integer size
a set of (integer) parameters
dimensions of data arrays (if needed)
external string (if needed)

Data arrays

There can be defined as

no data section
ordered or indirect ordered arrays
with integers or floating point reals

If ordered, only minimum and maximum indexes are given, otherwise, the data section starts with an array of index indirection. It is then followed by the data itself.

Unsteady Supersonic flow over parabolic 20% bump

GRESSIER Jérémie — 2011-09-01T22:00:00Z

Case description

20% bump in a channel
inviscid flow
unsteady upstream Mach number (sinusoidal oscillation from 3 to 2.4 to 3.)

MACH=3.+.6*(cos((t-.1)*6.28)-1.)*step((t-.1)*(1.1-t))

Numerical parameters

1600x320 quad mesh
morphing functions are

MORPH_X = 5*X MORPH_Y = Y+step(1-(sqr(x-.4)/0.04))*(1-sqr(x-.4)/0.04)*.2*(1-Y)
2nd order explicit Runge-Kutta, CFL=1
HLLC scheme, MUSCL extrapolation, 3rd order Kim limiter

Results

Ressources

An example of parameter file (main.rpm):

BLOCK:PROJECT 
 NZONE = 1 
 COORD = 2D 
 TIME = UNSTEADY 
 !RESIDUALS = 1.e-8
 DURATION = 2.
 NCYCLE = 100

ENDBLOCK 



BLOCK:OUTPUT 
 FORMAT = VTK-BIN
 FILE = "C2"
 PERIOD = 1 

ENDBLOCK



BLOCK:ZONE 
 NAME = "" 
 SOLVER = EULER 

ENDBLOCK



BLOCK:MESH
 FORMAT = INTERNAL
 FILE = "quad200x40.tym" 
 MORPH_X = 5*X
 MORPH_Y = Y+step(1-(sqr(x-.4)/0.04))*(1-sqr(x-.4)/0.04)*.2*(1-Y)

ENDBLOCK



BLOCK:MODEL
 DYNAMICS = EULER
 GAS = AIR

ENDBLOCK



BLOCK:TIME_PARAM 
 METHOD = RK2
 CFL = 1.
 RESIDUALS = .1

ENDBLOCK



BLOCK:SPAT_PARAM 
 SCHEME = HLLC
 HIGHRES = MUSCL
 LIMITER = ALBADA

ENDBLOCK



BLOCK:INIT
 P = 1.0E5
 T = 300.
 MACH = 3.
 DIRECTION = (1., 0., 0.)

ENDBLOCK



BLOCK:BOCO
 FAMILY = IMIN
 TYPE = SUPERSONIC_INLET
 PI = 1.E5
 TI = 300.
 MACH = 3.+.6*(cos((t-.1)*6.28)-1.)*step((t-.1)*(1.1-t))
 DIRECTION = ( 1., 0., 0.)

ENDBLOCK



BLOCK:BOCO
 FAMILY = IMAX
 TYPE = SUPERSONIC_OUTLET

ENDBLOCK



BLOCK:BOCO
 FAMILY = JMIN
 TYPE = SYMMETRY

ENDBLOCK



BLOCK:BOCO
 FAMILY = JMAX
 TYPE = SYMMETRY

ENDBLOCK

Typhon post-processing

GRESSIER Jérémie — 2011-06-03T08:30:00Z

A set of tools is provided to manage Typhon internal format files. Post-processors are detailed here.

Converters are detailed on this linked article.

`tymonitor`

command line: tymonitor [options] -[mon] "monitor=equation" inputfile[.tys]

where -[mon] option:
- -avg "monitor=equation" : volume weighted average of monitor
- -min "monitor=equation" : minimum value of monitor
- -max "monitor=equation" : maximum value of monitor
- "monitor" is the monitor name, outputs are written to "monitor.tmon"
- "equation" is the expression of monitor, depending on x,y,z and field variables

where [options] could be:
- -axi : enforce 2D axisymmetric mesh (metric calculation)
- -imin index : starting index solution (default: 1)
- -imax index : ending index solution
- -isize size : size of index suffix (default: 4)

parsed files will be
- inputfile.tys if -imax has not been defined
- inputfile.nnnn.tys if -imax has been defined

XBIN neutral format

GRESSIER Jérémie — 2011-06-02T15:30:00Z

XBIN neutral format is a new fortran based binary format which has been developed to support TYPHON internal format but can be used for many other purposes. It features automatic handling of integers and reals endianness check of integers and reals sizes version numbers to ensure backward compatibility sequential structure of data blocks

- File Format / XBIN neutral format

Converters

GRESSIER Jérémie — 2011-05-10T20:00:00Z

`typhon2vtk`

command line: typhon2vtk [options] inputfile.tys
available options:
- -bin / -binary : binary output (default)
- -asc / -ascii : formatted output
- -o basename : define basename of output file (default is inputfile)

`typhon2tecplot`

The tecplot file contains 2 zones: one is the mesh, the other one is the solution (with shared connectivity and node positions)

command line: typhon2tecplot [options] inputfile.tys
available options:
- -o basename : define basename of output file (default is inputfile)

Symbolic functions

GRESSIER Jérémie — 2011-04-28T10:30:00Z

A set of modules and routines aims at defining and computing symbolic expressions.

Available operators

Available binary operators are + - * / ^

Available unary operators are

inv
sqr, sqrt
ln, log
sin, cos, tan, asin, acos, atan
sinh, cosh, tanh
abs, step, ramp

How to use in fortran routines

1. define a fortran symbolic function

use FCT_NODE

type(st_fct_node) :: fctnode

2. parse a string to a symbolic function

use FCT_PARSER

character(len=100) :: str

integer :: info

str="sqrt(X*X+Y*Y)"

call convert_to_funct(str, fctnode, info)

3. define variables in FCT environment

use FCT_ENV

type(st_fct_env) :: env

call new_fct_env(env)

call fct_env_set_real(env, "X", 2.)

call fct_env_set_real(env, "Y", 3.)

4. compute symbolic functions using environment values

use FCT_EVAL

real :: result

call fct_eval_real(env, fctnode, result)