Skip to content

Curvilinear Solver Inputs

The YAML file format is used for specifying the information required to run the solver. The documentation below lists the name and type of each option. If an option is flagged as required then it must be included when the parent block is present. The default values and lower/upper bounds are also included for variables that have them. If an option is flagged as mutable then it can be modified on a solver restart. Each tab level in the YAML file should be 2 spaces. Blocks which can take multiple sub-blocks of an entry argument are prefaced by a -. Keywords in the YAML input file are case-insensitive.

Grid

  • This section defines the location of basic input files associated with the structured overset grid generated for the problem.

grid:
  curv:
    gridFile: <required>
    BCFile: <required>
    fileType:
    B2BFile:
    interpFile:
    IBINDFile:
    restartFile:
    RANSFile:
    initFile:
    loadInfoOnInit:
    subsetFile:
    initWithExactSolution:
    initVelocitiesWithXYZ:
  • curv

    • Category of options to work with structured overset grids.
    • gridFile (string(fileName), required)

      • Input file name for the grid file. This will be a Plot3D file. Refer to file formats page for details. More file formats may become available in future software releases. It is customary to use .x or .x.ihc extension for Plot3D files. The .ihc extension is used in the output grid that gets generated after running overset grid connectivity using curvSolver > task: connectivity.
    • BCFile (string(fileName), required)

      • File specifying where the boundaries of the computational domain are. It is customary to use the .bc extension for BC files. These can be generated through LAVA custom CGT Tools.
      • Example format shown below:
        !       Name GridNumber   Jmin  Jmax  Kmin  Kmax  Lmin  Lmax
        !*********** *********** ***** ***** ***** ***** ***** *****
                fuse 1               1    -1     1    -1     1     1
        
      • These names will be assigned a BC type in BC > names: <name>.
    • fileType (string, default="plot3d")

      • Accepted Values: ["plot3d"]
      • Input grid file type. More file formats may become available in future software releases.
      • Plot3D
    • B2BFile (string(fileName), default="")

      • This file contains the block-to-block interface indices. This can be auto generated through connectivity by setting B2BExtractor > extractB2Bs: true or by using the B2BExtractor tool.
    • interpFile (string(fileName), default="")

      • Interpolation file for fringe stecil donors. Required if grid has overset. This file is usually called INTOUT with no extensions. The INTOUT file is generated using curvSolver > task: connectivity
    • IBINDFile (string(fileName), default="")

      • File containing known immersed boundary indices. Can also contain trip and transition trip strips represented as negative indices.
    • restartFile (string(fileName), default="")

      • Restart file allows for a continuation of the solution. This preserves history of the solution. Cannot be used with initFile option. Restart files are written as restart.#######.rst where the number is based on number of iterations or timesteps. restart.latest.rst will be linked to the latest written restart files. If the user wants to construct a file to use as a restart file it must be a stream access Plot3D function file with the .rst extension.
    • RANSFile (string(fileName), default="")

      • This file is used when the user wants to load in a pre-computed Reynold-Averaged Navier-Stokes solution. It will generate dummy qVec and turVec data and initialize a solution. It can be used in conjuction with user.F90 for special user-defined boundary conditions and/or source terms.
    • initFile (string(fileName), default="")

      • Plot3D function file to use as initial conditions for the simulation. It must have the following fields in this order: pressure, velocityX, velocityY, velocityZ, temperature, turVar1 (optional), and turVar2 (optional). The restart file written by the code is also valid. This differs from a restart file in that no history from the previous simulation is preserved.
      • NOTE: If using loadInfoOnInit (described below) then the initFile should have a .rst extension.
    • loadInfoOnInit (boolean, default=False)

      • Read the info file when using init to perform free stream correction. This option allows for a restart file to be used for initializing a simulation where the history is not wanted in the new simulation. The information includes freestream conditions and more. An example where this is needed is when a solution is being initialized from a different angle of attack.
      • NOTE: The user should remove all other data in restart.#######.info that is not freestream values for restarting unsteady cases when using this option.
    • subsetFile (string(fileName), default="")

      • File used to define grid surface subsets and associated names for the subsets. It is used for defining actuator regions as well as for specifying surface output on non-BC surface subsets.
    • initWithExactSolution (boolean, default=False)

      • Initialize the flow with a user-supplied dynamic link library (DLL) file defining the exact solution. Specifying a restart or initialization file along with this option will give an error.
    • initVelocitiesWithXYZ (boolean, default=False)

      • Initialize the velocities in the X, Y, and Z directions with the X, Y, and Z grid coordinates, respectively, after all other initializations have been performed. This is useful for debugging.

Overset

  • This section defined parameters associated with performing grid overset connectivity.

overset:
  viscousStencilRepairDist:
  repairInviscidStencils:
  useExistingHoleCut:
  performHoleCutExplicitly:
  exactPointMatching:
  optimizeOverlap:
  useClusters:
  IBOrphanSearchDist:
  rayExtensionMaxIter:
  debugNode:
  octTreeFileName:
  surfPaintBlankingNIter:
  octTreeFloodIter:
  octTreeFloodWriteLast:
  octTreeFloodWriteIter:
  octTreeFloodWriteIncr:
  octTreeFloodSeeds:
    -
      pt:
  boundarySurfaces:
  periodicB2BsAreBoundaries:
  inOutFlowsAreBoundaries:
  internalFlow:
  nSphereSurface:
  nSphereVolume:
  curvatureFactor:
  edgeFactor:
  octTreeMinDepth:
  octTreeMaxDepth:
  octTreeCubesPerEdge:
  octTreeBBox:
  priority:
  explicitSurface:
  explicitJKL:
  writeExplicitCutters:
  writeBodyCutEdges:
  writeSurfDeviation:
  writeSurfBCClasses:
  writeUncertainNodes:
  writeBlankedSurfaceInfo:
  writeNameGroupedBCs:
  writeDistBandOrphData:
  distBandOrphBandLims:
  distBandOrphWriteAllHigher:
  distBandOrphWriteAllLower:
  zoneSpecific:
    -
      zones:
      explicitJKL:
      curvatureFactor:
      edgeFactor:
      octTreeMinDepth:
      octTreeMaxDepth:
      octTreeCubesPerEdge:
      priority:
      explicitSurface:
  explicitBlanking:
    -
      type: <required>
      zones:
      paintSource:
      xMin:
      xMax:
      rotationAngle:
      radius:
      radiusInner:
      nFacet:
      fileName:
      fileNames:
      fileType:
      offset:
      operator:
      variable:
      value:
      origin:
      normal:
      axis1Pt:
      axis2Pt:
  • viscousStencilRepairDist (float, lower bound=0.000, default=0.1000E-02)

    • When donors are being searched for near a viscous wall during connectivity's donor search processess, or during wall-distance calculations, viscous surfaces must be projected onto each-other to properly account for the differences in which two grids can represent the same underlying surface. If a grid node is within this distance of a viscous wall node projected for this correction, it is also shifted. This value should be sized according to:
      • A) The size of the viscous geometry;
      • B) The expected boundary layer height.
    • A good rule of thumb for this is the physical distance between a viscous wall node and its ~30th node from the wall in a curvilinearly-normal direction.
  • repairInviscidStencils (boolean, default=False)

    • Perform viscous stencil repair projections during donor search for inviscid walls as well.
  • useExistingHoleCut (boolean, default=False)

    • If true, connectivity will not run hole cutting at all, and assume the iblank array, if provided in the grid, has properly defined all hole regions and move directly to donor search.
  • performHoleCutExplicitly (boolean, default=False)

    • If true, connectivity will not run implicit hole cutting, instead using the explicit cutters defined in the .yaml input file.
  • exactPointMatching (boolean, default=False)

    • If overlapped surfaces are exactly point-matched then some in/out tests may be performed improperly. This options activates certain double-checking routines to try and handle this.
  • optimizeOverlap (boolean, default=True)

    • Perform a fringe-reduction by blanking portions of grid if the resulting blanked grid can find better donors for its new fringes. Default is to optimize.
  • useClusters (boolean, default=True)

    • Multiblock-connected blocks cannot cut each other.
  • IBOrphanSearchDist (integer, default=3)

    • If an orphan is immersed, it will attempt to find a local donor node by locally stencil walking. This search distance is the jkl distance walked away from the immersed orphan.
    • NOTE: If this distance is < 3 then no walk search is performed.
  • rayExtensionMaxIter (integer, default=10)

    • In/out surface ray-casts by default only try to travel a certain distance within the surface octree. In very rare cases some nodes will need more iterations of this to properly find if they are in/out of the surface geometry.
  • debugNode ([integer, ...], default=0)

    • Format is [iBlk, j, k, l]. If this is on, then information related to this node will be dumped to the screen and various optional information files will be written.
  • octTreeFileName (string, default="")

    • If this is specified then the surface octree is written.
  • surfPaintBlankingNIter (integer, default=10)

    • The max number of master iterations of the surface-painting blanking process using the flooded surface octree.
  • octTreeFloodIter (integer, default=1000)

    • Maximum number of flood iterations performed using the octree for hole cutting. Increase if flooding fails.
  • octTreeFloodWriteLast (boolean, default=False)

    • Will write the last iteration of the flooded surface-defining octree.
  • octTreeFloodWriteIter (integer, lower bound=0, default=0)

    • Will write the specified iteration of the flooded surface-defining octree. Must be > 0.
  • octTreeFloodWriteIncr (integer, lower bound=0, default=0)

    • Will write every defined iter increment during flooding of the surface-defining octree. Must be > 0.
  • octTreeFloodSeeds

    • Specify locations where to start flooding surface octree.
    • pt ([float , float , float], default=[0.000, 0.000, 0.000])

      • Physical [X, Y, Z] location of where to start flooding surface octree for internal flows.
  • boundarySurfaces ([string, ...], default=[""])

    • Surfaces defining closed body for hole cutting.
  • periodicB2BsAreBoundaries (boolean, default=False)

    • If this is True, connectivity will treat non-self-point-matched b2bs (translated or rotated) as portions of the closed boundary. This currently does not support partial b2bs.
  • inOutFlowsAreBoundaries (boolean, default=False)

    • If this is True, connectivity will treat inlets and outlets as portions of the closed boundary. Does not count Riemann. Specifying boundarySurfaces ignores this option.
  • internalFlow (boolean, default=False)

    • If this is True, connectivity will treat inlets, outlets, and non-self-point-matched b2bs (translated or rotated) as portions of the closed boundary. In order to use this, at least one entry must exist in octTreeFloodSeeds. Specifying boundarySurfaces ignores this option.
  • nSphereSurface (integer, lower bound=1, default=100)

    • Number of fail-safe hemispherical rays used for surface cutting.
  • nSphereVolume (integer, lower bound=1, default=100)

    • Number of fail-safe hemispherical rays used for volume cutting.
  • curvatureFactor (float, default=1.000)

    • A value which is representative of the average surface curvature. The smaller, the less lenient the surface overlap checks will be w.r.t. curvature-based projection distance when determining if two surfaces are the 'same'. Increasing this value will make overlapping of surfaces easier, and can help if edge-cutting is occuring near the boundary. It stops being very effective after a value of 5.
  • edgeFactor (float, default=0.1000)

    • A value which is representative of the average surface edge length. The smaller, the less lenient the surface overlap checks will be w.r.t. grid-scaled normal-based projection distance when determining if two surfaces are the 'same'.
  • octTreeMinDepth (integer, default=11)

    • Minimum number of levels to build the surface octree.
  • octTreeMaxDepth (integer, default=15)

    • Maximum number of levels to build the surface octree.
  • octTreeCubesPerEdge (float, default=2.000)

    • Resolution of surface octree. Default is usually OK.
  • octTreeBBox ([float , float , float , float , float , float], default=[-0.1798+309, 0.1798+309, -0.1798+309, 0.1798+309, -0.1798+309, 0.1798+309])

    • A limiting bounding box for the surface octree. Can be used to limit connectivity surface flooding/blanking to a specific region, which can be helpful for very high aspect ratio geometries. Format is [xMin, xMax, yMin, yMax, zMin, zMax]
  • priority (float, default=1.000)

    • Change priority of all blocks. Can be helpful when making only a few blocks lower priority in the zone options section.
  • explicitSurface (integer, default=0)

    • Can be 0 or 1. Explicit surfaces can only be blanked by explicit hole cuts (EHCs). Because of this, they should never have any 'geometry-internal' faces.
  • explicitJKL ([integer , integer , integer , integer , integer , integer], default=0)

    • A range of a block which cannot be implicitly blanked. Can still be blanked by EHCs. Supplied list specifies [jMin, jMax, kMin, kMax, lMin, lMax]. This should be used as a last-resort hot-fix to prevent blanking when the user has no idea why something is being blanked.
  • writeExplicitCutters (boolean, default=False)

    • Write all EHCs in Tecplot format with names ehcSurface.###.plt. Writing can fail for INTEL compilers.
  • writeBodyCutEdges (boolean, default=False)

    • Write all edges cut by implicit surface to bodyCutEdges.dat.
  • writeSurfDeviation (boolean, default=False)

    • Write the deviation (offset distances) of the surface mesh to surfaceDeviation.plt.
  • writeSurfBCClasses (boolean, default=False)

    • Write all 'classes' of surface mesh BCs to surfaceBCClasses.plt.
  • writeUncertainNodes (boolean, default=False)

    • Write all volume-cut uncertain nodes not near the wall to uncertainNodesNotNearWall_#.dat.
  • writeBlankedSurfaceInfo (boolean, default=False)

    • Write relevant overset information of blanked surface to blanked_surf_info.plt.
  • writeNameGroupedBCs (boolean, default=False)

    • Write all the BCs of the grid, grouped by name to nameGroupedBCs.plt.
  • writeDistBandOrphData (boolean, default=False)

    • Writes orphan donor and receiver info into distBandedOrphanInfo.dat. Each zone of written file contains orphans whose distance to its interpolation point is within one of the distance bands defined in overset > distBandOrphBandLims. Additionally, all orphans with distances from their interpolations below or above the defined bands can be written to their own zones if overset > distBandOrphWriteAllLower or overset > distBandOrphWriteAllHigher are defined. Each Tecplot zone contains either the donor cells or the interpolation vectors for a specific band, and all zones have fields representing blockID, j, k, l, where jkl for donor cells pertains to the lower-left cell corner.
  • distBandOrphBandLims ([float, ...], default=[0.1000E-02, 0.1000E-01, 0.1000, 0.2000, 0.5000])

    • A value list which is used to band orphan data written to distBandedOrphanInfo.dat if overset > writeDistBandOrphData is true. Distance bands are defined between successive values, which must be positive and stricly increasing.
  • distBandOrphWriteAllHigher (boolean, default=True)

    • Writes all orphan data for orphans which have an interpolation distance above the highest band to a single Tecplot zone pair inside distBandedOrphanInfo.dat if overset > writeDistBandOrphData is defined as true.
  • distBandOrphWriteAllLower (boolean, default=False)

    • Writes all orphan data for orphans which have an interpolation distance below the lowest band to a single tecplot zone pair inside distBandedOrphanInfo.dat if overset > writeDistBandOrphData is defined as true.
    • WARNING: In the presence of many orphans, most of them may be banded here and could cause Tecplot to become slow.
  • zoneSpecific

    • Entries in zoneSpecific will allow individual treatment of zones (overset optimization priority, etc.) and is the easiest way to fix issues with grid quality.
    • zones ([string, ...], default=[""])

      • List of zones to have values specifically set for.
    • explicitJKL ([integer , integer , integer , integer , integer , integer], default=0)

      • Refer to overset > explicitJKL above.
    • curvatureFactor (float, default=1.000)

      • Refer to overset > curvatureFactor above.
    • edgeFactor (float, default=0.1000)

      • Refer to overset > edgeFactor above.
    • octTreeMinDepth (integer, default=11)

      • Refer to overset > octTreeMinDepth above.
    • octTreeMaxDepth (integer, default=15)

      • Refer to overset > octTreeMaxDepth above.
    • octTreeCubesPerEdge (float, default=2.000)

      • Refer to overset > octTreeCubesPerEdge above.
    • priority (float, default=1.000)

      • The higher this value, the better the stencil 'quality' of the zone is artifically increased, which makes it more likely to be retained during overlap optimization.
    • explicitSurface (integer, default=0)

      • Refer to overset > explicitSurface above.
  • explicitBlanking

    • Entries here will explicitly blank zone nodes within geometric shapes defined either by triangulations or simple polygons.
    • type (string, required)

      • Accepted Values: ["box", "cone", "sphere", "surfile", "jkl", "clip"]
      • The type of EHC shapes. All defined EHC options will cut both surface and volume, and are applied prior to IHC or optimization.
      • A) Geometric-type EHC options available:
      • box
        • A box that is specified using xMin and xMax coordinates.
      • cone
        • A cone that is specified using start and end coordinates/radii xMin/rMin and xMax/rMax.
      • sphere
        • A sphere that is specified using centroid xMin and radius rMin.
      • All geometric-type EHC options may be rotated about the Cartesian axes using the rotationAngle entry.
      • B) File-type EHC options available:
      • surFile
        • A closed surface triangulation can be specified using the fileName and fileType options.
      • C) Grid-type EHC options available:
      • jkl
        • A [j,k,l] range may be specified using xMin and xMax integer (computational) coordinates.
      • D) Clipping-type EHC options available:
      • clip
        • A clipping plane can be specified using the operator option, paired with the value + variable, origin + normal, or origin + axis1Pt + axis2Pt options.
      • Clipping lenience is set by the offset value. If no zones are provided, then this EHC will become a true clipping plane, i.e., it will limit the sizing of the connectivity octree.
    • zones ([string, ...], default=[""])

      • List of zones to blank with this EHC object. If this is ommited then all grids will be used.
    • paintSource (boolean, default=False)

      • Defines if the explicit hole cutter will generate sources for the surface-blanking painting routine. If this is True, then the cutter will only cut the surface, NOT the volume, and all surface faces cut will be marked to initiate the flooding routines. This option should only be used for connectivity hot-fixes.
    • xMin ([float , float , float], default=[0.000, 0.000, 0.000])

      • First point supplied to a geometric EHC object:
        • A) The lower jkl curvilinear grid index set.
        • B) The lower left corner of a box.
        • C) The starting point of a cone.
        • D) The centroid of a sphere.
    • xMax ([float , float , float], default=[1.000, 1.000, 1.000])

      • Second point supplied to a geometric EHC object:
        • A) The upper jkl curvilinear grid index set.
        • B) The upper right corner of a box.
        • C) The ending point of a cone.
    • rotationAngle ([float , float , float], default=[0.000, 0.000, 0.000])

      • Defines axis rotation [xrot, yrot, zrot] for geometric EHC objects (box, cone, sphere) around the barycenter.
    • radius ([float, ...], default=[1.000, 1.000])

      • Radii at xMin and xMax when EHC type is cone or radius at xMin when EHC type is sphere.
    • radiusInner ([float, ...], default=[1.000, 1.000])

      • Format is [xMin, xMax]. Inner tube radii at xMin and xMax when EHC type is cone, or inner radius of shell at xMin when EHC type is sphere.
    • nFacet (integer, default=16)

      • Number of facets on EHC regions defined by curved geometric shapes [cone, sphere].
    • fileName (string(fileName), default="file")

      • Filename for the closed EHC surface. Chosen over overset > explicitBlanking > fileNames.
    • fileNames ([string, ...], default=["file"])

      • Filenames list for the closed EHC surface. Must be same fileType.
    • fileType (string, default="tecplot")

      • Accepted Values: ["tri", "plot3d", "tecplot"]
      • Filetype of the closed EHC surface.
      • tri
      • Plot3D
      • Tecplot
        • Tecplot PLT binary format file.
    • offset ([float, ...], default=[0.1000E-11])

      • The offset distance from the EHC geometry within which nodes of the defined zones will also be blanked. This can be a list of offsets for each zone.
    • operator (string, default="<")

      • Accepted Values: ["<", ">"]
      • The direction applied to a clip EHC type.
      • <
        • Values for which variable is below the value specified are clipped.
      • >
        • Values for which variable is above the value specified are clipped.
    • variable (string, default="y")

      • Accepted Values: ["x", "y", "z"]
      • The X, Y or Z value for plane of clip EHC type. Must also supply value.
      • x
        • Clip using a constant-X plane.
      • y
        • Clip using a constant-Y plane.
      • z
        • Clip using a constant-Z plane.
    • value (float, default=0.000)

      • An X, Y or Z value for plane of clip EHC type. Must also supply variable.
    • origin ([float , float , float], default=[0.000, 0.000, 0.000])

      • The origin of the clip EHC type. Must also supply normal or axis1Pt + axis2Pt.
    • normal ([float , float , float], default=[0.000, 0.000, 0.000])

      • The normal of the clip EHC type. Must also supply origin.
    • axis1Pt ([float , float , float], default=[0.000, 0.000, 0.000])

      • The local x axis of the clip EHC plane from the origin. Must also supply origin + axis2Pt.
    • axis2Pt ([float , float , float], default=[0.000, 0.000, 0.000])

      • The local y axis of the clip EHC plane from the origin. Must also supply origin + axis1Pt.

Reference Conditions

  • This section defines parameters related to the freestream reference conditions.

referenceConditions:
  pressure: <required>
  temperature: <required>
  umag: <required>
  alpha: <required>
  beta:
  qref:
  cp:
  gamma:
  SLConst:
  SLRef:
  prandtl:
  area:
  length:
  span:
  momentCenter:
  turvarfac:
  turvarfac_k:
  turvarfac_w:
  tu:
  hrms:
  additionalNormalizations:
    -
      names:
      area:
      length:
      momentCenter:
  • pressure (float, required, lower bound=0.000, mutable)

    • The reference pressure of the fluid in Pascal.
  • temperature (float, required, lower bound=0.000, mutable)

    • The static temperature of the freestream in Kelvin.
  • umag (float, required, mutable)

    • The magnitude of the freestream velocity in meters per second
  • alpha (float, required, mutable)

    • The angle of attack of the freestream condition relative to the body frame of the geometry. This assumes a standard orientation of 'span in y'.
  • beta (float, default=0.000)

    • The side-slip angle of the freestream condition relative to the body frame of the geometry. This assumes a standard orientation of 'span in y'.
  • qref (float, mutable, default=-1.000)

    • Overides the dynamic pressure from \(\rho_{ref} U_{ref}^2\), only for load normalization. Used for hovering cases when freestream velocity is zero and \(Q_{ref}\) should use tip velocity.
  • cp (float, mutable, default=1005.)

    • Specific heat at constant pressure of the working fluid in Joule per kilogram. Default corresponds to air.
  • gamma (float, mutable, default=1.400)

    • Ratio of specific heats. Default corresponds to air.
  • SLConst (float, mutable, default=0.1450E-05)

    • Constant used in Sutherland's Law for computing viscosity. Default corresponds to air.
  • SLRef (float, mutable, default=110.0)

    • Reference temperature used in Sutherland's Law. Default corresponds to air.
  • prandtl (float, mutable, default=0.7200)

    • Prandtl number of the working fluid. Default corresponds to air.
  • area (float, lower bound=0.000, default=1.000)

    • Reference area used for normalization of aerodynamic coefficients.
  • length (float, lower bound=0.000, mutable, default=1.000)

    • Reference length used for normalization of aerodynamic moments. Also used in reference timescale estimates in some upwind/centered blending functions.
  • span (float, lower bound=0.000, mutable, default=1.000)

    • Reference length used for normalization of aerodynamic roll moments.
  • momentCenter ([float , float , float], mutable, default=[0.000, 0.000, 0.000])

    • Point from which to take the aerodynamic moments about.
  • turvarfac (float, mutable, default=3.000)

    • Used for SA turbulence model and should be set between 3-5 for fully turbulent simulations, 0.1 for free/fixed-transition simulations.
  • turvarfac_k (float, mutable, default=0.2250E-06)

    • Used for two equation turbulence models. Non-dimensional farfield or ambient turbulent kinetic energy (will be multiplied by \(U_{ref}^2\) within the code).
  • turvarfac_w (float, mutable, default=125.0)

    • Used for two equation turbulence models. Non-dimensional farfield or ambient specific turbulence dissipation rate (will be multiplied by \(U_{ref} / L_{ref}\) within the code).
  • tu (float, mutable, default=0.2400)

    • Freestream turbulence intensity (%) using the Langtry-Menter transition model.
  • hrms (float, mutable, default=0.1000E-05)

    • Used in Langtry-Menter transition model. Represents the surface roughness for the \(C_f\) correlations:
    • ~ 0.25e-6m > highly polished,
    • ~ 0.50e-6m > polished,
    • ~ 3.33e-6m > painted.
  • additionalNormalizations

    • This section may be used to set surface-specific reference length, area and moment center for user-specified surface families.
    • names ([string, ...], default=["default"])

      • Names specified here correspond to the boundary condition subsets specified in grid > curv > BCFile for which to apply the custom normalizations to.
    • area (float, default=1.000)

      • Refer to referenceConditions > area.
    • length (float, default=1.000)

      • Refer to referenceConditions > length.
    • momentCenter ([float , float , float], default=[0.000, 0.000, 0.000])

      • Refer to referenceConditions > momentCenter.

Curvilinear Solver

  • This section defines general parameters associated with the curvilinear flow solver.

curvSolver:
  equations: <required>
  tileSize:
  wallDistCorrectionOffset:
  overlapComm:
  matrixScheduling:
  task:
  verbose:
  echoRestart:
  integrationWeights:
  overwriteIntegrationWeights:
  integrationWeightsDir:
  USURPBoundaries:
  writeIBINDFile:
  writeIBGeomTecplot:
  initializeImmersedBoundaries:
  zoneOptions:
    -
      zones:
      file:
  B2BTol:
  userSharedObject:
  writeRecordMarkersInGrids:
  initializeBoundaryLayer:
  initializeBoundaryLayerHeight:
  outputDir:
  metricExchange:
  fixBadRecon:
  checkForPBS:
  PBSStopBuffer:
  iterFileName:
  autoLoadBalance:
  debugCommFileName:
  saveIBADTInMem:
  useGPU:
  streamDirection:
  groundDirection:
  exactSolutionErrorVariables:
  exactSolutionErrorExcludeBCNames:
  nImmersedWallOffsetPts:
  writeIBWallModelInterpNodes:
  writeProbeInterpNodes:
  configGPUWarningsAsErrors:
  integratePRef:
  • equations (string, required)

    • Accepted Values: ["rans", "euler", "laminar", "les"]
    • The type of equations to solve:
    • RANS
      • Reynolds-Averaged Navier-Stokes (RANS) or Hybrid RANS-LES.
    • Euler
      • Euler equations (ignores viscous flux evaluation and turbulence model).
    • Laminar
      • Navier-Stokes equations (ignores turbulence and/or SGS model).
    • LES
      • Large eddy simulation (LES).
  • tileSize ([integer , integer , integer], lower bound=4, default=18)

    • The size of the tiles, including one level of halos. The optimum tilesize is primarily a function of the computer architecture, not the grid. The default size should give near optimum performance on modern x86 architectures.
  • wallDistCorrectionOffset (float, lower bound=0.000, default=0.1000E-01)

    • This is the offset distance from wall boundaries within which a more accurate/corrective search is performed to account for geometric features such as overlap and ambiguously close surface proximity (for wall-normal calculations).
  • overlapComm (boolean, default=True)

    • Flag specifying if the code should overlap communication and computation. This should generally be set to true unless the effect of this option is to be investigated.
  • matrixScheduling (string, default="p2p")

    • Accepted Values: ["barrier", "p2p"]
    • The type of matrix scheduling to use.
    • p2p
      • Should always be used as it is faster.
    • barrier
      • Should only be used for comparison purposes.
  • task (string, default="solve")

    • Accepted Values: ["solve", "verify", "broyden", "mms", "connectivity", "writesolution", "adjoint", "panelweights", "writeibind", "verifybcgpu", "verifyresgpu", "verifysolvegpu", "writenamegrpbc"]
    • The main task to be performed by the solver:
    • solve
      • Solve the specified equations.
    • verify
      • Tests YAML inputs to ensure validity and formatting. It is recommended to run this task to verify input options prior to running the code.
    • Broyden
      • Solve the specified equations until the target values in the Broyden input section are satisfied.
    • MMS
      • Perform Method of Manufactored Solutions for solver verification
    • connectivity
      • Perform overset grid connectivity.
    • writeSolution
      • Read restart, init, or set freestream and write the requested restart, volume, surface, etc. output(s).
    • adjoint
      • Solve the adjoint equations.
    • panelWeights
      • Perform overlapper procedure to compute surface panel weights for surface integrations.
    • writeIBInd
      • If immersed boundaries are present, this task will write a file named IBIND containing information on which cells fall inside the immersed boundaries. This file can be provided in grid > curv > IBINDFile so that this tagging does not have to be regenerated.
    • verifyBCGPU: Compare the state vector of the CPU and GPU after applying boundary condition(s).
    • verifyResGPU
      • Compare the residual vector of the CPU and GPU.
    • verifySolveGPU
      • Compare the solution vector of the CPU and GPU after solving on each architecture separately.
    • writeNameGrpBC
      • Write boundary condition(s) to a Tecplot file and group them by name.
  • verbose (boolean, default=True)

    • Flag to request extra solver output.
  • echoRestart (boolean, default=True)

    • Replay monitor data to STDOUT on restart.
  • integrationWeights (string, default="overlapper")

    • Accepted Values: ["none", "usurp", "overlapper"]
    • The method used to integrate on viscous surfaces.
    • none
      • This should be used if the entire grid does not contain overlapping surfaces.
    • USURP
      • This makes a call to Penn State's polygonal clipping algorithm USURP which is available as part of Chimera Grid Tools (CGT). It is limited to having viscous surfaces defined on J = 1 or L = 1 surfaces.
    • overlapper
      • LAVA-internal tool which utilizes an internally developed polygonal clipping algorithm.
  • overwriteIntegrationWeights (boolean, default=False)

    • If false and the requested panel weights file already exists then panel weight generation will be skipped unless curvSolver > task is set to panelWeights.
  • integrationWeightsDir (string, default="")

    • The directory in which all integration weights files are placed. If curvSolver > integrationWeights is usurp, this defaults to usurp/, and likewise to overlapper/ for curvSolver > overlapper.
  • USURPBoundaries ([string, ...], default=[""])

    • Use this option when running curvSolver > integrationWeights: USURP to specify over which surfaces to perform integrations over. These names correspond to the subset names specified in the boundary condition file specified in grid > curv > BCFile.
  • writeIBINDFile (boolean, default=False)

    • If the IBIND file has not been provided in grid > curv > IBINDFile and this is true, write the IBIND file after immersed boundaries are assessed.
  • writeIBGeomTecplot (boolean, default=False)

    • Write a Tecplot file with all immersed geometry to immBndGeom.plt.
  • initializeImmersedBoundaries (boolean, default=False)

    • Initialize relevant fields to respect all immersed boundary targets (zero velocity, target temperature, etc).
  • zoneOptions

    • Use this section to apply options to select zones only.
    • zones ([string, ...], default=[""])

      • Zone number(s) to apply zone-based options to.
    • file (string, default="")

      • Name of YAML file containing specific options to use for specified zones.
  • B2BTol (float, lower bound=0.1000E-15, upper bound=1.000, default=0.1000E-09)

    • Block-to-block (B2B) face-center proximity tolerance.
  • userSharedObject (string, default="")

    • Path to shared object file which contains compiled user-provided subroutines. For example grid motion, source terms, etc.
  • writeRecordMarkersInGrids (boolean, default=True)

    • Used to control if record markers are written in the Plot3D grid file(s) output by the code after connectivity or during moving grid simulations.
  • initializeBoundaryLayer (string, default="none")

    • Accepted Values: ["none", "false", "true", "ramp", "zero"]
    • Used to initialize a simple boundary layer profile near no-slip walls. This may increase robustness for steady-state solves, but is typically not necessary.
    • none or false
      • Does not apply a boundary layer profile correction.
    • ramp or true
      • Applies a boundary layer profile near no-slip walls with a fall-off based on the wall-distance. The user can control the distance away from no-slip walls over which this correction is applied via the initializeBoundaryLayerHeight option.
    • zero
      • Zeroes out the velocity field near no-slip walls. The user can control the distance away from no-slip walls over which this correction is applied via the initializeBoundaryLayerHeight option.
  • initializeBoundaryLayerHeight (float, lower bound=0.000, default=0.1000)

    • Distance from no-slip walls to construct velocity profiles if curvSolver > initializeBoundaryLayer is set to ramp, true or zero.
  • outputDir (string, default="./")

    • Path to output directory for any output requested in the output section of the input file.
  • metricExchange (boolean, default=True)

    • Determines if metric terms are exchanged across B2B surfaces. This should only be set to false if using HWCNS schemes and negative volumes or Jacobians are reported.
  • fixBadRecon (boolean, default=False)

    • Performs a 1st order reconstruction of the left and right states when unphysical (non-positive) pressures and temperatures are reconstructed or interpolated to a mid-point.
  • checkForPBS (boolean, default=False)

    • Checks for a PBS job environment and outputs a restart file prior to the end of the job if the solver is still running.
  • PBSStopBuffer (float, default=180.0)

    • Time in seconds to reserve for the restart file output at the end of the PBS job when curvSolver > checkForPBS is set to true.
  • iterFileName (string, default="data.iter")

    • Filename for datafile containing solver history, integrated forces and moments, probe history, etc.
  • autoLoadBalance (boolean, default=False)

    • Utilizes a series of RHS calls to re-load balance based on timing differences. This should be set to true when performing explicit time-stepping.
  • debugCommFileName (string, default="")

    • Write a debug file to replicate the communication structure.
  • saveIBADTInMem (boolean, default=False)

    • Allows the entire source immersed boundary (IB) geometry set to be held in memory in the grid object. While this can be expensive, it may be desired if geometry is moving as re-computation of large IBs when wall distance is needed can prohibitively extend simulation time.
  • useGPU (boolean, default=False)

    • Controls if GPU kernels are utilized. Should be set to true if running on GPUs.
  • streamDirection (string, default="x")

    • Accepted Values: ["x", "y", "z"]
    • Main Cartesian coordinate for the direction of the flow. This is used for adjusting the flow based on angle of attack, and for computing the lift and drag coefficients.
    • x
      • Main flow direction along the X-axis (default).
    • y
      • Main flow direction along the Y-axis.
    • z
      • Main flow direction along the Z-axis.
  • groundDirection (string, mutable, default="z")

    • Accepted Values: ["x", "y", "z"]
    • Main Cartesian coordinate for the direction of the ground. This is used for adjusting the flow based on angle of attack, and for computing the lift and drag coefficients.
    • x
      • Ground direction along the X-axis.
    • y
      • Ground direction along the Y-axis.
    • z
      • Ground direction along the Z-axis (default).
  • exactSolutionErrorVariables ([string, ...], default=["pressure", "velocityX", "velocityY", "velocityZ", "temperature"])

    • Variables whose errors are evaluated with respect to a user-supplied dynamic link library (DLL) file defining the exact solution. \(L^{\infty}\), \(L^1\), and \(L^2\) error norms are evaluated for combined boundary and interior nodes, interior nodes alone, and boundary nodes alone. The default variables are the five primitive variables: [p, u, v, w, t].
  • exactSolutionErrorExcludeBCNames ([string, ...], default=[""])

    • Names of boundary condition(s) whose nodes will be excluded from the evaluation of errors with respect to a user-supplied dynamic link library (DLL) file defining the exact solution. For example, this option can be used to exclude the errors on symmetry plane boundaries when simulating a two-dimensional problem on a three-dimensional mesh, or to isolate the errors on a specific boundary or set of boundaries.
  • nImmersedWallOffsetPts (integer, default=0)

    • The number of sample/offset points from non-curvilinear-cartesian immersed walls for calculating wall models and shear stresses. Default is 0. Curv-Cart uses 2, but currently all our implemented non-Curv-Cart methods only use cell center and wall-model match-distance interpolation, meaning using anything greater than 0 of these points now is simply extra memory overhead. When other methods are added (e.g. IBBC), then this default can increase, or appropriate logic added.
  • writeIBWallModelInterpNodes (boolean, default=False)

    • Write the physical vectors from immersed boundary cell centers to their wall model offset and match location nodes. These are written to IBSurf_offsetPtVecs.dat and IBSurf_matchLocVecs.dat inside the curvSolver > integrationWeightsDir folder, respectively.
  • writeProbeInterpNodes (boolean, default=False)

    • Write the physical vectors from probe nodes to their wall model offset and match location nodes. These are written in probe_offsetPtVecs.dat and probe_matchLocVecs.dat within the curvSolver > integrationWeightsDir folder, respectively.
  • configGPUWarningsAsErrors (boolean, default=False)

    • While verifying the input YAML file, for bad GPU options raise an error instead of a warning and modifying.
  • integratePRef (boolean, default=True)

    • Option to include the reference pressure in the integration of the pressure over the surface. If true, then the pressure forces are integrated as \(\mathbf{F_p} = -(p_{ref} - p) \ \mathbf{n} \ dA\), where \(\mathbf{n}\) is the surface normal vector and \(dA\) is a surface area element). Otherwise, the pressure forces are integrated as \(\mathbf{F_p} = -p \ \mathbf{n} \ dA\). This may be useful when doing a drag breakdown as integrating \(-(p-p_{ref})\) on an open surface will lead to different results compared to integrating \(-p\) on the same surface.
    • NOTE: Integrating \(-(p-p_{ref})\) or \(-p\) over a closed surface will give back the same result.

Time Stepping

  • This section defines parameters related to the time discretization in the simulation.

timeStepping:
  steady: <required>
  timeSteps:
  dt:
  method:
  initializeAveraging:
  jacobianLag:
  gridMotion:
  explicitCFLLimit:
  conservativeInTime:
  timescaleCTU:
  constantStepExit:
  • steady (boolean, required)

    • Flag specifying if the simulation is steady or unsteady.
  • timeSteps (integer, lower bound=1, mutable, default=1000)

    • The number of timesteps to perform for an unsteady simulation. While this value has a default, it should be specified for unsteady simulations. Only used if steady is false.
  • dt (float, default=0.1000E-02)

    • The timestep to use for the unsteady simulation. For methods BDF1 and BDF2 this is the actual timestep. For the explicit schemes, this is the maximum timestep to use. Stability constraints may dictate a smaller timestep is actually used. This timestep will be used for I/O purposes using either implicit or explicit time-stepping.
  • method (string, default="bdf2")

    • Accepted Values: ["bdf1", "bdf2", "tvd_rk3", "rk4", "ssp_rk45", "rk1"]
    • The type of time marching scheme to use. Available are the following options:
    • BDF1
      • 1st order implicit backwards difference in time.
    • BDF2
      • 2nd order implicit backwards difference in time. Most common implicit scheme.
    • RK1
      • 1st order explicit Runge-Kutta scheme. Commonly known as explicit Euler.
    • TVD_RK3
      • 3rd order explicit Runge-Kutta scheme. Most common explicit scheme.
    • RK4
      • Classic 4th order Runge-Kutta (RK4) scheme.
    • SSP_RK45
      • Strong stability preserving Runge-Kutta scheme.
  • initializeAveraging (integer, mutable, default=1)

    • The timestep at which to start averaging output variables. The physical time at which this occurs is equal to timestep*dt.
  • jacobianLag (integer, lower bound=1, upper bound=50, default=1)

    • The number of timesteps over which to lag the recomputation of the flow Jacobian (aka LHS). This should not be changed unless it is known that the flow is not substantially changing from one timestep to the next. It should always be 1 for a moving grid simulation.
  • gridMotion (boolean, default=False)

    • Flag specifying if the grid is moving in time. Two types of grid motion are supported: a user-supplied dynamic link library (DLL) file describing the motion through a user.F90 routine or rigidly rotating blocks using the rotatingMesh input section. Only one type of motion may be used at a time.
  • explicitCFLLimit (float, lower bound=0.000, default=1.000)

    • Explicit CFL Limit for explicit time marching schemes. This will indirectly determine the maximum timestep in the explicit schemes.
  • conservativeInTime (boolean, default=False)

    • Flag specifying that the grid that is moving in time should use a temporal discretization that is strongly conservative in time. This option is only relevant when the grid is moving in time.
  • timescaleCTU (float, default=0.000)

    • Timescale to use for the monitoring of 'convective time units' (CTUs) for an unsteady flow solve. If a timescale is not provided, the reference length and reference velocity magnitude are used to compute a timescale.
  • constantStepExit (boolean, default=False)

    • Flag specifying that the time loop for Runge-Kutta methods should be exited based on the number of constant timesteps as opposed to the number of timesteps. Setting this option to true ensures that the final numerical solution corresponds to a final time equal to the number of specified timesteps multiplied by the specified fixed timestep. This is useful for evaluating errors with respect to an exact solution at a specific final time.

Nonlinear Solver

  • This section defines parameters related to the nonlinear solver used in the code.

nonlinearSolver:
  method:
  kind:
  iterations:
  minIterations:
  L2Conv:
  jacobianLag:
  subIterTur:
  useScaledResiduals:
  CFLStart:
  CFLLimit:
  CFLLimitTur:
  CFLRamp:
  CFLStepTol:
  CFLLinItsTol:
  CFLFromFile:
  • method (string, default="implicit")

    • Accepted Values: ["implicit"]
    • The nonlinear solver method.
    • implicit
      • Use an implicit approach to solve the coupled system of governing equations.
  • kind (string, default="ank")

    • Accepted Values: ["ank", "nk"]
    • The kind of solver to use.
    • ANK
      • Approximate Newton-Krylov algorithm.
    • NK
      • Newton-Krylov algorithm. This option is experimental and may not work properly for all cases.
  • iterations (integer, lower bound=0, default=1000)

    • The maximum number of nonlinear iterations to perform. For steady simulations this is the total number of iterations to perform. For implicit unsteady simulations, it is the number of nonlinear iterations, or sub-iterations, to perform during each timestep.
  • minIterations (integer, lower bound=0, default=0)

    • Perform at least this fixed number of nonlinear iterations. This parameter is useful when using the Broyden solve option in curvSolver > task.
  • L2Conv (float, lower bound=0.1000E-15, upper bound=1.000, mutable, default=0.1000E-07)

    • The required convergence for the nonlinear solver. This is relative to the initial residual.
  • jacobianLag (integer, lower bound=1, upper bound=50, default=5)

    • The number of nonlinear iterations over which to lag the recomputation of the jacobian, or LHS. Typical values are between 5 and 10.
  • subIterTur (integer, lower bound=1, upper bound=50, default=1)

    • The number of nonlinear iterations over which to sub-iterate the turbulence model for each flow solve iteration. Typical values are between 1 and 5.
  • useScaledResiduals (boolean, default=True)

    • Use volume weighted residuals to determine convergence. This should generally be true for steady simulations and false for unsteady simulations.
  • CFLStart (float, lower bound=0.000, mutable, default=10.00)

    • The starting CFL for the flow simulation. Both the flow and turbulence (if applicable) start at this CFL.
  • CFLLimit (float, lower bound=0.000, default=0.1000E+05)

    • The maximum CFL limit to use for the flow equations.
  • CFLLimitTur (float, mutable, default=-1.000)

    • The maximum CFL limit to use for the turbulence model. If this value is less than 0.0, it uses the nonlinearSolver > CFLLimit value.
  • CFLRamp (float, default=1.250)

    • The factor used to ramp the CFL when there are good solution updates.
  • CFLStepTol (float, mutable, default=0.5000E-01)

    • The factor used for judging acceptable update sizes. The CFL is reduced if the step size is below this factor.
  • CFLLinItsTol (float, mutable, default=0.9000)

    • The average linear iteration tolerance, relative to the Krylov subspace size, used to control CFL ramping.
  • CFLFromFile (boolean, default=False)

    • Use CFL from input YAML file instead of restart file.

Linear Solver

  • This section defines parameters related to the linear solver used in the code.

linearSolver:
  method:
  tolerance:
  maxTolerance:
  failureTolerance:
  subSpaceSize:
  matFree:
  HOSwitchTol:
  approxViscFluxes:
  useLHSBlending:
  monitor:
  lineSearch:
  adJacobian:
  • method (string, default="gmres")

    • Accepted Values: ["gmres", "richardson"]
    • The linear solver method.
    • GMRES
      • Generalized minimal residual (GMRES) method.
    • Richardson
      • Richardson method. Not to be used in practice.
  • tolerance (float, lower bound=0.1000E-15, upper bound=0.9999, default=0.1000)

    • The target convergence tolerance for the linear solver.
  • maxTolerance (float, lower bound=0.1000E-14, default=0.5000)

    • The maximum linear convergence tolerance which is acceptable before the CFL is reduced.
  • failureTolerance (float, lower bound=0.000, upper bound=1.000, mutable, default=0.8000)

    • The maximum linear convergence tolerance which is considered a failure. A CFL reduction is executed and no step is taken.
  • subSpaceSize (integer, lower bound=1, default=40)

    • The maximum number of Krylov vectors to use for GMRES. This also sets the maximum number of linear iterations to perform.
  • matFree (boolean, default=True)

    • Flag controling the use of the matrix-free method for doing matrix-vector products within the GMRES algorithm. This is usually desirable for steady simulations as it allows for effectively higher-order left-hand operator to be used. If the convergence is failing switch to false. If running unsteady also set to false.
  • HOSwitchTol (float, lower bound=0.1000E-15, default=0.1000E-03)

    • The convergence ratio relative to freestream residual at which to activate the higher order left-hand side. Only meaningful if linearSolver > matFree is true.
  • approxViscFluxes (boolean, default=False)

    • Flag specifying if 1st order approximate viscous fluxes are used for the LHS. Only meaningful if linearSolver > matFree is true. This makes the matrix-free LHS closer to the matrix-based LHS which always uses approximate viscous fluxes.
  • useLHSBlending (boolean, default=False)

    • Flag specifying if blending is to be used for the LHS. Only meaningful if linearSolver > matFree is true. Should almost always be set to false.
  • monitor (boolean, default=False)

    • Display the convergence of the linear GMRES iterations in STDOUT.
  • lineSearch (boolean, default=True)

    • Whether to use a linear search for residual reduction. It is highly recommended to use this option as it increases the solver robustness.
  • adJacobian (boolean, default=False)

    • Use analytical derivatives to form the explicit Jacobian. This is different from using the linearSolver > matFree approach, since analytical differentiations of the fluxes are used to form the Jacobian.
  • This section defines parameters associated with the Navier-Stokes equations and the numerical scheme utilized to solve them.

navierStokes:
  convective:
    type:
    dissipationType:
    riemannSolver:
    dis2:
    dis4:
    sigma:
    eigEps:
    dSwitch:
    symmetricMetricTerms:
    constantSource:
    sourceFile:
    schemeOrder:
    interpOrder:
    limiter:
    entropyfix:
    lowspeedPreCon:
    beta:
    interiorBlending:
    upwindSensor:
    fdBlendARCutOff:
    fdARCutOff:
    fdLTurbCutOff:
    ducrosMachCutOff:
    sensorCutOffForRoe:
    interiorZetaMin:
    interiorZetaMax:
    meshARCutOff:
    meshPSCutOff:
    meshSRCutOff:
    interiorZetaWS:
    interiorZetaUS:
    interiorZetaWM:
    interiorZetaPow:
    interiorZeta:
    fringeZeta:
    minWENO:
    useLimiter:
  turbulenceModel:
    type:
    useQCR:
    QCRVersion:
    useRC:
    useRC_TD:
    useFdExtraProtection:
    useSACC:
    useSAlowRe:
    useFT2:
    mode:
    gridLengthScale:
    LHSFacMode7:
    mode2_C1:
    RANS_InterfaceHeight:
    sgsmodel:
    csgs:
    komega_sust:
    komega_muRefFac:
    komega_prodLimFacExp:
    komega_prodLimFacImp:
    komega_CDkwmin:
    komega_a1:
    lin:
    turLimit_n:
    turLimit_p:
    prandtLTurb:
    smth:
    smthfac:
    sttsfac:
    locCFLMin:
    useTransCF:
    useTransCFdelay:
    useTransCFTol:
    useTransCFAlg:
    useTransCC:
    freezeQ:
    freezeT:
  • convective

    • type (string, default="upwind")

      • Accepted Values: ["upwind", "centeredq", "centeredw", "kep", "hwcns", "keep", "ranocha", "keeppe", "aec0", "aec1", "aec2", "keepg0", "keepg1", "keepg2"]
      • The type of convective flux.
      • upwind
        • Roe-like upwind scheme which can be used with or without low-Mach preconditioning activated. This is the default scheme and should be used for most RANS-based analysis.
      • centeredq
        • Central difference scheme with artifical dissipation based on the primitive variables \([p, u, v, w, T]\). Can be used with or without low-Mach preconditioning activated. Should have less artificial dissipation than the centeredw scheme in the boundary layer.
      • centeredw
        • Central difference scheme with artificial dissipation based on conserved variables \([\rho, \rho u, \rho v, \rho w, e]\).
      • KEP
      • HWCNS
        • Hybrid Weighted Compact Nonlinear Scheme (HWCNS) which uses a combination of mid-point fluxes based on Roe-like scheme and node fluxes to construct a high-order finite upwind difference stencil (up to 4th order implemented).
      • KEEP
      • ranocha
      • KEEPPE
        • Kinetic-energy-preserving and pressure-equilibrium-preserving flux of Shima et al. This flux is not entropy-consistent, but has favorable entropy-preserving behavior (although slightly worse entropy-preserving behavior compared to the KEEP scheme). Refer to 10.1016/j.jcp.2020.110060 .
      • AEC0, AEC1, AEC2
        • Kinetic-energy-preserving, asymptotically entropy-consistent, and pressure-equilibrium-preserving fluxes of De Michele and Coppola. The fluxes are based on the arithmetic mean for density and the harmonic mean for internal energy, which makes them cheaper than the entropy-consistent flux of Ranocha that uses the logarithmic mean. The numbers 0, 1, and 2 are related to the number of terms retained in the asymptotic expansions. Refer to 10.1016/j.jcp.2023.112439 .
      • KEEPG0, KEEPG1, KEEPG2
        • Kinetic-energy-preserving, asymptotically entropy-consistent, and pressure-equilibrium-preserving fluxes of Kawai and Kawai. The fluxes are based on the geometric mean for density and internal energy, which makes them cheaper than the entropy-consistent flux of Ranocha that uses the logarithmic mean, but slightly more expensive than the AEC fluxes since the geometric mean involves a square root. The numbers 0, 1, and 2 are related to the number of terms retained in the asymptotic expansions. Refer to 10.2514/6.2024-3788 .
    • dissipationType (string, default="jst")

      • Accepted Values: ["jst", "reconblend", "interpblend", "interpscale"]
      • The type of dissipation for the convective fluxes.
      • JST
        • Dissipation based on Jameson-Schmidt-Turkel scheme by by Jameson et al. Refer to 10.2514/6.1981-1259 .
      • reconBlend
        • Dissipation based on modified-Roe formulation with blending of reconstructed states using robustness sensors. Mimics the dissipation of the upwind scheme with the modifiedRoe option in navierStokes > convective > riemannSolver input.
      • interpBlend
        • Dissipation based on modified-Roe-HLL formulation with blending of interpolated states using robustness sensors. Mimics the dissipation of the upwind scheme with the modifiedRoeHLL option in navierStokes > convective > riemannSolver input.
      • interpScale
        • Dissipation based on modified-Roe-HLL formulation with scaling of entire artificial dissipation based on robustness sensors. Mimics the dissipation of the upwindHS scheme with the modifiedRoeHLL option in navierStokes > convective > riemannSolver input.
    • riemannSolver (string, default="modifiedroe")

      • Accepted Values: ["modifiedroe", "hll", "modifiedroehll", "none"]
      • Approximate Riemann solver used in the numerical flux for upwind and HWCNS-type schemes.
      • modifiedRoe
        • A Roe-like numerical flux with artificial dissipation applied to the primitive variables \([p, u, v, w, T]\).
      • HLL
        • A Harten, Lax, and van Leer like numerical flux with artificial dissipation applied to the primitive variables \([p, u, v, w, T]\).
      • modifiedRoeHLL
        • Combination of modifiedRoe and HLL numerical fluxes which are blended based on a shock sensor (refer to navierStokes > convective > dSwitch). This approximate Riemann solver should be used for high supersonic cases which contain bow shocks.
      • none
        • No approximate Riemann solver is used in the numerical flux.
    • dis2 (float, lower bound=0.000, upper bound=10.00, mutable, default=0.2500)

      • Second-difference dissipation coefficient used for JST type dissipation.
    • dis4 (float, lower bound=0.000, upper bound=10.00, mutable, default=0.2000E-01)

      • Fourth-difference dissipation coefficient used for JST type dissipation.
    • sigma (float, default=6.000)

      • Lumping coefficient for LHS operator used for JST type dissipation. Values between 4 and 6 are suggested.
    • eigEps (float, lower bound=0.000, upper bound=1.000, mutable, default=0.3000)

      • Constant used for eigenvalue scaling when using entropyfixii in navierStokes > convective > entropyFix.
    • dSwitch (float, lower bound=0.000, default=1.000)

      • Constant used for pressure-based shock sensor which is important when using the modifiedRoeHLL Riemann solver in navierStokes > convective > riemannSolver. Values between 0.001 and 0.1 are typically sufficient, with lower values identifying weaker gradients as shocks.
    • symmetricMetricTerms (boolean, default=True)

      • Utilize symmetric metric terms for the HWCNS type flux.
    • constantSource ([float , float , float , float , float], default=[0.000, 0.000, 0.000, 0.000, 0.000])

      • Constant source term to run channel flow or other applications which require a user-imposed source.
    • sourceFile (string(fileName), default="")

      • Filename containing a spatially varying source term, often used for MMS.
    • schemeOrder (integer, default=2)

      • Order of the finite-difference operator used for convective flux discretization. schemeOrder 2 and 4 are acceptable for the HWCNS and KEEP family of schemes. All other types assume a schemeOrder of 2.
    • interpOrder (integer, lower bound=1, upper bound=4, default=3)

      • Order of the interpolation/reconstruction used for the left/right state interpolations/reconstructions input to the approximate Riemann solver. Values of 1, 2, 3, and 4 are accepted where odd numbers are upwind biased and even numbers are centered.
    • limiter (string, default="koren")

      • Accepted Values: ["vanalbada", "vanleer", "koren", "none", "minmod", "weno", "wenoshkfr", "unstmuscl"]
      • Slope limiter option for left/right state interpolation/reconstruction.
      • vanAlbada
        • The van Albada slope limiter can be used with the upwind modifiedRoe, HLL, and modifiedRoeHLL Riemann solvers.
      • vanLeer
        • The van Leer slope limiter can be used with the upwind modifiedRoe, HLL, and modifiedRoeHLL Riemann solvers.
      • koren
        • The Koren slope limiter can be used with the upwind modifiedRoe, HLL, and modifiedRoeHLL Riemann solvers
      • minmod
        • The minmod slope limiter can be used with the upwind modifiedRoe, HLL, and modifiedRoeHLL Riemann solvers.
      • WENO
        • The Weighted Essentially Non-Oscillatory (WENO) interpolation can be used with the HWCNS flux.
      • WENOShkFr
        • The Weighted Essentially Non-Oscillatory (WENO) interpolation combined with local shock detection can be used with the HWCNS flux.
    • entropyfix (string, default="entropyfixi")

      • Accepted Values: ["entropyfixi", "entropyfixii", "none"]
      • Entropy fix used for modifiedRoe and modifiedRoeHLL approximate Riemann solvers.
      • entropyFixI
        • Standard entropy fix for Roe-type schemes.
      • entropyFixII
        • Gnoffo strong entropy fix. Can be overly dissipative.
    • lowspeedPreCon (string, mutable, default="none")

      • Accepted Values: ["localinviscidvelocity", "constantbeta", "none"]
      • Low-speed preconditioning. This should be activated when the freestream Mach number becomes less than 0.1.
      • localInviscidVelocity
        • Uses the local velocity magnitude to determine the artificial sound speed.
      • constantBeta
        • Uses a constant to set the artificial sound speed.
      • none
        • Do not use low-speed preconditioning.
    • beta (float, lower bound=0.1000, default=1.000)

      • Constant used in low-speed preconditioning for either localInviscidVelocity or constantBeta preconditioning. For localInviscidVelocity this acts as the minimum local velocity. This should be between \(10 U_{ref}\) and \(100 U_{ref}\) and affects both the steady-state convergence rate as well the amount of local artificial dissipation.
    • interiorBlending (string, default="none")

      • Accepted Values: ["fixed", "localmach", "fd", "ducros", "ducrosstab", "fdshock", "shockint", "ducrosmach", "none", "wigglestab"]
      • Upwind/centered blending function used to reduce local dissipation.
      • none
        • No upwind/centered blending (default).
      • fixed
        • Uses a fixed amount of upwind dissipation throughout the zone/domain.
      • localMach
        • Uses the local Mach number to determine the amount of upwinding. If the local Mach is greater than or equal to 1 then full upwinding is used.
      • fd
        • Uses the shielding function along with a wiggle sensor and the navierStokes > convective > upwindSensor input to determine amount of local upwinding. If fd < 0.8 (RANS mode), full upwinding is used.
      • wiggleStab
        • Uses a combination of the wiggle sensor of Mary and Sagaut (refer to 10.2514/2.1763), and navierStokes > convective > upwindSensor into the upwind/centered blending of velocity.
    • upwindSensor (string, lower bound=0, upper bound=4, mutable, default="vorticitydilatation")

      • Accepted Values: ["vorticitydilatation", "vorticitystrainrate", "lowspeedsensor", "hrlessensor"]
      • The upwind sensor controls local amount of upwind dissipation used when blending is activated.
      • vorticityDilatation
        • Sensor based on the Ducros relation comparing vorticity magnitude and dilatation. Can be used with Hybrid RANS/LES (HRLES) or Wall-Modeled LES (WMLES).
      • lowSpeedSensor
        • Sensor based on vorticity magnitude and strain rate magnitude using the expression for \(g\) in Eq. (3) in Spalart et al. (refer to 10.2514/6.2012-1174). Can be used with unsteady RANS (URANS), HRLES, and WMLES.
      • vorticityStrainRate
        • Same as lowSpeedSensor but numerically more efficient using approximations. Can be used with URANS, HRLES, and WMLES.
      • hrlesSensor
        • Sensor based on the full expression, Eqs. (2)-(3) in Spalart et al. (refer to 10.2514/6.2012-1174). This sensor should only be used with HRLES.
    • fdBlendARCutOff (float, lower bound=0.1000E-05, default=0.1000E+07)

      • Deactivates the centered blending if the local aspect ratio of the mesh is larger than this value.
    • fdARCutOff (float, lower bound=0.1000E-05, default=0.1000E+07)

      • Activates RANS-mode shielding if the local aspect ratio of the mesh is larger than this value.
    • fdLTurbCutOff (float, lower bound=0.000, mutable, default=0.000)

      • Activates RANS-mode shielding if local turbulent length scale estimate is smaller than this value.
    • ducrosMachCutOff (float, lower bound=0.000, mutable, default=0.7000)

      • Scales local Mach test in when navierStokes > convective > interiorBlending is set to ducrosMach. Smaller value results in more centering.
    • sensorCutOffForRoe (float, lower bound=0.000, default=2.000)

      • Determines if modifiedRoe flux is used or HLL flux is used in HWCNS. If navierStokes > convective > upwindSensor is less than this value or if this value is larger than 1 the modifiedRoe flux is used, otherwise the HLL flux is used.
    • interiorZetaMin (float, lower bound=0.000, default=0.000)

      • Minimum blending coefficient allowed no matter which blending option is chosen, i.e. there will always be at least interiorZetaMin amount of upwinding in the interpolation/reconstruction of left/right states.
    • interiorZetaMax (float, lower bound=0.000, upper bound=1.000, mutable, default=1.000)

      • Maximum blending coefficient. This can be used to bound the total amount of upwinding, i.e. there will never be more than interiorZetaMax amount of upwinding in the interpolation/reconstruction of left/right states.
    • meshARCutOff (float, lower bound=1.000, mutable, default=100.0)

      • Not currently used, but can be used as a threshold for identifying regions where the local mesh aspect ratio is larger than the value specified.
    • meshPSCutOff (float, lower bound=0.5000, mutable, default=0.8500)

      • Not currently used, but can be used as a threshold for identifying regions where the local mesh planar skewness is larger than the value specified.
    • meshSRCutOff (float, lower bound=1.000, mutable, default=1.200)

      • Not currently used, but can be used as a threshold for identifying regions where the local mesh stretching ratio is larger than the value specified.
    • interiorZetaWS (float, lower bound=0.000, upper bound=1.000, mutable, default=0.000)

      • Utilizes a wiggle sensor to detect non-physical oscillations and incorporate interiorZetaWS amount of local upwinding. Typical values of 0.1 to 0.3 are used if activated.
    • interiorZetaUS (float, lower bound=0.000, upper bound=1.000, mutable, default=1.000)

      • Bounds the amount of upwinding used to interiorZetaUS if the upwind sensor returns a value larger than the value specified.
    • interiorZetaWM (float, lower bound=0.000, default=1.000)

      • Decrease the amount of upwinding to the value specified for nodes with a stencil that contains a wall-model node. This is only activated if the current amount of upwind blending is larger than this value, otherwise it is left unmodified.
    • interiorZetaPow (float, lower bound=1.000, default=4.000)

      • Power used in when navierStokes > convective > interiorBlending is set to wiggleStab. A larger power results in a sharper sensor and less dissipation (default is 4).
    • interiorZeta ([float , float , float , float , float], lower bound=0.000, upper bound=1.000, mutable, default=[1.000, 1.000, 1.000, 1.000, 1.000])

      • Initial blending values used before the selected blending procedure is applied. If fixed blending is used, then this vector will be used to blend upwind and centered interpolations/reconstructions for \([p, u, v, w, T]\).
    • fringeZeta ([float , float , float , float , float], lower bound=0.000, upper bound=1.000, mutable, default=[1.000, 1.000, 1.000, 1.000, 1.000])

      • Specify the amount of upwinding for nodes which contain a fringe (receiver) in their stencil.
    • minWENO ([float , float , float , float , float], lower bound=0.000, default=[0.000, 0.000, 0.000, 0.000, 0.000])

      • Used to reduce the amount of WENO interpolation, i.e. dissipation when using the wenoShkFr limiter. This overrides the shock sensor which means if the shock sensor detects a shock and wants to use full WENO, the minWENO overrides this behavior and uses minWENO amount of WENO and (1 - minWENO) amount of optimal weights in the left/right state interpolation.
    • useLimiter ([integer , integer , integer , integer , integer], lower bound=0, upper bound=1, mutable, default=0)

      • Utilized to set a minimum amount of upwinding for each individual primitive variable when utilizing either the ducrosStab or ducrosMach blending option in navierStokes > convective > interiorBlending.
  • turbulenceModel

    • This section is dedicated to the fine-tuning of turbulence model options and parameters.
    • type (string, default="sa")

      • Accepted Values: ["sa", "saorig", "komegasst", "komegabsl", "saslm2015"]
      • Turbulence model type.
      • SA
        • Negative form of the Spalart-Allmaras (SA) turbulence model.
      • SAOrig
        • Original Spalart-Allmaras (SA) turbulence model.
      • kOmegaSST
        • Menter Shear Stress Transport (SST) turbulence model.
      • kOmegaBSL
        • Menter Baseline (BSL) turbulence model.
      • SASLM2015
        • Smooth local correlation-based transition model for the Spalart-Allmaras turbulence model. Refer to 10.2514/1.J059784.
    • useQCR (boolean, default=True)

      • Flag to activate the Quadratic Constitutive Relation (QCR).
    • QCRVersion (string, default="qcr2000")

      • Accepted Values: ["qcr2000", "qcr2013", "qcr2013v", "qcr2020", "qcr2020s"]
      • Version options for QCR.
      • QCR2000
      • QCR2013
        • Additional normal stress term to account for turbulent kinetic energy. Refer to 10.2514/6.2013-860.
      • QCR2013V
        • Similar to QCR2013, but replaces the use of strain-rate magnitude with the anti-symmetric rotation sensor. Refer to 10.2514/6.2020-1304.
      • QCR2020
      • QCR2020S
        • Improved version of QCR but utilizing the strain-rate magnitude. Refer to 10.2514/1.J059683.
    • useRC (boolean, mutable, default=True)

      • Activate the Rotation/Curvature correction within the Spalart-Allmaras (SA) turbulence model (unsteady term neglected). Refer to 10.2514/2.1058.
    • useRC_TD (boolean, default=False)

      • Activates the unsteady time derivative term in the Rotation/Curvature correction within the Spalart-Allmaras (SA) turbulence model. Should be used for unsteady problems with navierStokes > turbulenceModel > useRC set to true when activated.
    • useFdExtraProtection (boolean, default=True)

      • Activates an extra protection based on estimated local length scales compared to the local grid spacing. This will result in staying in RANS mode for ZDES-Mode# HRLES models.
    • useSACC (boolean, default=False)

      • Activates the compressibility correction in the Spalart-Allmaras (SA) turbulence model. Refer to 10.2514/6.2000-2306.
    • useSAlowRe (boolean, mutable, default=False)

      • Activate the low Reynolds number correction in the Spalart-Allmaras (SA) turbulence model. Refer to 10.2514/1.J059489.
    • useFT2 (boolean, mutable, default=False)

      • Activates the \(f_{t2}\) term in the Spalart-Allmaras (SA) turbulence model which by default is deactivated.
    • mode (string, default="zdesmode0")

      • Accepted Values: ["zdesmode0", "zdesmode1", "zdesmode2", "zdesmode3", "zdesmode4", "zdesmode7"]
      • Zonal Detached Eddy Simulation (ZDES) mode.
      • ZDESMode0
        • RANS mode (default).
      • ZDESMode1
        • DES97 mode.
      • ZDESMode2
        • ZDES-Mode2 2012 mode (DDES).
      • ZDESMode3
        • ZDES-Mode3 (Wall-Modeled LES).
      • ZDESMode4
        • ZDES-Mode4 (LES).
      • ZDESMode7
        • ZDES Mode 2 (2020).
      • ZDESMode8
        • Reynolds Stress Contrained Eddy Simulation version 1. Currently under development, not ready for prime-time.
      • ZDESMode9
        • Reynolds Stress Contrained Eddy Simulation version 2. Currently under development, not ready for prime-time.
    • gridLengthScale (string, default="lenscalecubevol")

      • Accepted Values: ["lenscalemaxedge", "lenscalecubevol", "lenscaleomega"]
      • Local grid length scale used in HRLES models.
      • lenScaleMaxEdge
        • Maximum edge length attached to the node/vertex.
      • lenScaleCubeVol
        • Cube-root of the volume of the dual-cell associated with the node/vertex.
      • lenScaleOmega
        • Square-root of the dual cell area perpendicular to the local vorticity vector.
    • LHSFacMode7 (boolean, default=False)

      • Activates a scaling factor to control diagonal dominance of the LHS for ZDES Mode 2 (2020). This should be set to true if navierStokes > turbulenceModel > mode is set to zdesMode7.
    • mode2_C1 (float, lower bound=8.000, default=8.000)

      • Constant used in \(r_d\) part of shielding function for HRLES. This can be increased if shielding of the attached boundary layer is breaking down, i.e., going into LES mode and either the grid has insufficient resolution or the timestep is not sufficiently small.
    • RANS_InterfaceHeight (float, lower bound=0.000, default=0.000)

      • Fixed interface height for either RANS mode in zdesMode3 or Reynolds stress constraint height in zdesMode8 and zdesMode9.
    • sgsmodel (string, default="sigmasgs")

      • Accepted Values: ["sigmasgs", "vremansgs", "vremananisosgs", "amdsgs", "dynsmag"]
      • Sub-grid scale (SGS) turbulence model used in Large Eddy Simulation (LES).
      • sigmaSGS
        • Sigma SGS turbulence model. Use csgs \(\approx 1.35\).
      • vremanSGS
        • Vreman SGS turbulence model. Use csgs \(\approx 0.07\).
      • vremanAnisoSGS
        • Vreman anisotropic grid SGS turbulence model. Use csgs \(\approx 0.07\) (good for anisotropic meshes).
      • amdSGS
        • Anisotropic Minimum-Dissipation (AMD) SGS turbulence model. Use csgs \(\approx 0.3\) for 2nd order and 0.212 for 4th order numerical discretizations. Refer to 10.1063/1.4928700.
      • dynSmag
        • Dynamic Smagorinsky SGS turbulence model. csgs is not used.
    • csgs (float, default=1.350)

      • Constant used in sub-grid scale turbulence model for LES. Refer to description of SGS model to chose csgs value.
    • komega_sust (float, default=0.000)

      • Sustaining terms for \(k-\omega\) turbulence model. Should be set to one to force \(k\) and \(\omega\) to freestream, or zero otherwise.
    • komega_muRefFac (float, default=0.9000E-02)

      • Fraction of reference viscosity added to the turbulent eddy viscosity to avoid division by zero in \(k-\omega\) SST and BSL source terms.
    • komega_prodLimFacExp (float, default=20.00)

      • Production limiter constant used in RHS of \(k-\omega\) SST and BSL.
    • komega_prodLimFacImp (float, default=20.00)

      • Production limiter constant used in LHS of \(k-\omega\) SST and BLS.
    • komega_CDkwmin (float, default=0.1000E-19)

      • Minimum value of \(CD_{kw}\) in \(k-\omega\) SST and BSL.
    • komega_a1 (float, default=0.3100)

      • Constant used in turbulent eddy viscosity evaluation in \(k-\omega\) SST.
    • lin (string, default="full")

      • Accepted Values: ["full", "stts"]
      • Linearization flag for the turbulence model.
      • full
        • Full linearization.
      • STTS
        • Source-term time-stepping linearization used for the \(k-\omega\) SST and BSL turbulence models.
    • turLimit_n (float, mutable, default=0.1000)

      • Scale factor which controls how much a turbulence variable can change in the negative direction.
    • turLimit_p (float, mutable, default=0.6000)

      • Scale factor which controls how much a turbulence variable can change in the positive direction.
    • prandtLTurb (float, mutable, default=0.9000)

      • Turbulent Prandtl number.
    • smth (boolean, mutable, default=False)

      • Activate smoothing in the SASLM2015 turbulence transition model.
    • smthfac (float, default=300.0)

      • Smoothing factor used in the SASLM2015 turbulence transition model.
    • sttsfac (float, mutable, default=0.8000)

      • Scale factor used in source-term time-stepping method for \(k-\omega\) SST and BSL turbulence models.
    • locCFLMin (float, mutable, default=1.000)

      • Local CFL restriction for source-term time-stepping method for \(k-\omega\) SST and BSL turbulence models.
    • useTransCF (boolean, default=False)

      • Activate transition model crossflow correlations.
    • useTransCFdelay (boolean, mutable, default=False)

      • Delay the activation of the crossflow correlations until useTransCFTol is hit. This parameter is required for transonic simulations to prevent upstream transition front.
    • useTransCFTol (float, default=0.1000E-02)

      • Turbulence model residual convergence tolerance before activating the crossflow correlations in the SASLM2015 transition model.
    • useTransCFAlg (boolean, mutable, default=True)

      • Recommended to use algebraic formulation for the crossflow correlations \((F_\text{onset, scf})\).
    • useTransCC (boolean, mutable, default=False)

      • Compressibility correlations for the Tollmien-Schlichting and crossflow empirical correlations.
    • freezeQ (boolean, default=False)

      • Freezes the primitive variable updating. Can be used to debug turbulence model settings.
    • freezeT (boolean, mutable, default=False)

      • Freezes the turbulence model updating. Can be used to debug convective and viscous flux settings.

Preconditioner

  • This section defines parameters related to the linear solver preconditioner used in the code.

preconditioner:
  type:
  ILUFill:
  subIter:
  • type (string, default="ilu")

    • Accepted Values: ["ilu"]
    • The type of preconditioner to use.
    • ILU
      • Incomplete lower-upper (ILU) factorization.
  • ILUFill (integer, lower bound=0, upper bound=10, default=1)

    • The level of fill used for ILU. Higher levels of fill take more time to apply and use more memory, but it can result in lower number of linear iterations. The most common values are 0 and 1. Values of 0 are more often used for unsteady simulations.
  • subIter (integer, lower bound=1, upper bound=5, default=1)

    • The number of sub-iteration applications of preconditioner to perform. This option should be rarely changed. The only time this could be increased to 2 is if memory requirements dictate only a fill level of 0 can be used, but a stronger preconditioner is desired.

Boundary Conditions

  • This section specifies the association between named subsets from the grid > curv > BCFile to boundary conditions which should be applied/enforced on the specified boundaries.

BC:
  -
    type:
    names:
    location:
    projectNodes:
    symPlaneOrigin:
    symPlaneNormal:
    symPlaneAxis1:
    symPlaneAxis2:
    totalPressure:
    totalTemperature:
    inflowDir:
    density:
    pressure:
    mach:
    temperature:
    velocity:
    wallVelocity:
    wallModel:
    wallModelOrder:
    matchLoc:
    roughnessLength:
    robustOutflow:
    gridFile:
    qFile:
    useFreestream:
    reflectNormalVelocityAboutMidpoint:
    firstHaloExtrapolationOrder:
    secondHaloExtrapolationOrder:
    velocityExtrapolationOrder:
    pressureTreatment:
    temperatureTreatment:
  • type (string, default="bcfarfield")

    • Accepted Values: ["bcwallviscous", "bcwallviscousisothermal", "bcwallinviscid", "bcsymmetryplane", "bcfarfield", "bcinflowsubsonic", "bcoutflowsubsonic", "bctypeuserdefined", "bcextrapolate", "bcinflowsupersonic", "bcdirichlet", "userdefined", "bcdirichletriemann"]
    • Type of boundary condition to apply/enforce at the named BC subset.
    • BCWallViscous
      • No-slip adiabatic wall boundary condition.
    • BCWallViscousIsothermal
      • No-slip isothermal wall boundary. Requires the specification of a wall temperature.
    • BCWallInviscid
      • Slip-wall boundary condition.
    • BCSymmetryPlane
      • Symmetry plane boundary condition.
    • BCFarfield
      • Far-field Riemann invariants boundary condition.
    • BCInflowSubsonic
      • Subsonic inflow boundary condition. Requires the specification of one of the following variable combinations:
      • a) Velocity magnitude, temperature, and flow angle;
      • b) Total pressure, total temperature, and flow angle.
    • BCOutflowSubsonic
      • Subsonic outflow boundary condition. Requires the specification of pressure.
    • BCTypeUserDefined
      • User-supplied boundary condition. Requires the specification of a dynamic link library (DLL) file (refer to curvSolver > userSharedObject).
    • BCExtrapolate
      • Extrapolate all variables from interior. This can be used for supersonic outflows.
    • BCInflowSupersonic
      • Supersonic inflow boundary condition fixes the prescribed boundary values. Requires the specification of pressure, temperature, velocity magnitude, and flow angle.
    • BCDirichlet
      • Dirichlet-type boundary condition which fixes the boundary surface and the neighboring interior surface to pre-computed or set solution values.
    • BCDirichletRiemann
      • Dirichlet-Riemann boundary condition which resets the boundary surface and the neighboring interior surface to pre-computed or set solution values, and then applies the Riemann invariant boundary condition procedure first to the neighboring surface, and then to the boundary surface.
  • names ([string, ...], default=["default"])

    • Name of the subset specified in grid > curv > BCFile.
  • location (string, default="unknown")

    • Accepted Values: ["unknown", "onbody", "offbody"]
    • The location of the boundary condition. Specifying this option will overwrite all other assessments of this BC performed during connectivity.
    • unknown
      • Let the code assess whether the BC should be associated with the geometry or not (default).
    • onBody
      • The BC is on the considered geometry.
    • offbody
      • The BC is not associated with the geometry, and can be ignored during connectivity.
  • projectNodes (boolean, default=False)

    • If this BC is symmetry, this will project all nodes of a block face with this BC onto its symmetry plane using the normal and origin defined by the user, or at \(y=0\) if no symmetry plane definitions are provided.
  • symPlaneOrigin ([float , float , float], default=[0.000, 0.000, 0.000])

    • If this BC is symmetry, this helps to explicitly define the symmetry plane when provided alongside either symPlaneNormal, or both symPlaneAxis1 and symPlaneAxis2. The explicit definition will be used instead of block sides if projecting nodes. This argument defines the origin of the explicit symmetry plane definition.
  • symPlaneNormal ([float , float , float], default=[0.000, 0.000, 0.000])

    • If this BC is symmetry, this helps to explicitly define the symmetry plane along with symPlaneOrigin. This argument defines the normal of the explicit symmetry plane definition.
  • symPlaneAxis1 ([float , float , float], default=[0.000, 0.000, 0.000])

    • If this BC is symmetry, this helps to explicitly define the symmetry plane along with symPlaneOrigin. This argument defines the first axis (from the origin) of the explicit symmetry plane definition, and must be supplied together with symPlaneAxis2.
  • symPlaneAxis2 ([float , float , float], default=[0.000, 0.000, 0.000])

    • If this BC is symmetry, this helps to explicitly define the symmetry plane along with symPlaneOrigin. This argument defines the second axis (from the origin) of the explicit symmetry plane definition, and must be supplied together with symPlaneAxis1.
  • totalPressure (float, lower bound=0.000, default=1.000)

    • Total pressure (or stagnation pressure) used in subsonic inflow.
  • totalTemperature (float, lower bound=0.000, default=1.000)

    • Total temperature (or stagnation temperature) used in subsonic inflow.
  • inflowDir ([float , float , float], default=[1.000, 0.000, 0.000])

    • Inflow direction which should have a norm of one. This defines the velocity direction used in subsonic inflow.
  • density (float, lower bound=0.000, default=1.000)

    • Density which can be specified instead of temperature for a subsonic inflow boundary condition.
  • pressure (float, lower bound=0.000, default=1.000)

    • Specified static pressure for subsonic outflow.
  • mach (float, lower bound=0.000, default=0.5000)

    • Mach which can be specified instead of pressure for a subsonic outflow. Sometimes used in inlets for propulsion elements within a supersonic aircraft.
  • temperature (float, lower bound=0.000, default=1.000)

    • Specified temperature for subsonic inflow or isothermal wall boundary condition(s).
  • velocity (float, default=100.0)

    • Velocity magnitude used for subsonic inflows.
  • wallVelocity ([float , float , float], default=[0.000, 0.000, 0.000])

    • Specified velocity for a moving adiabatic wall.
  • wallModel (string, default="none")

    • Accepted Values: ["muskerslaw", "reichardtslaw", "nosliplaw", "roughwall", "roughwallrandom", "none", "blendedloglaw", "salaw"]
    • Wall model law.
    • muskersLaw
      • Follows fitting procedure of A.J. Musker (1979).
    • reichardtsLaw
      • Follows fitting procedure of H. Reichardt (1951).
    • noSlipLaw
      • Assumes resolution is sufficient to capture boundary layer.
    • roughWall
      • Includes surface roughness factors.
    • roughWallRandom
      • Randomizes the surface roughness. Only implemented for the Curvilinear-Cartesian immersed-boundary method.
    • blendedLogLaw
      • A fitting procedure that is computationally more efficient than muskersLaw and reichardtsLaw.
    • SALaw
      • A profile consistent with the SA turbulence model that can be used when performing WM-RANS using the SA turbulence model.
  • wallModelOrder (integer, lower bound=0, upper bound=2, default=1)

    • Method used for extrapolating data from the interior to the wall for a wall-modeled wall.
    • 1
      • Constant (zeroth-order polynomial) extrapolation of pressure, temperature, and tangential velocity yielding first-order truncation error. Most robust option. This is equivalent to setting the following options: firstHaloExtrapolationOrder to firstOrder, secondHaloExtrapolationOrder to firstOrder, velocityExtrapolationOrder to firstOrder, pressureTreatment to zeroGradientExtrapolation, and temperatureTreatment to zeroGradientExtrapolation.
    • 2
      • Constant (zeroth-order polynomial) extrapolation of pressure and temperature yielding first-order truncation error, and linear (first-order polynomial) extrapolation of tangential velocity, yielding second-order truncation error. This is equivalent to setting the following options: firstHaloExtrapolationOrder to firstOrder, secondHaloExtrapolationOrder to firstOrder, velocityExtrapolationOrder to secondOrder, pressureTreatment to zeroGradientExtrapolation, and temperatureTreatment to zeroGradientExtrapolation.
    • 0
      • Linear (first-order polynomial) extrapolation of pressure and temperature. The stencil uses BDF2 coefficients (4/3, -1/3) and seeks to enforce second-order truncation error in the normal pressure and temperature gradients, although the pressure and temperature values themselves are associated with first-order truncation error. Constant (zeroth-order polynomial) extrapolation is used for the tangential velocity, yielding first-order truncation error. This is equivalent to setting the following options: firstHaloExtrapolationOrder to secondOrder, secondHaloExtrapolationOrder to firstOrder, velocityExtrapolationOrder to firstOrder, pressureTreatment to zeroGradientExtrapolation, and temperatureTreatment to zeroGradientExtrapolation.
  • matchLoc (float, lower bound=1.000, upper bound=3.000, default=2.000)

    • This is the distance off the boundary used for wall model and viscous stress calculations, and should be set to integer values (e.g. 2). For body-fitted walls, the match location is placed that many cell layers off the wall. For sharp (i.e. Curv-Cart) immersed geometries, it will be scaled by the local Cartesian block cell size. For other general immersed approaches, it is a multiplicative factor of the immersedBoundary > interpOffsetDist value defined in the IB entry.
  • roughnessLength (float, lower bound=0.1000E-11, default=0.1000E-09)

    • Length of the roughness used in the rough wall wall-model.
  • robustOutflow (boolean, default=False)

    • This activates checking of the flow direction for the neighboring node to the boundary. If activated and the flow direction is not out of the domain, then perform a slip-wall procedure. This may need to be activated for propulsion inlets of supersonic aircraft if steady-state convergence is being slowed down by the use of the BCSubsonicOutflow boundary condition at the propulsion inlet.
  • gridFile (string(fileName), default="bc.x")

    • This is the name of the Plot3D grid file representing the boundary surface and its neighbor when using BCDirichlet or BCDirichletRiemann boundary condition(s).
  • qFile (string(fileName), default="bc.q")

    • This is the name of the Plot3D function file representing the solution on the boundary surface and its neighbor when using BCDirichlet or BCDirichletRiemann boundary condition(s).
  • useFreestream (boolean, default=False)

    • Allows the BCDirichlet or BCDirichletRiemann surface and neighbor nodes be set to freestream instead of reading a Plot3D function file.
  • reflectNormalVelocityAboutMidpoint (boolean, default=False)

    • Flag that reflects the normal velocity at the interior nodes near a wall-model wall about the first midpoint into the fluid off of the wall when populating the velocities in the halo nodes. This option only applies to BCWallViscous and BCWallViscousIsothermal walls when using a wall model. This option was introduced as a quick fix to run channel flow with WMLES and should be used with caution.
  • firstHaloExtrapolationOrder (string, default="firstorder")

    • Accepted Values: ["firstorder", "secondorder"]
    • Controls the order of accuracy of extrapolation to the first halo node coinciding with the domain boundary. Note: the order refers to truncation error, not the degree of the extrapolating polynomial. This option applies to the pressure and temperature at BCWallInviscid walls and BCWallViscous and BCWallViscousIsothermal walls when using a wall model, and the primitive variables \([p, u, v, w, T]\) at BCExtrapolate boundaries.
    • firstOrder
      • Constant (zeroth-order polynomial) extrapolation, yielding first-order truncation error.
    • secondOrder
      • Linear (first-order polynomial) extrapolation, yielding second-order truncation error. For BCWallInviscid walls and BCWallViscous and BCWallViscousIsothermal walls when using a wall model, the stencil uses BDF2 coefficients to compute the pressure (and/or temperature) in the first halo node, e.g., \(p_1 = \frac{4}{3} p_2 - \frac{1}{3} p_3\). This seeks to enforce second-order accuracy in the normal pressure gradient, although the first halo node value itself is only first-order accurate. For BCExtrapolate boundaries, standard linear extrapolation is used, yielding second-order truncation error, e.g., \(p_0 = 2 p_1 - p_2\).
  • secondHaloExtrapolationOrder (string, default="firstorder")

    • Accepted Values: ["firstorder", "secondorder"]
    • Controls the order of accuracy of extrapolation to the second halo node just beyond the domain boundary. Note: the order refers to truncation error, not the degree of the extrapolating polynomial. This option applies to the pressure and temperature at BCWallInviscid walls and BCWallViscous and BCWallViscousIsothermal walls when using a wall model, and the primitive variables \([p, u, v, w, T]\) at BCExtrapolate boundaries.
    • firstOrder
      • Constant (zeroth-order polynomial) extrapolation, yielding first-order truncation error, e.g., \(p_0 = p_1\).
    • secondOrder
      • Linear (first-order polynomial) extrapolation, yielding second-order truncation error, e.g., \(p_0 = 2 p_1 - p_2\).
  • velocityExtrapolationOrder (string, default="firstorder")

    • Accepted Values: ["firstorder", "secondorder"]
    • Controls the order of accuracy of extrapolation of velocity components \([u,v,w]\) to the first halo node coinciding with the domain boundary. Note: the order refers to truncation error, not the degree of the extrapolating polynomial. This option applies to BCWallInviscid walls and BCWallViscous and BCWallViscousIsothermal walls when using a wall model.
    • firstOrder
      • Constant (zeroth-order polynomial) extrapolation, yielding first-order truncation error, e.g., \(u_1 = u_2\).
    • secondOrder
      • Linear (first-order polynomial) extrapolation, yielding second-order truncation error, e.g., \(u_1 = 2 u_2 - u_3\).
  • pressureTreatment (string, default="zerogradientextrapolation")

    • Accepted Values: ["zerogradientextrapolation", "normalmomentum"]
    • Controls how pressure is set at boundary halo nodes. This option applies to BCWallInviscid walls and BCWallViscous and BCWallViscousIsothermal walls when using a wall model.
    • zeroGradientExtrapolation
      • Copies/extrapolates the interior pressure seeking to enforce zero normal gradient at the wall.
    • normalMomentum
      • Computes the boundary pressure by solving a discrete normal momentum relation. Refer to 10.2514/3.50745 for details regarding the normal momentum relation. This option is not currently supported with grid motion and has not been throughly tested with iblanks and special corners.
  • temperatureTreatment (string, default="zerogradientextrapolation")

    • Accepted Values: ["zerogradientextrapolation", "constantentropyextrapolation"]
    • Controls how temperature is set at boundary halo nodes. This option only applies to BCWallInviscid walls and BCWallViscous and BCWallViscousIsothermal walls when using a wall model.
    • zeroGradientExtrapolation
      • Copies/extrapolates the interior temperature seeking to enforce zero normal gradient at the wall.
    • constantEntropyExtrapolation
      • Copies the interior entropy from the first node off of the wall and recomputes temperature consistent with the boundary pressure using the equation of state.

Probes

  • This section is used to define user-requested data to be recorded at probe points and surfaces. The surfaces are general, so this could be a Plot3D volume grid file containing a volume of points to probe. Probe surface data can often be used for external purposes like acoustic propagation using Ffowcs Williams-Hawkings (FWH) or monitoring functionals like mass flow rate.

probes:
  point:
    -
      name: <required>
      variables: <required>
      position:
      fileName:
      sourceFileType:
      stationaryProbeInMovingMesh:
  surface:
    -
      sourceFileName: <required>
      location: <required>
      writeFrequency: <required>
      stationaryProbeInMovingMesh:
      bufferSize:
      sourceFileType:
      fileName:
      outFileType:
      name:
      integrationVars:
      variables:
      precision:
      outsideTreatment:
      offset:
      offsetUpdateFrequency:
      yPlusTarget:
      wallModel:
  • point

    • This sub-section is used to define point probes.
    • name (string, required)

      • Name associated with the probe point(s) for monitoring. Can be used with the output > monitor input section to get point probe data output.
    • variables ([string, ...], required)

      • Variables to report at the probe point(s). Refer to the list of available variables here.
      • NOTE: Certain variables may result in increased computational cost if probed at a high frequency. This is especially true for non-primitive variables computed from \([p, u, v, w, T]\). Make sure to consider how often any non-primitive variable needs probing.
    • position ([float , float , float], default=[0.000, 0.000, 0.000])

      • [X, Y, Z] position of point probe location.
    • fileName (string(fileName), default="")

      • Filename containing list of [X, Y, Z] positions of point probe locations.
    • sourceFileType (string, default="formatted")

      • Accepted Values: ["unformatted", "formatted"]
      • File type of the source point probe location.
      • unformatted
        • FORTRAN unformatted file.
      • formatted
        • ASCII formatted file.
    • stationaryProbeInMovingMesh (boolean, default=False)

      • This option accounts for the movement of the mesh relative to a stationary probe by recomputing the probe donors and interpolation weights when appropriate. This option should be set to true if the mesh is moving and should be set to false if it is known that the probe will always be located in a stationary portion of the mesh throughout the mesh movement.
  • surface

    • This sub-section is used to define surface probes.
    • sourceFileName (string, required)

      • File name of the source sampling probe surface.
    • location (string, required)

      • Accepted Values: ["vertex", "cellcentered"]
      • Location on the probe surface to interpolate data to.
      • vertex
        • Interpolate data to the surface nodes.
      • cellCentered
        • Interpolate data to the surface cell centers.
    • writeFrequency (integer, required, lower bound=-1)

      • Frequency in number of iterations for steady runs or timestep for unsteady runs at which to extract and write the probe data.
      • NOTE: The data may not be written to disk immediately depending on the bufferSize specified.
    • stationaryProbeInMovingMesh (boolean, default=False)

      • Refer to probes > point > stationaryProbeInMovingMesh above.
    • bufferSize (integer, lower bound=1, upper bound=10000, default=100)

      • Number of probe surface output files to store before writing to disk. It is highly encouraged to use a buffer size larger than 1 to increase performance since the write is MPI parallel.
      • WARNING: If the simulation stops before the data is written it is lost. Also, if the buffer size is too large, the user may run out of memory.
    • sourceFileType (string, default="tri")

      • Accepted Values: ["tri", "plot3d", "tecplot"]
      • File type of the source sampling probe surface.
      • tri
      • Plot3D
      • Tecplot
        • Tecplot PLT binary format file.
    • fileName (string, default="surfprobe")

      • Output file name prefix for sampled data.
    • outFileType (string, default="tri")

      • Accepted Values: ["tri", "plot3d", "tecplot", "triq", "sboom"]
      • Output file type for sampled data. Set to the same file type as in sourceFileType by default, as well as for Plot3D and Tecplot probes. For tri probes the user may choose Tecplot output (Plot3D output is the same as tri). The user may also choose to output as a triq file, which forces a specific choice of variables in the buffer to be accepted by triload. Refer to triload's documentation for more details.
      • tri
      • Plot3D
      • Tecplot
        • Tecplot PLT binary format file.
      • triq
      • SBOOM
        • Custom format required for input to the sonic boom propagation tool (sBOOM) developed at NASA Langley Research Center.
    • name (string, default="")

      • Name associated with the probe surface for monitoring and reporting functions like lift, mass flow rate, or average Mach.
    • integrationVars ([string, ...], default=["flow"])

      • Selects which variables to integrate on the probe.
      • flow
        • Activates mass flow rate, mass-averaged total pressure, mass-averaged total temperature, mass-averaged Mach, area, area-averaged total pressure, area-averaged total temperature, and area-averaged Mach.
      • aero
        • Aerodynamic forces and moments. Viscous contributions utilize a wall-model to compute skin friction on the surface.
      • aerop
        • Pressure-only aerodynamic forces and moments.
    • variables ([string, ...], default=["pressure", "velocityX", "velocityY", "velocityZ", "temperature"])

      • Surface probe variable(s) to be interpolated. Refer to the list of available variables here.
      • NOTE: Certain variables may result in increased computational cost if probed at a high frequency. This is especially true for non-primitive variables computed from \([p, u, v, w, T]\). Make sure to consider how often any non-primitive variable needs probing.
      • WARNING: Viscous surface-based average quantities, such as cfavg, ustaravg, yplusavg, are currently not available for surface probing.
    • precision (string, default="double")

      • Accepted Values: ["single", "double"]
      • Precision used in the output of the surface-sampled data.
      • single
        • Data is output in single-precision.
      • double
        • Data is output in double-precision.
    • outsideTreatment (string, default="zerovalue")

      • Accepted Values: ["zerovalue", "reference"]
      • Values to assign to interpolation point if interpolation stencil is not found.
      • zeroValue
        • Assigns values to be zero.
      • reference
        • Assigns values based on reference freestream conditions.
    • offset (float, default=0.2500E-03)

      • Offset distance to determine offset interpolation node locations. Used for \(\tau_{\text{wall}}\). The default value of 2.5e-4 [m] is what is required to obtain an average \(y^+\) value of about 51 for the probe surface for a flat plate test case.
    • offsetUpdateFrequency (integer, lower bound=-1, default=-1)

      • This sets the frequency at which to update the probe surface offset distance for wall model evaluation based on the target average \(y^+\) value. Default value is -1. If set to a negative number it will prevent offset distance updates.
    • yPlusTarget (float, lower bound=30.00, upper bound=100.0, default=55.00)

      • Average \(y^+\) value to target when updating probe surface offset distance for wall model evaluation. This value should be set such that the \(y^+\) values for the probe surface are within the log-layer. For this reason, 30 <= yPlusTarget <= 100, and its default value is 55.
    • wallModel (string, default="none")

      • Accepted Values: ["muskerslaw", "reichardtslaw", "nosliplaw", "roughwall", "roughwallrandom", "none", "blendedloglaw", "salaw"]
      • Possible wall model law for surface probe. Used for \(\tau_{\text{wall}}\). Refer to descriptions of wall model laws under BC > wallModel.

Output

  • This section is used to define the desired solution output parameters.

output:
  ioProcs:
  averageFrequency:
  restart:
    frequency:
    fileName:
    filesToKeep:
  volume:
    -
      frequency:
      fileName:
      fileType:
      precision:
      variables:
  surface:
    -
      frequency:
      fileName:
      fileType:
      BCTypes:
      names:
      variables:
      bufferSize:
  slice:
    -
      frequency:
      bufferSize:
      fileName:
      fileType:
      debug:
      variables:
      specs:
        -
          plane:
          values:
          range:
          origin:
          normal:
  isoSurface:
    -
      isoVariable: <required>
      isoValues: <required>
      frequency:
      bufferSize:
      fileName:
      fileType:
      debug:
      variables:
  monitor:
    precision:
    variables:
    frequency:
  adjoint:
    write:
    fileName:
    writeRHS:
    RHSFileName:
    writeResidual:
    residualFileName:
  surfGradient:
    -
      families: <required>
      fileName:
  • ioProcs (integer, lower bound=0, default=0)

    • Number of processors over which the volume solution is partitioned to perform MPI parallel solution output. When set to 0 (default) all processors running the simulation are utilized.
  • averageFrequency (integer, lower bound=1, upper bound=1000000000, default=1)

    • Frequency used to update the user-requested averaged variables. Default is 1 (every timestep) for implicit time-stepping. Consider increasing the frequency to 10 or 100 for explicit time-stepping.
  • restart

    • This sub-section covers the output of restart files.
    • frequency (integer, lower bound=-1, mutable, default=500)

      • Frequency used to write the restart file to disk in number of iterations (steady) or timesteps (unsteady).
    • fileName (string, mutable, default="restart")

      • File name prefix used for the restart file(s).
    • filesToKeep (integer, lower bound=0, upper bound=100, default=3)

      • Number of restart files to keep around. Since these can get large, only the latest filesToKeep number of restarts are retained on the disk, while the previous restarts (written during the current simulation) are deleted.
  • volume

    • This sub-section covers the output of volume files.
    • frequency (integer, lower bound=-1, mutable, default=0)

      • Frequency used to write the volume file(s) to disk in number of iterations (steady) or timesteps (unsteady).
    • fileName (string, mutable, default="volume")

      • File name prefix used for the volume output file(s).
    • fileType (string, mutable, default="default")

      • Accepted Values: ["plot3d", "plot3dsoln", "default"]
      • File type used in writing the volume solution.
      • Plot3D
        • Plot3D function file containing the user-requested volume solution variables. Refer to file formats page for details.
      • Plot3DSoln
        • Plot3D solution file which is restricted to 5 fields and includes a header containing the reference flow conditions. The five variables should be the conserved variables \([\rho, \rho u, \rho v, \rho w, e]\), but it is left to the user to set the variables as they may want dimensional or nondimensional conserved variables depending on the external program that is using the file. For example, triload and overint would typically be used with nondimensional conserved variables.
      • default
        • Use the input grid file type specified in grid > curv > fileType for the output file type.
    • precision (string, mutable, default="double")

      • Accepted Values: ["single", "double"]
      • Precision used in the output of the volume data.
      • single
        • Data is output in single-precision.
      • double
        • Data is output in double-precision.
    • variables ([string, ...], mutable, default=["pressure", "velocityX", "velocityY", "velocityZ", "temperature", "Mach"])

      • List of variables to include the volume output file. Refer to the list of available output variables here.
  • surface

    • This sub-section covers the output of surface files.
    • frequency (integer, lower bound=-1, mutable, default=0)

      • Frequency used to write the surface file(s) to disk in number of iterations (steady) or timesteps (unsteady).
    • fileName (string, mutable, default="surface")

      • File name prefix used for the surface output file(s).
    • fileType (string, mutable, default="default")

      • Accepted Values: ["plot3d", "turbo", "default"]
      • File type of the surface output file(s).
      • Plot3D
        • Plot3D function file containing the user-requested surface solution variables. Refer to file formats page for details.
      • turbo
        • Custom format used for coupling to the TURBO flow solver developed at NASA Glenn Research Center. Refer to 10.2514/6.2024-1195 for details.
      • default
        • Use the input grid file type specified in grid > curv > fileType for the output file type.
    • BCTypes ([string, ...], default=["bcwallviscous", "bcwallinviscid", "bcsymmetryplane"])

      • Accepted Values: ["bcwallviscous", "bcwallviscousisothermal", "bcwallinviscid", "bcsymmetryplane", "bcfarfield", "bcinflowsubsonic", "bcoutflowsubsonic", "bctypeuserdefined", "bcinflowsupersonic"]
      • Surface types to include in the surface output solution file(s) as defined by their boundary condition(s). These have a direct correspondence to the naming utilized in BC > type.
    • names ([string, ...], default=[""])

      • Names from the grid > curv > subsetFile to include in the surface output solution file(s).
    • variables ([string, ...], default=["pressure", "velocityX", "velocityY", "velocityZ", "temperature"])

      • List of variables to include in the surface output solution file(s). Refer to the list of available output variables here.
    • bufferSize (integer, lower bound=1, upper bound=10000, default=1)

      • Number of surface output solution file(s) to store before writing to disk. It is highly encouraged to use a buffer size larger than 1 to increase performance since the write is MPI parallel.
      • WARNING: If the simulation stops before the data is written it is lost. Also, if the buffer size is too large, the user may run out of memory.
  • slice

    • This sub-section covers the output of solution slices.
    • frequency (integer, lower bound=-1, default=0)

      • Frequency used to write slice file(s) to disk in number of iterations (steady) or timesteps (unsteady).
    • bufferSize (integer, lower bound=1, upper bound=10000, default=1)

      • Number of slice output solution file(s) to store before writing to disk. It is highly encouraged to use a buffer size larger than 1 to increase performance since the write is MPI parallel.
      • WARNING: If the simulation stops before the data is written it is lost. Also, if the buffer size is too large, the user may run out of memory.
    • fileName (string, mutable, default="slice")

      • File name prefix used for the slice output file(s).
    • fileType (string, default="tecplot")

      • Accepted Values: ["tecplot"]
      • File type used for the slice output file(s).
      • tecplot
        • Tecplot PLT binary format file.
    • debug (boolean, default=False)

      • Debug flag used to get minimal verbose information during runtime related to slicing algorithm.
    • variables ([string, ...], default=["pressure", "velocityX", "velocityY", "velocityZ", "temperature"])

      • List of variables to be sampled at (interpolated onto) the slice triangulation nodes. Refer to the list of available output variables here.
    • specs

      • Specify different slice definitions in this sub-section.
      • plane (string, default="y")

        • Accepted Values: ["x", "y", "z", "general"]
        • Slice cut plane.
        • x, y, z
          • Slice the volume solution at a constant X, Y or Z plane. The user must also provide a list of values or a range defining the slice.
        • general
          • Slice the volume solution along a general plane. User must also provide origin and normal for each slice specification.
      • values ([float, ...], default=[0.000])

        • List of values defining the constant coordinate(s) (x, y or 'z') to take the slice at. Cannot be used when range is provided.
      • range ([float , float , float], default=[0.000, 1.000, 2.000])

        • Take slices using a range. The first number is the start value, the second number is the end value, and third number corresponds to the number of slices between the start and end values (slices are equally spaced in the range provided). Cannot be used when values is provided.
      • origin ([float , float , float], default=[0.000, 0.000, 0.000])

        • The [X, Y, Z] location corresponding to the origin of the slice when using plane: general. User must also supply normal.
      • normal ([float , float , float], default=[0.000, 0.000, 0.000])

        • The [X, Y, Z] defining the vector normal to the slicing plane when using plane: general. User must also supply origin.
  • isoSurface

    • This sub-section covers the output of solution iso-surfaces.
    • isoVariable (string, required, mutable)

      • Variable that will be probed to define the iso-surface geometry. The geometry is defined by the isoValues of the variable specified here. Refer to the list of available variables here.
    • isoValues ([float, ...], required, mutable)

      • List of value(s) used to define the iso-surface(s) from the volume solution.
    • frequency (integer, lower bound=-1, mutable, default=0)

      • Frequency used to write iso-surface file(s) to disk in number of iterations (steady) or timesteps (unsteady).
    • bufferSize (integer, lower bound=1, upper bound=10000, default=1)

      • Number of iso-surface output solution file(s) to store before writing to disk. It is highly encouraged to use a buffer size larger than 1 to increase performance since the write is MPI parallel.
      • WARNING: If the simulation stops before the data is written it is lost. Also, if the buffer size is too large, the user may run out of memory.
    • fileName (string, mutable, default="isosurface")

      • File name prefix used for the iso-surface output file(s).
    • fileType (string, default="tecplot")

      • Accepted Values: ["tecplot"]
      • File type used for the iso-surface output file(s).
      • tecplot
        • Tecplot PLT binary format file.
    • debug (boolean, default=False)

      • Debug flag used to get minimal verbose information during runtime related to iso-surfacing algorithm.
    • variables ([string, ...], default=["pressure", "velocityX", "velocityY", "velocityZ", "temperature"])

      • List of variables to be sampled at (interpolated onto) the iso-surface(s) triangulation nodes. Refer to the list of available variables here.
  • monitor

    • This sub-section covers the monitoring and reporting of user-defined solution functionals to STDOUT.
    • precision (integer, lower bound=4, upper bound=18, mutable, default=7)

      • Precision (number of digits) used when writing to STDOUT for the monitored variables.
    • variables ([string, ...], mutable, default=["cl", "cd", "cmy"])

      • List of solution functionals to monitor in STDOUT. This list accepts a vast amount of functionals that are defined depending on other user-provided inputs to the code.
      • Some typical examples that are always available are minpressure, mintemperature, maxmach, etc., which allow for monitoring of min/max primitive variables as the solution progresses to quickly detect suspect flow solves.
      • Functionals that depend on user-defined surface integrations are also available. These are automatically defined based on the boundary condition specifications provided by the user. Dimensional force/moment functionals (fx, fy, my) as well as non-dimensional coefficients (cl, cd, cmy, cfx, cfy) may be requested. These functionals may also be appended with a boundary condition (BC) name (as defined in the grid > curv > BCFile to obtain the force/moment functional applied to that BC. For example, if two separate surface definitions are provided in the BCFile, with the names wing and fuselage, then functionals such as cl_wing, cd_wing, cl_fuselage, cd_fuselage are available.
      • This option may also be combined with point and surface probes (via probes > point and probes > surface). Variables may be monitored at point probes defined inside the computational domain by appending the name defined for the probe to the variable name. For example, if a point probe has been defined with probes > point > name: point_1, then variables such as pressure_point1 and mach_point1 are available. Surface probes may also be desirable for monitoring flow-rates or mass-averaged/area-averaged quantities across a flow section. If a surface probe has been defined with probes > surface > name: surf1, and probes > surface > integrationVars: flow, functionals such as the mass flow rate (mdot_surf1), mass-averaged total-pressure, total-temperature and Mach (mavgptot_surf1, mavgttot_surf1, mavgmach_surf1) and area-averaged total-pressure, total-temperature and Mach (aavgptot_surf1, aavgttot_surf1, aavgmach_surf1) are also available for monitoring.
    • frequency (integer, lower bound=1, default=1)

      • Frequency used to report the user-requested monitor variables STDOUT. Default is 1 for steady-state and implicit time-stepping. Consider increasing the frequency to 10 or 100 for explicit time-stepping.
  • adjoint

    • This sub-section covers the output of adjoint solution files.
    • write (boolean, mutable, default=False)

      • Flag used to specify whether to write the adjoint solution to a file.
    • fileName (string, mutable, default="adjoint.q")

      • Name of file containing the adjoint solution. It should contain the file extension.
    • writeRHS (boolean, mutable, default=False)

      • Flag used to specify whether to write the adjoint RHS \((\partial J / \partial Q)\) to a file.
    • RHSFileName (string, mutable, default="adjointRHS.q")

      • Name of file containing the adjoint RHS. It should contain the file extension.
    • writeResidual (boolean, mutable, default=False)

      • Flag used to specify whether to write the adjoint residual \((\partial J / \partial Q - \psi^T \partial R / \partial Q)\) to a file.
    • residualFileName (string, mutable, default="adjointRes.q")

      • Name of file containing the adjoint residual. It should contain the file extension.
  • surfGradient

    • Use this sub-section to define families of surface gradients to output.
    • families ([string, ...], required)

      • Name of surface families for surface gradient output.
    • fileName (string, default="surfGrad.plt")

      • Name of file containing the surface gradient. It should contain the file extension.

Overlapper

  • This section is used to define parameters associated with the integration of solution functionals over viscous surfaces.

overlapper:
  ignoreImmersedBoundaries:
  simpleIntersectionWeights:
  method:
  wallPriorityType:
  tolerance:
  offsetEpsPerc:
  projAngLim:
  coPlanarPreference:
  writeOctTrees:
  writeADTTrees:
  writeBlanking:
  writeIntersections:
  writeAllIntegratedGeom:
  writeZonesIntegratedGeom:
  debugWallBlkJKL:
  debugWallBlkBCCell:
  debugWallGlbCell:
  debugIBFileCell:
  debugIBSurfCell:
  debugIBGlbCell:
  debugVerbose:
  debugWriteWallBlankingFronts:
  debugWriteIBBlankingFronts:
  debugWriteIOUncertainNodes:
  debugWriteClipPoly:
  • ignoreImmersedBoundaries (boolean, default=False)

    • This is an option which will allow immersed boundaries to be ignored. This is currently implemented as a stop-gap to prevent errors while kinks in the isect processess are being finalized. Note that if this is True, but IB surfaces still exist, they will STILL be integrated over, but the panel weights will be assigned based on cell-center and offset interpolation validity instead of actual weights (i.e. exactly what probes do).
  • simpleIntersectionWeights (boolean, default=False)

    • This option should only be used as a stop-gap if the calculation of immersed boundary <-> wall intersections goes awry during panel weight calculation. This option causes panel weights of intersected wall or immersed boundary elements to become a fraction of the nodes external to other surfaces. If issues are found with intersecting panel weights, set this to true and contact James Koch.
  • method (string, default="dcel")

    • Accepted Values: ["dcel", "bruteforce"]
    • The method used to integrate on viscous surfaces when using the LAVA-internal overlapper integration tool. Overlapping quads are projected and parameterized, and a fraction found for each quad which represents the surface it owns.
    • DCEL
      • Uses a doubly-connected edge list (DCEL) surface-overlap decomposition to sub-divide the overlap exacly.
    • bruteForce
      • The brute force method is less-accurate, creating an integration grid to approximate quad area.
  • wallPriorityType (string, default="elemarea")

    • Accepted Values: ["zonearea", "elemarea"]
    • The method used to define viscous surface element priority when using the LAVA-internal overlapper integration tool so that accounted-for surface is unit. Lesser area always correlates to higher priority.
    • zoneArea
      • Sets priority of all elements in the zone to that of the zone's average area.
    • elemArea
      • Sets each elements's priority to its own area.
  • tolerance (float, default=0.1000E-07)

    • The tolerance for overlap clipping and intersection checks.
  • offsetEpsPerc (float, default=1.000)

    • The positive percentage by which the quad bounding box is expanded prior to checking for quad-quad overlap. Default is 1.0%: increase if finding that certain overlap sections aren't recognizing each-other (which generally only happens when compared cells are Cartesian axis-aligned).
  • projAngLim (float, default=78.00)

    • The angle in degrees which limits which quads can project onto eachother when comparing normals. Increase to be more lenient. It is bounded between 45 and 85 degrees. USURP uses 78 degrees.
  • coPlanarPreference (string, default="immersed")

    • Accepted Values: ["immersed", "wall"]
    • If immersed boundaries and viscous walls both exist when generating panel weights, then it is possible they could have elements which are coplanar. In this situation, either all walls or all immersed elements should be considered over the other set.
    • immersed
      • Immersed elements are preferred (default).
    • wall
      • Wall elements are preferred.
  • writeOctTrees (boolean, default=False)

    • Will write the last iteration of the flooded surface-defining octrees for all walls and immersed boundary surfaces.
  • writeADTTrees (boolean, default=False)

    • Will write the surface defining the IO search ADT trees of all walls and immersed boundary surfaces.
  • writeBlanking (boolean, default=False)

    • Will write the blanking values for all walls and immersed boundary surfaces in a single Tecplot .plt file.
  • writeIntersections (boolean, default=False)

    • Will write the intersection cutlines between all walls and immersed boundary surfaces in a single Tecplot .plt file.
  • writeAllIntegratedGeom (boolean, default=False)

    • Will write a triangulated representation of the accounted-for integration area of all walls and immersed boundaries. All wall and immersed surface portions of this integration area will be in a single zone. Note that actual integration in the LAVA code is still a node-fractional representation.
    • WARNING: very high cell count for the bruteForce method.
  • writeZonesIntegratedGeom (boolean, default=False)

    • Will write a triangulated representation of the accounted-for integration area of all walls and immersed boundaries. Each zone in this file pertains to a wall zone's or immersed surface's integration portion. Note that actual integration in the LAVA code is still a node-fractional representation.
    • WARNING: very high cell count for the bruteForce method.
  • debugWallBlkJKL ([float , float , float , float], default=[0.000, 0.000, 0.000, 0.000])

    • Format is [iBlk, j, k, l]. If this is provided, then debug info related to the surface quad with the lower-left jkl index of iBlk will be printed during the overlapper process. Note that this jkl MUST pertain to a lower-left boundary-condition (BC) cell within the defined block.
  • debugWallBlkBCCell ([float , float , float], default=[0.000, 0.000, 0.000])

    • Format is [iBlk, iBC, iElem]. If this is provided, then debug info related to the wall BC surface of the block will be printed during the overlapper process. Generally, the user would get iBlk, iBC and iElem by interrogating overlap_wallElemFracs.plt and looking at the zone name and cell index label.
  • debugWallGlbCell (float, default=0.000)

    • If this is provided, then information related to this unique wall surface quad will be printed to the screen during the overlapper routine. This option is used for more print-in-line debugging approaches.
  • debugIBFileCell ([float , float], default=[0.000, 0.000])

    • Format is [fileI, elemI]. If this is on, then information related to element elemI within immersed boundary fileI's surface file will be printed to the screen during the overlapper routine.
  • debugIBSurfCell ([float , float], default=[0.000, 0.000])

    • Format is [iSurf, iCell]. If this is provided, then debug info related to this unique IB surface cell will be printed during the overlapper process. Generally, the user would get iSurf and iCell by interrogating overlap_IBElemFracs.plt.
    • NOTE: iSurf may not be the same as fileI, because spatially-unique surface sets are divided if multiple exist within a single immersed surface file.
  • debugIBGlbCell (float, default=0.000)

    • If this is provided, then information related to this unique IB surface quad will be printed to the screen during the overlapper routine. This option is used for more print-in-line debugging approches.
  • debugVerbose (boolean, default=False)

    • Debugging will print each looked-at cell in order to help find issue.
  • debugWriteWallBlankingFronts (boolean, default=False)

    • Debugging will write each wall flood iteration's blanked nodes.
    • WARNING: Can take a while to run.
  • debugWriteIBBlankingFronts (boolean, default=False)

    • Debugging will write each IB flood iteration's blanked nodes.
    • WARNING: Can take a while to run.
  • debugWriteIOUncertainNodes (boolean, default=False)

    • Debugging will write all wall and IB intersection-local nodes which have uncertain oct/ADT IO raycast checks.
  • debugWriteClipPoly (boolean, default=False)

    • Print and write the clip poly task required for isect negative area calc. This is quite verbose, so is default false.

B2B Extractor

  • This section is used to automate the generation of the file specifying block-to-block (B2B) interfaces when they are present in the grid file (the grid > curv > B2BFile).

B2BExtractor:
  extractB2Bs:
  writePrefix:
  onlyFullB2Bs:
  fullInds:
  nPatchAlloc:
  orderByDonor:
  writeB2BZones:
  warnPartialB2Bs:
  debugBlkID:
  debugFaceI:
  transformations:
    -
      type:
      translationVec:
      rotAxisBeg:
      rotAxisEnd:
      rotAxisAng:
  blockTols:
    -
      zone: <required>
      B2BTol: <required>
  ignoredBlockFaces:
    -
      zone: <required>
      faceI: <required>
  • extractB2Bs (boolean, default=False)

    • Will read grid file, find all B2B relations between blocks, write B2B file and use the written file.
  • writePrefix (string, default="NONE")

    • The prefix of the file holding extracted b2bs. If none is provided, then the grid name will be the prefix.
  • onlyFullB2Bs (boolean, default=False)

    • If true, then only B2B connections between entire block faces which match 1:1 will be considered for b2bs.
  • fullInds (boolean, default=False)

    • When writing the B2B file, jkl indices will be the full index values instead of (possibly) -1 which represents the max index value.
  • nPatchAlloc (integer, default=50)

    • The max number of B2B patches that is allocated per block. The default should be ok pretty much always.
  • orderByDonor (boolean, default=False)

    • Orders the written b2bs for a block by donor block ID instead of by face I
  • writeB2BZones (boolean, default=False)

    • Will write all the grid surfaces associated with the b2bs found to a file with the prefix defined in B2BExtractor > writePrefix + .b2b.x.
  • warnPartialB2Bs (boolean, default=False)

    • B2B extraction process will provide warnings if partial b2bs are detected (unless B2BExtractor > onlyFullB2Bs is true, in which case there is no need to check). This can be used to check if the process finds partials when the user does not expect there should be any, and can find errors in grid topology.
  • debugBlkID (integer, default=-1)

    • A debug block ID for the B2B extraction process. Will spit out data for that block. It is recommented to specify B2BExtractor > debugFaceI as well to get more specific info.
  • debugFaceI (integer, default=-1)

    • A debug block face I for the B2B extraction process. To use, also specify B2BExtractor > debugBlkID.
  • transformations

    • Entries here are a transformation type and its info.
    • type (string, default=)

      • Accepted Values: ["none", "translation", "rotation"]
      • A periodic transformation type which is relevant for the entire mesh.
      • none
        • No periodic transformation is applied (default).
      • translation
        • Apply a periodic translation transformation (e.g. infinite wing). Must specify translationVec.
      • rotation
        • Apply a periodic rotational transformation (e.g. turbomachinery blade cascade). Must specify rotAxisBeg, rotAxisEnd, and rotAxisAng.
    • translationVec ([float , float , float], default=[0.000, 0.000, 0.000])

      • The [X, Y, Z] periodic translation vector for the B2B extraction process.
    • rotAxisBeg ([float , float , float], default=[0.000, 0.000, 0.000])

      • The [X, Y, Z] of the periodic rotation axis start point for the B2B extraction process.
    • rotAxisEnd ([float , float , float], default=[0.000, 0.000, 0.000])

      • The [X, Y, Z] of the periodic rotation axis end point for the B2B extraction process.
    • rotAxisAng (float, default=0.000)

      • The periodic rotation angle for the B2B extraction process.
  • blockTols

    • Entries here are a block and tolerance pair, and will change the tolerance of B2B face contact checks for those specific blocks during the b2bExtractor process. Should only be used as a last resort. It is recommended that the grids be fixed first.
    • zone (integer, required)

      • The block which will be assigned a new B2B tolerance.
    • B2BTol (float, required)

      • The tolerance used for B2B checks during the B2BExtractor process instead of curvSolver > b2bTol.
  • ignoredBlockFaces

    • Entries here are a block and faceID pair, and will set a block face to be ignored by the B2BExtractor process. Should only be used as a last resort. It is recommended that the grids be fixed first.
    • zone (integer, required)

      • The block number to be ignored by the B2BExtractor process.
    • faceI (integer, required)

      • The face of the block to be ignored by the B2BExtractor process (follows the mapping 1-6 -> JMin, JMax, KMin, KMax, LMin, LMax).

Rotating Mesh

  • This section defines regions of the mesh that are to undergo rotational motion as the simulation progresses.
  • NOTE: Make sure to set timeStepping > gridMotion to True for the motion specified in this section to take effect.

rotatingMesh:
  -
    omega:
    zones:
    axis1:
    axis2:
  • omega (float, default=1.000)

    • Angular rotation rate in radians per second.
  • zones ([string, ...], default=[""])

    • List of zones that undergo rotational motion.
  • axis1 ([float , float , float], default=[0.000, 0.000, 0.000])

    • Start point [X, Y, Z] of mesh rotation axis.
  • axis2 ([float , float , float], default=[1.000, 0.000, 0.000])

    • End point [X, Y, Z] of mesh rotation axis.

Immersed Boundaries

  • This section is used to define immersed boundaries within the computational domain.

immersedboundaries:
  -
    fileName: <required>
    filetype: <required>
    updateType:
    octTreefilename:
    octTreeCubes:
    octTreeMinDepth:
    octTreeMaxDepth:
    octTreeCubesPerEdge:
    zones:
    BCName:
    timescaleInterval:
    timescaleValues:
    timescaleValuesType:
    timescaleIntervalType:
    timescaleRampType:
    ibMarkOffsetDist:
    interpOffsetDist:
    uniqueSurfOptions:
      -
        uniqueSurfs:
        octTreeCubes:
        octTreeMinDepth:
        octTreeMaxDepth:
        octTreeCubesPerEdge:
    timescale:
    cartInterpOffsetDistFactor:
  • fileName (string(fileName), required)

    • Filename containing the closed water-tight surface triangulation which represents the immersed body.
  • filetype (string, required)

    • Accepted Values: ["tri", "tecplot"]
    • Filetype of the immersed boundary surface triangulation.
    • tri
    • Tecplot
      • Tecplot PLT binary format file.
  • updateType (string, default="settozero")

    • Accepted Values: ["settozero", "drivetozero"]
    • The type of update the immersed boundary undergoes each timestep.
    • setToZero
      • Forces velocity/momentum to be 0, but can be numerically unstable.
    • driveToZero
      • Drives velocity/momentum toward zero using an update \(\eta\) of \(1 / T\), where \(T\) is the timescale.
  • octTreefilename (string, default="")

    • Filename for octree used for in/out testing of the immersed boundary
  • octTreeCubes (integer, default=500000)

    • The maximum number of cubes allowed in the octree. If resolution is poor, increase. Decrease to resolve memory limit issues.
  • octTreeMinDepth (integer, default=9)

    • Minimum number of subdivision levels allowed to resolve the immersed surface using an octree. Lower to allow enforcement of memory limitations. Raise to force increase of minimum surface resolution.
  • octTreeMaxDepth (integer, default=12)

    • Maximum number of subdivision levels allowed to resolve the immersed surface using an octree. Lower this to enforce memory limitations. Raise to allow increased local resolution if needed.
  • octTreeCubesPerEdge (float, default=2.000)

    • Resolution requirement of immersed surface octree which states how many final cubes must be on a surface edge. Default is usually OK.
  • zones ([string, ...], default=[""])

    • List of zones that claim to represent this immersed boundary. If specified, nodes of these zones will not be blanked by connectivity when found to be inside closed geometry, instead being marked as immersed. Nodes of these grids may still be blanked by explicit hole cuts. Can cause the IBIND file to be re-written if its write was desired.
    • NOTE: To properly remember the update to the IBIND file, ensure that curvSolver > writeIBINDFile is set to true.
  • BCName (string, default="default")

    • This is the name of the BC which this immersed boundary will seek to emulate. The name list of each entry in the BC sub-dictionary will be looked through until this BC name is found.
    • NOTE: The BC entry for the immersed boundary must include definitions for both BC > matchLoc and BC > wallModel.
  • timescaleInterval ([integer, ...], default=1)

    • Array of integers specifying the iteration or CTU value to update timescale for immersed boundary penalization.
  • timescaleValues ([float, ...], default=[0.1000E-07])

    • Array of real numbers specifying the timestep values or multiplicative factor relative to the physical timestep for explicit solvers
  • timescaleValuesType (string, default="none")

    • Accepted Values: ["none", "factor", "specified"]
    • Type of timescale scheduling.
    • none
      • Turn off all timescale scheduling (default).
    • factor
      • Interprets the values specified in immersedBoundaries > timescaleValues as a multiplicative factor of the timestep for explicit solvers.
    • specified
      • Interprets the values specified in immersedBoundaries > timescaleValues as explicit values.
  • timescaleIntervalType (string, default="iter")

    • Accepted Values: ["ctu", "iter"]
    • Type of timescale scheduling interval.
    • iter
      • Interprets immersedBoundaries > timescaleInterval as an array of outer iterations.
    • ctu
      • Interprets immersedBoundaries > timescaleInterval as an array of integer CTU values.
  • timescaleRampType (string, default="discrete")

    • Accepted Values: ["linear", "discrete"]
    • Type of timescale ramping.
    • linear
      • Linearly interpolates at each outer iteration between the containing user-specified interval. May be viewed as continuous ramping.
    • discrete
      • Changes the value of timescale at each timescale interval provided by the user (default). May be viewed as discrete ramping.
  • ibMarkOffsetDist (float, default=0.000)

    • This is a user-defined physical distance off of this immersed boundary's elements normals which, if > 0.0, will tag volume cells as inside the immersed geometry if they are outside the surface but still within this distance.
    • NOTE: This value is meant to be small, as it is only used if volume nodes fall within the wall-holding cells of the search octree.
  • interpOffsetDist (float, default=0.2500E-03)

    • This is a user-defined physical distance off of this immersed boundary's elements normals at which interpolation points will be placed. This value times its BC > matchLoc will determine the wall model interp location, while a number of successive offset locations equal to curvSolver > nImmersedWallOffsetPts will be used to interpolate integrable immersed surface values from the volume solution. The default value of 2.5e-4 is what is required to obtain an average yplus value of about 51 for the probe surface for a flat plate test case.
  • uniqueSurfOptions

    • Use this section to define unique surfaces within the supplied immersed boundary file.
    • uniqueSurfs ([string, ...], default=[""])

      • The ids of the unique surfaces within the supplied immersed boundary file. If there is only a single unique surface, then there is no need to use immersedBoundaries > uniqueSurfOptions.
    • octTreeCubes (integer, default=500000)

      • Refer to immersedBoundaries > octTreeCubes above.
    • octTreeMinDepth (integer, default=9)

      • Refer to immersedBoundaries > octTreeMinDepth above.
    • octTreeMaxDepth (integer, default=12)

      • Refer to immersedBoundaries > octTreeMaxDepth above.
    • octTreeCubesPerEdge (float, default=2.000)

      • Refer to immersedBoundaries > octTreeCubesPerEdge above.
  • timescale (float, default=0.1000E-03)

  • cartInterpOffsetDistFactor (float, default=1.000)

    • If this immersed boundary surface is represented by a sharp IB type, then its immersedBoundary > interpOffsetDists used for surface integration and wall model calculation are automatically inferred directly from the local mesh dx. This factor multiplies the found dx to increase the effective immersedBoundary > interpOffsetDists if needed.

Actuator Regions

  • This section is used to define actuator regions inside the computational domain. This feature can be used to apply volumetric momentum sources inside the fluid domain.

actuatorRegions:
  -
    rotAxisBegin: <required>
    rotAxisEnd: <required>
    thrust: <required>
    names:
    type:
    method:
    torque:
    interpolationFile:
    actuatorLineFile:
    relax:
    iterRelaxRange:
  • rotAxisBegin ([float , float , float], required)

    • Start point [X, Y, Z] of actuator region rotation axis.
  • rotAxisEnd ([float , float , float], required)

    • End point [X, Y, Z] of actuator region rotation axis.
  • thrust (float, required)

    • Total thrust force imparted to the flow through the entire actuator region.
  • names ([string, ...], default=["default"])

    • List of names of regions specified in the subset file. These names must match those provided in the first colum of the file provided in grid > curv > subsetFile. The actuator disk will be applied over these regions.
  • type (string, default="disk")

    • Accepted Values: ["disk"]
    • Actuator region type. Options include:
    • disk
      • The source terms are applied uniformly across a disk. This is a steady-state computation.
  • method (string, default="const")

    • Accepted Values: ["const"]
    • Actuator region method. Options include:
    • const
      • Constant loading across the radius of the disk.
  • torque (float, default=0.000)

    • Total torque imparted to the flow through the entire actuator region.
  • interpolationFile (string(fileName), default="")

    • Prescribed loading distribution across the radius of the disk. Only used if using method: interp.
  • actuatorLineFile (string(fileName), default="")

    • File containing control points used in the distribution function for the actuator line approach when type: line is used. Refer to NTRS/20220010349 for more details.
  • relax (boolean, default=True)

    • Whether to apply a relaxation/ramping factor to the source terms for this actuator disk during the flow solve.
  • iterRelaxRange ([integer , integer], default=0)

    • Nonlinear iterations range (start and end) over which this actuator disks source terms are ramped from zero (not applied) to one (fully applied).

Adjoint

  • This section defines parameters associated with the adjoint solver.

adjoint:
  method:
  objectives:
    -
      name: <required>
      weight:
  designVariables:
  pseudo:
    timeStepStart:
    timeStepMax:
    timeStepMin:
    timeStepRamp:
    timeStepStepTol:
    iterMax:
    tolerance:
    matFree:
    doLineSearch:
    timeStepLinItsTol:
    maxTimeStepLinTol:
  linearSolver:
    tolerance:
    subSpaceSize:
    iterMax:
    monitor:
    solver:
    recycleSize:
    iterativeRefinement:
  preconditioner:
    type:
    ilufill:
    subIter:
  freezeT:
  scaleAdjointOutput:
  freezeConnectivity:
  probeTargets:
    -
      name: <required>
      fileName: <required>
      sourceFileType:
      targetVars:
      precision:
  exactBCDiff:
  freezeProbeWeights:
  sBOOMAdjoints:
    -
      probeName: <required>
      fileName:
      weight:
  warmStartFromApprox:
  • method (string, default="approx")

    • Accepted Values: ["approx", "pseudo", "exact"]
    • The linear adjoint solver method.
    • approx
      • Approximate linear adjoint solver method.
    • pseudo
      • Pseudo linear adjoint solver method.
    • exact
      • Exact linear adjoint solver method.
  • objectives

    • This sub-section defines the objective functionals for either optimization or adaptation.
    • name (string, required)

      • Objective functionals for either optimization or adaptation.
    • weight (float, default=1.000)

      • Weights used for multi-objective functionals.
  • designVariables ([string, ...], default=["alpha"])

    • Design variables for optimization.
  • pseudo

    • timeStepStart (float, default=0.000)

      • Starting timestep size for pseudo-transient continuation (PTC) of adjoint. If set to zero (\(< 10^{-12}\)), then no PTC is done and it goes straight into the inexact-Newton method.
    • timeStepMax (float, default=0.000)

      • Maximum timestep size for pseudo-transient continuation (PTC) of adjoint. If set to zero (\(< 10^{-12}\)), then the max step is infinity!... which means it will eventually switch into the inexact-Newton method.
    • timeStepMin (float, default=0.000)

      • Minimum timestep size for pseudo-transient continuation (PTC) of adjoint. If set to zero (\(< 10^{-12}\)), then it takes the starting timestep as the minimum. Memory-wise, it is beneficial to have timeStep, timeStepMax, and timeStepMin set to zero, in which case the PTC approach is never used. If PTC is never used, an explicit residual Jacobian is not stored in memory to quickly reapply the timestep before refactoring the preconditioner.
    • timeStepRamp (float, mutable, default=1.250)

      • The factor used to ramp the timestep when there are good updates.
    • timeStepStepTol (float, mutable, default=0.5000E-01)

      • The factor used for judging acceptable update sizes. The timestep is reduced if the step size is below this factor.
    • iterMax (integer, default=100)

      • Number of pseudo timestep iterations.
    • tolerance (float, lower bound=0.1000E-15, default=0.1000)

      • The required convergence for the linear solver for the pseudo adjoint problem. This is not relative to the initial residual.
    • matFree (boolean, default=True)

      • Use the matrix-free method for doing matrix-vector products in the linear system solve.
    • doLineSearch (boolean, default=False)

      • Perform a backtracking line search for each Newton iteration.
    • timeStepLinItsTol (float, mutable, default=0.9000)

      • The average linear iteration tolerance, relative to the Krylov subspace size, used to control timestep ramping.
    • maxTimeStepLinTol (float, lower bound=0.1000E-14, upper bound=0.9999, default=0.5000)

      • The maximum linear convergence tolerance which is acceptable before the timestep is reduced.
  • linearSolver

    • tolerance (float, lower bound=0.1000E-15, upper bound=1.000, mutable, default=0.1000E-08)

      • The required convergence for the linear solver for the adjoint problem. This is relative to the initial residual.
    • subSpaceSize (integer, lower bound=1, default=200)

      • The maximum number of Krylov vectors to use for GMRES.
    • iterMax (integer, lower bound=1, default=1000)

      • Sets the maximum number of linear iterations to perform.
    • monitor (boolean, default=True)

      • Display the convergence of linear iterations for the adjoint solve.
    • solver (string, default="gmres")

      • Accepted Values: ["gmres", "gcrodr"]
      • The linear solver to use for solving the linear system.
      • GMRES
        • Generalized minimal residual (GMRES) method (default).
      • GCRODR
        • Generalized Conjugacy Residual with Deflated Restarting (GCRO-DR) method.
    • recycleSize (integer, lower bound=0, default=10)

      • Number of Krylov vectors recycled between GMRES restarts. This option is only used if GCRODR is selected as solver.
    • iterativeRefinement (boolean, default=False)

      • Use iterative refinement to solve the adjoint problem. Similar to the flow solve, this technique solves the linear system in single precision, and uses a sequence of correction steps to obtain an adjoint solution in double precision. Only valid if using approx or exact adjoint methods.
  • preconditioner

    • type (string, default="ilu")

      • Accepted Values: ["ilu"]
      • The type of preconditioner to use for the adjoint solve.
      • ILU
        • Incomplete lower-upper (ILU) factorization.
    • ilufill (integer, lower bound=0, upper bound=10, default=1)

      • The level of fill used for ILU. Higher levels of fill take more time to apply and use more memory, but it can result in lower number of linear iterations. The most common values are 0 and 1. Values are 0 are more often used for unsteady simulations.
    • subIter (integer, lower bound=1, upper bound=5, default=1)

      • The number of sub-iteration applications of preconditioner to perform. This option should be rarely changed. The only time this could be increased to 2 is if memory requirements dictate only a fill level of 0 can be used, but a stronger preconditioner is desired.
  • freezeT (boolean, default=False)

    • Flag specifying that contributions from the turbulence model will be ignored in the calculation of the adjoint solution. Only the flow residual will be linearized and used as the operator for the LHS of the adjoint problem.
  • scaleAdjointOutput (boolean, default=False)

    • Flag specifying if the output written by adjoint > writeAdjointSol will be scaled by the metric Jacobian. This scaling option is only useful for visualizing the adjoint and should not be used for any error or gradient calculations.
  • freezeConnectivity (boolean, default=True)

    • Flag specifying if the connectivity for a given grid remains unchanged throughout the optimization process. The default is true, for which connectivity is not recomputed each time the volume grid is deformed. If this is set to false by the user, then connectivity will be recomputed each time the volume grid is deformed. Derivatives for the overset weights will be included in the gradient calculations. However, recomputing connectivity may lead to a non-smooth design space resulting in increased difficulty for gradient-based optimization.
  • probeTargets

    • This section may be used to set target variables for the adjoint problem defined on probes specified by the user.
    • name (string, required)

      • Name of the probe for which this target is set. This probe, and its corresponding name, should exist in the probes section of the YAML input file.
    • fileName (string, required)

      • Name of the probe solution file that holds the target values. For example, this solution file should contain the pressure targets if the user is targetting pressure on a given probe.
    • sourceFileType (string, default="tri")

      • Accepted Values: ["tri", "plot3d", "tecplot"]
      • File type of the probe target file.
      • tri
      • Plot3D
      • Tecplot
        • Tecplot PLT binary format file.
    • targetVars ([string, ...], default=["pressure"])

      • Variables that the user is targeting on the probe surface.
    • precision (string, default="double")

      • Accepted Values: ["single", "double"]
      • Precision used in the output of the probe target solution data.
      • single
        • Data is output in single-precision.
      • double
        • Data is output in double-precision.
  • exactBCDiff (boolean, default=True)

    • Flag specifying if the boundary condition(s) (BCs) are to be differentiated exactly. When performing the reverse pass over the BCs, the value of \(Q\) at the node is technically needed before the BC has been applied. However, if a node has two BCs applied to it (like at the edge or corner of the farfield) then the first set of BCs must be applied before computing the derivatives. In all, this will cost a bit more in computations and memory (it needs a temporary qVec).
  • freezeProbeWeights (boolean, default=False)

    • Flag specifying if the interpolation weights for all probes remain unchanged throughout the optimization process. The default is false, for which probe weights are recomputed each time the volume grid is deformed and/or the probe is moved. If this is set to true by the user, then the probe weights will not be recomputed each time the volume grid or probe is deformed. Derivatives for the interpolation weights will be excluded from the gradient calculations.
  • sBOOMAdjoints

    • This sub-section defines parameters related to performing sBOOM adjoint computations.
    • probeName (string, required)

      • Name of the probe for which an sBOOM adjoint is applied. This probe, and its corresponding name, should exist in the probes section of the YAML input file.
    • fileName (string, default="Gradient.plt")

      • Name of the sBOOM adjoint file that holds adjoint solution output from sBOOM. Typically, this would be Gradient.plt
    • weight (float, default=1.000)

      • Weights applied to this sBOOM adjoint, useful for when there are multiple sBOOM adjoints or other functionals and the user would like to weight them all differently.
  • warmStartFromApprox (boolean, default=False)

    • Warm start the exact adjoint solution using the solution and Krylov subspace from the approximate adjoint solve.

Broyden Solver

  • This section defines parameters associated with utilizing the Broyden method to adjust input parameters while solving the RANS equations to meet a target output. For example, adjusting alpha to meet a target lift coefficient.

broydenSolver:
  outputs:
  outputTargets:
  tolerance:
  maxIterations:
  inputs:
  inputIndices:
  initialStep:
  initialJacobian:
  • outputs ([string, ...], default=["cl"])

    • List of output functionals to target.
  • outputTargets ([float, ...], default=[0.5000])

    • Targets for each output functional of interest. Must be the same size as broydenSolver > outputs.
  • tolerance (float, default=0.1000E-03)

    • Tolerance used around the target value(s) when assessing whether the Broyden solver procedure has completed successfully.
  • maxIterations (integer, lower bound=1, upper bound=100, default=10)

    • Maximum number of Broyden solves to perform before stopping the procedure.
  • inputs ([string, ...], default=["referenceconditions.alpha"])

    • Input parameters which can be adjusted by the Broyden procedure. Must be the same size as broydenSolver > outputs.
  • inputIndices ([integer, ...], default=0)

    • Index for each input parameter (0-based). Must be the same size as broydenSolver > outputs.
  • initialStep ([float, ...], default=[0.1000E-01])

    • After the first RANS solve the input parameters are incremented by this amount in order to start the Broyden procedure. Must be the same size as broydenSolver > outputs.
  • initialJacobian ([float, ...], default=[0.1000])

    • Scale factor used for limiting the initial Jacobian formed during the first step of the Broyden procedure. Must be the size of broydenSolver > outputs squared.

Convergence Criteria

  • This section defines convergence criteria that will be used to control the stoppage of a steady-state RANS-based analysis. When using limiters, steady-state convergence can often stall due to limiter rattling, leading to long run times. This option allows users to prescribe a standard deviation tolerance over a specified number of iterations for specific quantities of interest. If either the residual converges to the specified tolerance or all of the specified functional-based convergence tolerances are met, then the steady-state solve is completed. This can also be used within implicit unsteady runs using dual time-stepping, if a large timestep is being used.

convergenceCriteria:
  -
    quantity: <required>
    stdTolerance: <required>
    stdWindowIterations:
    verbose:
    frequency:
  • quantity (string, required)

    • Quantity used to monitor convergence in addition to using the residual norm. The default quantity is \(C_d\) which represents the drag coefficient.
  • stdTolerance (float, required)

    • Standard deviation tolerance for the specified quantity of interest. For example, the default is 0.00001 which represents a tenth of a drag count.
  • stdWindowIterations (integer, default=500)

    • The size of the iteration window used for computing the standard deviation of the quantity of interest. Common examples are 100, 500, or 1000 depending on the problem and functional. The default is set to 500 which should be good for cases in which the CFL becomes larger than 100.0 during steady-state convergence.
  • verbose (boolean, default=True)

    • Setting verbose to true will report the mean and standard deviation of the quantity of interest every time the convergence criteria is checked.
  • frequency (integer, default=10)

    • This sets the frequency at which the convergence criteria is checked. Also controls the output of the mean and standard deviation if verbose is set to true. The default is set to every 10 iterations.

Parameter Scheduling

  • This section is used to specify iteration-based user-defined input parameter changes.

parameterScheduling:
  -
    iter: <required>
    modify: <required>
  • iter (integer, required)

    • Iteration to apply parameter change at.
  • modify ([string, ...], required)

    • Parameter to change. Example: dt:1.0e-4.

Sponges

  • This section is used to define sponge regions. A sponge region can be defined to activate a source term in the equations to smoothly return the solution to the reference conditions within the specified region. This can be used if the domain is too small and non-physical waves are being generated at the boundary that interact with a region of interest.

sponges:
  -
    type: <required>
    applySpongeTo: <required>
    xMin:
    xMax:
    rotationAngle:
    radius:
    radiusInner:
    nFacet:
    fileName:
    fileType:
  • type (string, required)

    • Accepted Values: ["box", "surfile", "cone"]
    • The type of volume region specification.
    • box
      • A cartesian aligned box specified using xMin and xMax coordinates.
    • surFile
      • A closed surface triangulation that is specified using the fileName and fileType options.
    • cone
      • A cone using min/max radii specified using rMin/rMax at xMin/xMax.
  • applySpongeTo (string, required)

    • Accepted Values: ["interior", "exterior"]
    • Location relative to the sponge where source terms are applied.
    • interior
      • Sponge is applied to the interior of the closed triangulation.
    • exterior
      • Sponge is applied everywhere not inside the triangulation.
  • xMin ([float , float , float], default=[0.000, 0.000, 0.000])

    • Lower left corner of refinement region when type is box. Starting point of cone axis when type is cone.
  • xMax ([float , float , float], default=[1.000, 1.000, 1.000])

    • Upper right corner of refinement region when type is box. End point of axis when type is cone.
  • rotationAngle ([float , float , float], default=[0.000, 0.000, 0.000])

    • Defines axis rotation for box around barycenter [xrot, yrot, zrot].
  • radius ([float , float], default=[1.000, 1.000])

    • Radius at xMin and xMax when type is cone.
  • radiusInner ([float , float], default=[1.000, 1.000])

    • Inner radius of tube at xMin and xMax when type is cone.
  • nFacet (integer, default=120)

    • Number of facets on sponges defined by curved geometric shapes (applies to types [cone]).
  • fileName (string(fileName), default="file")

    • Filename for the closed surface for type surFile.
  • fileType (string, default="tecplot")

    • Accepted Values: ["tri", "plot3d", "tecplot"]
    • Filetype of closed surface for type surFile.
    • tri
    • Plot3D
    • Tecplot
      • Tecplot PLT binary format file.

Tripping Strips

  • This section is dedicated to the specification of flow tripping strips by adding momentum source terms to trigger resolved turbulence in the boundary layer.

tripStrips:
  -
    projectionType: <required>
    fileName:
    xMin:
    xMax:
    xRadius:
    dirStart:
    projectionVector:
    tripLength:
    tripSkip:
    radius:
    families:
    timescaleFact:
  • projectionType (string, required)

    • Accepted Values: ["closest", "vector"]
    • Type of projection to apply to the trip strip geometry.
    • closest
      • Project the trip strip nodes to the closest wall geometry found.
    • vector
      • Project the trip strip nodes to the wall geometry along a direction specified by the vector projectionVector.
  • fileName (string(fileName), default="tripStrips.x")

    • File name of input Plot3D file with trip strip geometry.
  • xMin ([float , float , float], default=[0.000, 0.000, 0.000])

    • Physical location [X, Y, Z] of the trip strip start.
  • xMax ([float , float , float], default=[1.000, 0.000, 0.000])

    • Physical location [X, Y, Z] of the end of the trip strip.
  • xRadius (float, default=1.000)

    • Radius for circular trip strip.
  • dirStart ([float , float , float], default=[0.000, 0.000, -1.000])

    • Direction to start circle. Usually -zhat for y-symm plane
  • projectionVector ([float , float , float], default=[1.000, 0.000, 0.000])

    • Direction of projection to apply to trip strip geometry.
  • tripLength (float, default=4.000)

    • Length of individual trips.
  • tripSkip (float, default=4.000)

    • Distance between individual trips.
  • radius (float, default=1.414)

    • Radius of influence.
  • families ([string, ...], default=[""])

    • Project trip strip onto parts defined with these names in the BC file only.
  • timescaleFact (float, default=3.000)

    • Factor to control strength of tripping source term.

Transition Model Tripping Strips

  • This section is to be used in conjunction with the Spalart Allmaras Smooth Langtry Mentor 2015 transition model in navierStokes > turbulenceModel > type: SASLM2015. Use these parameters to set a location in the geometry to transition the flow using the intermittency function.

transTripStrips:
  -
    projectionType: <required>
    fileName:
    xMin:
    xMax:
    xRadius:
    dirStart:
    projectionVector:
    radius:
    dxtrans:
    families:
    timescaleFact:
  • projectionType (string, required)

    • Accepted Values: ["closest", "vector"]
    • Type of projection to apply to the trip strip geometry.
    • closest
      • Project the trip strip nodes to the closest wall geometry found.
    • vector
      • Project the trip strip nodes to the wall geometry along a direction specified by the vector projectionVector.
  • fileName (string(fileName), default="transTripStrips.x")

    • File name of input Plot3D file with trip strip geometry.
  • xMin ([float , float , float], default=[0.000, 0.000, 0.000])

    • Physical location [X, Y, Z] of the trip strip start.
  • xMax ([float , float , float], default=[1.000, 0.000, 0.000])

    • Physical location [X, Y, Z] of the end of the trip strip.
  • xRadius (float, default=1.000)

    • Radius for circular trip strip.
  • dirStart ([float , float , float], default=[0.000, 0.000, -1.000])

    • Direction to start circle. Usually -zhat for y-symm plane
  • projectionVector ([float , float , float], default=[1.000, 0.000, 0.000])

    • Direction of projection to apply to trip strip geometry.
  • radius (float, default=1.414)

    • Radius of influence.
  • dxtrans (float, default=1.000)

    • Reference grid length (off-wall or streamwise spacing, could use characteristic length of domain (i.e. MAC) as well).
  • families ([string, ...], default=[""])

    • Project trip strip onto parts defined with these names in the BC file only.
  • timescaleFact (float, default=1.000)

    • Factor to control strength of tripping source term.

Target Volume Source Regions

  • This section specifies regions defined by a triangulation within which a series of target values for flow variables can be specified. In terms of analogy to immersedBoundaries, this uses the driveToZero update method.

targetVolumeSourceRegions:
  -
    fileName: <required>
    fileType: <required>
    targetVariables: <required>
    targetValues:
    octTreeFileName:
    octTreeCubes:
    timescale:
  • fileName (string(fileName), required)

    • The name of the tri file (*.i.tri) to use when defining the region.
  • fileType (string, required)

    • Accepted Values: ["tri"]
    • Input file format.
    • tri
  • targetVariables ([string, ...], required)

    • A list of variable names which have defined target values within the targetVolumeSourceRegions > targetValues list. Therefore, they must be same size. Allowed names are: [pressure, xvelocity, yvelocity, zvelocity, xvelocitynormal, yvelocitynormal, zvelocitynormal, temperature, rho, turbulencevar1, turbulencevar2, turbulencevar3]. If a certain combination of variables is not physically legal then the code will complain.
  • targetValues ([float, ...], default=[0.000])

    • A list of target values for each variable name in the targetVolumeSourceRegions > targetVariables list.
  • octTreeFileName (string, default="")

    • If defined, writes the octree used to tag nodes inside the region.
  • octTreeCubes (integer, default=500000)

    • Defines the maximum number of octree cubes allowed to define the region.
  • timescale (float, mutable, default=0.1000E-03)

    • A source-application update scalar. Scales update by 1/timescale. Currently this is mutable to allow potential tuning during runtime.