Options

inputFile: str

Name of the file that contains the surface mesh. This is a file that has been generated in an external meshing program, typically ICEMCFD.

patches: list = []

Explicitly assign arrays of patches as the input surface.

fileType: str = PLOT3D

Type of the input file.

• PLOT3D: PLOT3D format

• CGNS: CGNS format

skip: bool = False

Flag to entirely skip the grid generation of this geometry.

mode: str = hyperbolic

Type of extrusion.

• hyperbolic: Most commonly used

• elliptic: Not typically used

unattachedEdgesAreSymmetry: bool = True

Automatically applies symmetry boundary conditions to any edges that do not interface with another block. This option may fail in rare cases. See here for details.

outerFaceBC: str = farfield

Specifies the boundary condition at the outermost face of the extruded mesh.

• farfield: Farfield BC

• overset: Used for overset component meshes

BC: dict = {}

Specifies boundary condition information for specific block edges. See here for details.

families: str or dict = {}

Name given to wall surfaces. If a dictionary is submitted, each wall patch can be named separately. This can help with applying operations to specific wall patches.

autoConnect: bool = True

Run the cgnsUtilities connect function to add any necessary block to block connectivity.

noPointReduce: bool = False

Do not find duplicate nodes along edges. This can only be used with single surface input files.

N: int = 65

Number of grid levels to march. This determines the grid dimension in the off-wall direction. Typically, this should be a “multi-grid” friendly number.

s0: float = 0.01

Initial off-wall (normal) spacing of grid. This is taken to be constant across the entire geometry. The units are consistent with the rest of the geometry.

nConstantStart: int = 1

Number of constant off-wall layers before beginning stretch.

nConstantEnd: int = 1

Number of constant layers at the end of the march.

nTruncate: int = -1

This will stop the mesh marching after the specified number of levels. Specifying \(1 <\) nTruncate \(<\) N will produce a mesh that is identical to the first nTruncate levels of the full mesh with N levels. Values outside of this range have no effect. This option is mainly useful for debugging low quality cells or negative volumes in the first few layers of the mesh.

marchDist: float = 50.0

Distance to march in the normal direction. Most wing geometries will have a distance such that the farfield boundary is 10 to 20 span lengths away from the geometry.

nodeTol: float = 1e-08

Tolerance for nodes to be treated as identical.

splay: float = 0.25

Splay BC spreading factor. This controls how far the floating edges splay outwards and can be useful for increasing the volume overlap in overset meshes.

splayEdgeOrthogonality: float = 0.1

How hard to try to force orthogonality at splay edges. Should be between 0 and 0.5.

splayCornerOrthogonality: float = 0.2

How hard to try to force orthogonality at splay corners.

cornerAngle: float = 60.0

Maximum convex corner angle in degrees necessary to trigger the implicit node averaging scheme. See Section 8 of Chan and Steger for more information.

coarsen: int = 1

Automatically coarsen a surface mesh before starting extrusion. 1 gives the same surface mesh. 2 coarsens by a factor of 2 in each direction. 3 coarsens by a factor of 4 in each direction, and so on.

panelEps: float = 1e-08

Only used in elliptic mode. Distance source panels are “below” nodes. This parameter usually does not need to be changed.

farfieldTolerance: float = 4.0

Only used in elliptic mode. The multiple of the panel length cutoff to use the approximation formula.

useMatrixFree: bool = True

Only used in elliptic mode. Use matrix-free solution technique. This is always True when evalMode is fast.

evalMode: str = fast

Only used in elliptic mode. Type of panel evaluation routine.

• fast: Uses farfield approximations and panel groupings

• exact: Modifies the farfield tolerance to ensure that only the exact evaluations are used

• slow: Uses farfield approximations but does not group panels

sourceStrengthFile: str = panelStrength.source

Only used in elliptic mode. File to use to load/save the source strengths on the surface.

cMax: float = 1.0

The maximum permissible ratio of the step in the marching direction to the length of any in-plane edge. This parameter effectively operates as a CFL-type limit. If a step would result in a ratio c greater than cMax, the step is automatically split internally to respect this user-supplied limit. Increased robustness can be achieved at the expense of computational cost by lowering cMax.

nonLinear: bool = False

Use the nonlinear formulation. This is experimental and not currently recommended and may not work at all.

slExp: float = 0.15

Exponent used in the scaling function \(S_l\), which is computed as \(S_l = \left(\frac{\text{Distance from wall}}{\texttt{marchDist}}\right)^\texttt{slExp}\). \(S_l\) scales the explicit smoothing such that it is low near the wall to maintain orthogonality and high away from the wall to prevent crossing of grid lines in concave regions. This is the same purpose as described in Section 6 of Chan and Steger, but the computation is different. The exponent determines how quickly the smoothing ramps up as the extrusion moves away from the wall. An exponent closer to zero will result in steeper ramping.

ps0: float = -1.0

Initial pseudo off-wall spacing. This spacing must be less than or equal to s0. This is the actual spacing the hyperbolic scheme uses. The solver may take many pseudo steps before the first real grid level at s0. This is computed internally if a non-positive value is provided.

pGridRatio: float = -1.0

The ratio between successive levels in the pseudo grid. This will be typically somewhere between ~1.05 for large grids to 1.2 for small grids. This number is not the actual grid spacing of the final grid; that spacing ratio is computed and displayed at the beginning of a calculation. The pGridRatio must be smaller than that number. This is computed internally if a non-positive value is provided.

epsE: float = 1.0

The explicit smoothing parameter. Typical values are approximately 1.0. Increasing the explicit smoothing may result in a smoother grid, at the expense of orthogonality. If the geometry has very sharp corners, too much explicit smoothing will cause the solver to rapidly “soften” the corner and the grid will fold back on itself. In concave corners, additional smoothing will prevent lines from crossing (avoiding negative cells). See Section 3 of Chan and Steger for more information.

epsI: float = 2.0

Implicit smoothing parameter. Typical values are from 2.0 to 6.0. Generally increasing the implicit coefficient results in a more stable solution procedure. Usually this value should be twice the explicit smoothing parameter. See Section 3 of Chan and Steger for more information.

theta: float = 3.0

Kinsey-Barth coefficient. This provides additional implicit smoothing and is useful for preventing grid lines from crossing at concave corners. A single theta value is used for both in-plane directions. Typical values are ~2.0 to ~4.0. See Section 3 of Chan and Steger for more information.

volCoef: float = 0.25

Coefficient used in point-Jacobi local volume smoothing algorithm. The value should be between 0 and 1. Larger values will result in a more uniform cell volume distribution. Alternatively, use more volSmoothIter for stronger local smoothing. See Section 5 of Chan and Steger for more information.

volBlend: float = 0.0001

The global volume blending coefficient. This value will typically be very small, especially if you have widely varying cell sizes. Typical values are from ~0 to 0.001.

volSmoothIter: int = 100

The number of point-Jacobi local volume smoothing iterations to perform at each level. More iterations will result in a more uniform cell volume distribution.

volSmoothSchedule: list or NoneType = None

Define a piecewise linear schedule for volume smoothing iterations. If provided, this supersedes volSmoothIter. This option is usually used to limit the number of smoothing iterations early in the extrusion to maintain orthogonality near the wall and ramp up the number of smoothing iterations later in the extrusion to achieve a more uniform cell volume distribution in the farfield. An example of a smoothing schedule is "volSmoothSchedule": [[0, 10], [0.4, 50], [1.0, 100]]. In this example, the number of smoothing iterations increases linearly from 10 to 50 over the first 40% of grid levels. For the remaining levels, the number of smoothing iterations increases linearly from 50 to 100.

KSPRelTol: float = 1e-08

Tolerance for the solution of the linear system at each iteration. Typically \(1\times 10^{-8}\) is sufficient. Very difficult cases may benefit from a tighter convergence tolerance.

KSPMaxIts: int = 500

Maximum number of iterations to perform for each step. The default should be sufficient for most cases.

KSPSubspaceSize: int = 50

Size of the Krylov subspace. Very large and difficult problems may benefit from a larger subspace size.

writeMetrics: bool = False

Flag to write the mesh gradients to the solution file. This option should only be used for debugging purposes.

outputType: str = CGNS

Output format for the volume mesh.

• CGNS: CGNS format

• PLOT3D: PLOT3D format

outputFile: str or NoneType = None

Output filename. If None, an automatic filename will be generated by appending “_hyp” to the input filename.