OVERGRID Version 2.3

Author: William M. Chan

Date: March, 2010.



OVERGRID is a graphical user interface (GUI) for performing one or more of the following tasks: The GUI contains a viewer for displaying the geometry and grids, and various modules are accessed from a main menu.

The programming languages used by the GUI are listed below. It is assumed that the necessary libraries are available on the local machine.

 C        - main program and driver for graphics
Tcl/Tk    - window management, widgets creation
OpenGL    - 3-D graphics display
Fortran90 - geometry/grid library routines
The Togl widget by Brian Paul and Ben Bederson is used for communication between Tk and OpenGL ( Copyright (C) 1996-2002, See the togl_LICENSE file for copyright details ). Togl is included in the overgrid package.

For users without Tcl/Tk, look under

for information on down-loading and installing your own. OVERGRID is now compatible with the following versions:
   Tcl/Tk 8.0p2, 8.0.3, 8.0.4, 8.0.5
   Tcl/Tk 8.1.1
   Tcl/Tk 8.2.2, 8.2.3
   Tcl/Tk 8.3.0, 8.3.1, 8.3.2, 8.3.3, 8.3.4, 8.3.5
   Tcl/Tk 8.4.0, 8.4.1, 8.4.2, 8.4.3, 8.4.4, 8.4.5, 8.4.6, 8.4.7,
          8.4.8, 8.4.9, 8.4.10, 8.4.11, 8.4.12, 8.4.13
          8.5.1, 8.5.2, 8.5.3, 8.5.4, 8.5.5, 8.5.6, 8.5.7, 8.5.8

This code is under frequent modifications and improvements and may contain some undiscovered bugs. OVERGRID is used by invoking a C-shell script called overgrid which then calls the C executable og and the Tcl/Tk script og.tcl. OVERGRID also has its own Makefile which relies on user-specified environment variables for locating the necessary include and library files (see Installation section below). A C-compiler (gcc/icc/pgcc) and a Fortran-90-compiler (ifort/pgf90/gfortran) are required to compile OVERGRID.

Installation of Tcl/Tk on machines with Linux, Unix, Mac OS-X (X11 option)

Skip this if you already have Tcl/Tk installed in your system. On Mac OS-X Intel machines, it is possible to use either the X11 or the Aqua version of Tcl/Tk. Currently, the X11 version is preferred since it gives a better appearance and faster performance, and it is easier to compile and install. Installation instructions of the X11 version of Tcl/Tk are the same as those for Linux/Unix and are given here.
  1. Download tcl8.*.*-src.tar.gz and tk8.*.*-src.tar.gz from the web-site given above.
  2. Expand the tcl file first (tar xzf tcl8.*.*-src.tar.gz).
  3. Go to the unix subdirectory and type ./configure to generate a Makefile for your particular operating system and hardware.
  4. Type "make" to create the tcl library called libtcl8.*.so for Linux/Unix, or libtcl8.*.dylib for Mac.
  5. Repeat the same procedure for the tk directory to create a library called libtk8.*.so for Linux/Unix, or libtk8.*.dylib for Mac.

Installation of OVERGRID on machines with Linux, Unix, Mac OS-X (X11 option)

Let $TCLDIR and $TKDIR be the full path names to the top level directories where tcl8.*.* and tk8.*.* are installed, respectively, i.e., $TCLDIR should contain the full path to the tcl8.*.* directory, and similarly for $TKDIR.
  1. The following environment variables should be set in the user's .cshrc file (the first 6 are needed for compilation, the last 3 are needed at run time):
          TCLDIR_INC = full path to directory containing tcl.h
          TKDIR_INC  = full path to directory containing tk.h
          X11DIR_INC = full path to directory containing X11/X.h, GL/gl.h
          TCLDIR_SO  = full path to directory containing libtcl8.*.so
          TKDIR_SO   = full path to directory containing libtk8.*.so
          X11DIR_SO  = full path to directory containing libX11.so
          TCL_LIBRARY = full path to directory containing init.tcl
          TK_LIBRARY  = full path to directory containing tk.tcl
          On Unix/Linux machines:
            LD_LIBRARY_PATH = full path to the libtcl8.*.so and libtk8.*.so libraries
          On Mac OS-X machines:
            DYLD_LIBRARY_PATH = full path to the libtcl8.*.dylib and libtk8.*.dylib libraries

  2. A convenient way to do this is to set the following:
          setenv TCLDIR_INC  $TCLDIR/generic
          setenv TKDIR_INC   $TKDIR/generic
          setenv X11DIR_INC  /usr/include
          setenv TCLDIR_SO   $TCLDIR/unix
          setenv TKDIR_SO    $TKDIR/unix
          setenv X11DIR_SO   /usr/lib64
          setenv TCL_LIBRARY $TCLDIR/library
          setenv TK_LIBRARY  $TKDIR/library
          setenv LD_LIBRARY_PATH $TCLDIR/unix:$TKDIR/unix

  3. On machines that can handle either 32 or 64 bit objects, specify appropriate compile flags for og.c so that the resulting executable has the same object type as that of the Tcl/Tk shared libraries libtcl8.*.so and libtk8.*.so.

  4. Type make to compile og.c and produce the og executable

  5. Modify the EXECDIR variable in the overgrid script file to point to the directory where og and og.tcl are located.

  6. Move the overgrid script file to a directory in the user's path, e.g. ~/bin.

  7. The following modules in the chimera*.*/src directory are used by overgrid: grided, srap, progrd, seamcr, seamcrt, surgrd, sblock, wkcut, hypgen, and boxgr. Single and double precision versions of the executables should be stored in separate directories. Loading a single or double precision file into overgrid will automatically trigger the use of executables in the appropriate directory specified by the user (see next item below and on-line help under PREFERENCES in the Controls Window).

  8. Create a preferences file called .overgridrc in the user's home directory. This file should contain the following 3 lines:
           < directory_path_for_single_precision_executables >
           < directory_path_for_double_precision_executables >
           < background_color, exec_endian >
    where the first two lines must point to different locations, and background_color = 0/1 (0=black, 1=white), exec_endian = 0/1 (0=little, 1=big). The exec_endian parameter is used to specify the `endianess' of the executables in the directories contained in the first two lines. Grid files of big or little endian can be handled appropriately by OVERGRID provided the exec_endian parameter is set properly. The .overgridrc file can also be created from inside OVERGRID by clicking on the PREFERENCES button, filling in the appropriate entries, and saving the contents to disk.

  9. The environment variable CGTROOTDIR can be used to override the locations of the CGT executables in the .overgridrc file. If CGTROOTDIR exists, then the single precision executables are assumed to be in $CGTROOTDIR/bin_sp, and the double precision executables are assumed to be in $CGTROOTDIR/bin_dp.

Installation of OVERGRID on machines with Mac OS-X (Aqua option)

For the adventurous users who insist on the Aqua version of Tcl/tk, installation instructions are given below.
  1. Download tcl8.*.*-src.tar.gz and tk8.*.*-src.tar.gz from the web-site given above.
  2. Put these files in a directory (let's call it $PKG from now).
  3. Expand the tcl8.*.* directory, cd to the macosx subdirectory, and type make.
  4. Expand the tk8.*.* directory, cd to the macosx subdirectory, and type make.
  5. This will generate a directory called build in $PKG which contains two subdirectories, one called tcl, one called tk.
Next, define the following environment variables for the location of the Tcl and Tk framework directories.

For self-installed tcl/tk,

         setenv TCL_FRWK $PKG/build/tcl/Tcl.framework
         setenv TK_FRWK  $PKG/build/tk/Tk.framework
For tcl/tk that is already installed on the system, these are usually located at
         setenv TCL_FRWK /System/Library/Frameworks/Tcl.framework
         setenv TK_FRWK  /System/Library/Frameworks/Tk.framework
Overgrid also uses the Togl dynamic library which has been pre-compiled for Mac OS-X and is found in the gui/macosx subdirectory of CGT. Define the following environment variable for Togl and append the path to the dynamic library path.
         setenv TOGL_DIR $CGT/gui/macosx

             where $CGT is the full path to the chimera* directory
Go to the $CGT/gui directory and type make -f Makefile.darwin.aqua to create the og executable.

Installation of OVERGRID on Windows machines

Platform specific problems


The user is strongly urged to go through the tutorial under chimera*.*/gui/tutorial for details on the capabilities and usage of the modules of OVERGRID. All unformatted grid files in the tutorial are given in big endian format. If needed, execute the script in chimera2.1/scriptbin/convertendian to convert all the tutorial unformatted grid files to little endian format.


   overgrid < FILENAMES >
   overgrid < -2 FILENAMES >
   overgrid < -r -2 FILENAMES >
   overgrid < -l -2 FILENAMES >
   overgrid < +x # +y # FILENAMES >
   overgrid < -dp FILENAMES >
where FILENAMES can be one or more filenames.

All command line options, except -dp, affect dual screen setups only. If xdpyinfo is not available, individual screen aspect ratios are assumed to be 1.6. The primary screen (screen 1) is always the upper left screen. Screen 2 is either to the right of screen 1 (horizontal stacking), or below screen 1 (vertical stacking). By default, overgrid windows will appear in screen 1.

Use "-2" on the command line to send the overgrid windows to screen 2. If both screens are the same size, just "-2" should work. If the two screens are of different sizes and xdpyinfo is not available, "-r" and "-l" may be used to indicate the location of the smaller screen ("-r" means smaller screen is on the right, "-l" means the smaller screen is on the left). E.g., "-2 -r" will send the overgrid windows to smaller screen 2 which is on the right, and "-2 -l" will send overgrid to the bigger screen on the right.

For more general shifting, use overgrid +x followed by an integer (optional xshift), and +y followed by an integer (optional yshift), to shift all overgrid windows to the right by xshift pixels, and down by yshift pixels. E.g., "overgrid +x 200 file" will shift all windows 200 pixels to the right.

Use `overgrid -dp' to force the code to enter double precision mode if the input grid file is formatted or single precision. For accessing native CAD files, OVERGRID must be invoked by typing `overgrid' alone.

Input File Types

OVERGRID is intended to be used primarily for structured grid data types. Unstructured surface triangulation data types are accepted for visualization purposes or for use as a reference surface geometry definition for the SEAMCR, SURGRD, PROGRD and COMPONENTS modules. Native CAD solid parts can also be read and internally converted to an unstructured triangulation for display and then be used as reference geometry for surface grid generation. This CAD access feature in OVERGRID is accomplished through the cad2srf and srf2cad modules which utilize a commercial software called CAPRI (Computational Analysis PRrogramming Interface). Through CAPRI, a variety of native solid CAD parts can be accessed through a common interface, e.g., Pro/ENGINEER, CATIA, Parasolid, Solidworks, OpenCASCADE, FELISA, etc. For users who require the CAD option, executables for cad2srf and srf2cad can be requested from CADNexus. In order to read a particular native CAD file, the corresponding CAD license, as well as a CAPRI user's license must be active.

A recently added new option for reading native CAD parts involves using the Virtual Topology Editor (VTE) library - an optional CAPRI package. Structured quadrilateral patches are automatically generated to represent the surface of the CAD parts. The VTE package is in its initial development phase and the structured patches generated are sometimes skewed and not aligned with surface curvature. Work is in progress to improve the mesh quality of the structured patches. As long as the Tcl-interface between VTE and OVERGRID remains unchanged, the VTE library can be updated and reconnected to OVERGRID in the future without recompilation. Users who are interested in trying out this option can request the VTE library from Bob Haimes (haimes@mit.edu).

The following file name extensions are used by OVERGRID to identify the CAD file type:

    CATIAV5 - .CATPart, .CATProduct
    FELISA  - .dat
    OpenCASCADE - .BRep
    Parasolid   - .xmt_txt
    Pro/ENGINEER - .prt, .asm, .prt.n, .asm.n where n can be any integer
    SolidWorks - .sldprt, .sldasm
    UniGraphics -.prt
Warning: only the Pro/ENGINEER file type has been tested.

The following structured grid and unstructured triangulation file types are currently readable by OVERGRID:

  1. PLOT3D grid (unformatted/formatted, big/little endian, single grid/multiple grid, 3-D/2-D, with/without iblanks, single/double precision). The format is automatically determined by OVERGRID. The filename can be any string. If a filename contains the strings ".tri", ".i.tri", ".fst", ".triq", or ".ucd" it will first be considered as a triangulation file. If read fails, an attempt will be made to read it as a PLOT3D file. OVERGRID can currently read and write both big and little endian PLOT3D files. However, for the execution of CGT batch modules like SRAP and HYPGEN to work successfully, the endian type of the CGT modules must be specified properly in the .overgridrc file. For the "ifort" compiler, the endian type of the executable can be hard-coded to little endian, while a user-defined environment variable F_UFMTENDIAN can be set to be either "big" or "little" to control the endian setting for file i/o.
  2. CART3D triangulation (unformatted/formatted). The format is automatically determined but the filename must contain the string ".tri" (un-intersected components) or the string ".i.tri" (intersected components), or the string ".triq" (triangulation with scalar q variables at vertices).
  3. FAST unstructured triangulation (unformatted/formatted). The format is automatically determined but the filename must contain the string ".fst".
  4. UCD unstructured surface with triangles and quads (formatted). The format is automatically determined but the filename must contain the string ".ucd".
WARNING - the capabilities for triangles data types are currently restricted to the list below. Attempts to use other OVERGRID features on triangles may produce unexpected results. Further capabilities and error checks for triangles will be implemented in the future.

PLOT3D File Format

read(2) ngrid read(2) (nj(n),nk(n),nl(n),n=1,ngrid) do n=1,ngrid read(2) (((x(j,k,l),j=1,nj(n)),k=1,nk(n)),l=1,nl(n)), & (((y(j,k,l),j=1,nj(n)),k=1,nk(n)),l=1,nl(n)), & (((z(j,k,l),j=1,nj(n)),k=1,nk(n)),l=1,nl(n)), & (((ib(j,k,l),j=1,nj(n)),k=1,nk(n)),l=1,nl(n)) enddo where ngrid = number of grids nj,nk,nl = j,k,l dimensions of each grid x,y,z = vertex coordinates ib = vertex iblank value (optional) For single grid format, ngrid is omitted.

CART3D Surface Triangulation File Format

read(2) nvert,nface read(2) (x(i),y(i),z(i),i=1,nvert) read(2) (iface(i,1),iface(i,2),iface(i,3),i=1,nface) read(2) (icomp(i),i=1,nface) where nvert = number of vertices nface = number of faces x,y,z = coordinates of vertex i iface = vertex indices of face i (vertex numbering begins with 1) icomp = ID tag of face i (integer)

CART3D Surface Triangulation with scalar Q File Format

read(2) nvert,nface,nscalar read(2) (x(i),y(i),z(i),i=1,nvert) read(2) (iface(i,1),iface(i,2),iface(i,3),i=1,nface) read(2) (icomp(i),i=1,nface) read(2) ((q(j,i),j=1,nscalar),i=1,nvert) where nvert = number of vertices nface = number of faces x,y,z = coordinates of vertex i iface = vertex indices of face i (vertex numbering begins with 1) icomp = ID tag of face i (integer)

FAST Surface Triangulation File Format

read(2) nvert,nface,ntet read(2) (x(i),i=1,nvert),(y(i),i=1,nvert),(z(i),i=1,nvert), & (iface(i,1),iface(i,2),iface(i,3),i=1,nface), & (icomp(i),i=1,nface) where ntet = 0

UCD Surface File Format

This is currently restricted to triangles and quads only and each quad is immediately converted to two triangles on input. One or more lines of comments that begin with '#' followed by read(2,*) nvert,nface,ndata,cdata,mdata do i=1,nvert read(2,*) vertnum,x(i),y(i),z(i) enddo do i=1,nface read(2,*) facenum,tag,element,vertlist(i) enddo where ndata,cdata,mdata,vertnum,facenum,tag are disregarded integers, element = "tri" or "quad" vertlist = flist(i,1),flist(i,2),flist(i,3) if element = "tri" flist(i,1),flist(i,2),flist(i,3),flist(i,4) if element = "quad"

Help and Tutorial

General on-line help is available under the Main Menu window. More detailed on-line help is also available under each module. A tutorial that illustrates most of the features of OVERGRID is located in chimeraxxx/gui/tutorial in a standard CGT release.


   Left mouse (up/down motion)    - rotate about screen X axis
   Left mouse (side motion)       - rotate about object Z axis
   Middle mouse                   - zoom
   Right mouse                    - translate
   Alt + Left mouse (side motion) - rotate about screen Y axis
Transforms using the mouse are almost like PLOT3D with the following exceptions.
  1. With mouse button depressed, the transforms continue when the mouse motion stops in PLOT3D. In OVERGRID, the transforms stop when the mouse motion stops.
  2. There is no acceleration with mouse motion in OVERGRID.
Sensitivity of mouse motion can be decreased/increased using the down/up arrow keys on the keyboard.

Entity Highlight and Selection

Highlighting and selection are performed in the "Entity Highlight and Selection" window at the lower right corner of the screen. For a black background, a highlighted surface is painted white while a selected surface has a thick white perimeter and a spherical icon in the middle. Similarly a highlighted curve is painted white with white symbols at the grid points and a selected curve has a spherical icon near the middle. The black/white colors are reversed for a white background.

Highlighting can be applied to a single entity (using the Entity # widget at the upper left corner of the "Entity Highlight and Selection" window). Highlighting is used when the user needs to flag a single entity for performing operations such as grided functions.

Selection can be applied to multiple entities. After an entity is highlighted, it can be selected by clicking on the Select button. Another entity can then be highlighted and selected subsequently. All entities that belong to a certain type (volumes, surfaces or curves) can be selected at once by pressing the appropriate Select All button. Selection is used when the user needs to flag multiple entities for performing further operations. The `Clear All' button clears all selections.

Selection of an unblanked entity can also be achieved by holding down the Ctrl key and clicking on the entity in the Graphics Display window with one of the mouse buttons.

Ctrl + left mouse button   - surface entity
Ctrl + middle mouse button - curve entity
Ctrl + right mouse button  - point entity
Performing the above operation on a selected entity will unselect the entity.

Selection/unselection of a group of entities can be achieved by drawing a drag box with

Shift + middle mouse buttom  - select entities within or partially within box
Shift + right mouse buttom  - unselect entities within or partially within box

Blank, Unblank, and Delete

Entities that are highlighted or selected can be blanked, unblanked or deleted by clicking on the appropriate buttons. A deleted entity can only be retrieved by reading from a file. Clicking the Tog Blank button will exchange the display status of blanked and unblanked entities.

Index Notation

A J-K-L index notation is used for all grids. For a surface grid (J/K/1), the tangent vector in J is indicated by an arrow, while the tangent vector in K is indicated by a line when the Show Tangent vector checkbutton is activated. A subset of an entity can be highlighted by clicking on the JS,JE,KS,KE,LS,LE widgets in the Entity Highlight and Selection window. When the constant J, K and L checkbuttons are all activated, the x, y, z coordinates and iblank value of a point is displayed in the message window for structured entities. A similar display for the vertex coordinates and face vertex indices are available for triangulated entities.

Current limitations

Entity Names

Each entity read into OVERGRID is automatically given a default name that can be viewed in the lower right corner message box when the entity is selected. The default name is the filename where the entity came from followed by ".", followed by the entity number in the file. This feature is only partially implemented and can only be trusted provided no entities are deleted or created by any of the modules in OVERGRID.

Drag box and Overlays

Unlike the previous implementation of the drag box for performing zooming and selection, the current implementation no longer require overlay plane support in hardware or software. However, due to an unknown bug or implementation problem probably related to Togl, shadows of the drag motion are displayed. The function of the drag box is not affected and the results are dependent only on the final edition of the box on release of the mouse button.


The GRIDED module contains a number of grid manipulation functions for structured curve, surface and volume entities. These include: Notes:
  1. The Swap, Reverse, Mirror, Scale, Translate and Rotate functions can be used on one or multiple entities. The Extract and Extrapolate functions can only be used on a single entity at a time. The Concat function operates on two selected entities only, i.e. the user must select the first and then the second entity to be concatenated. The order of selection is important. Use the tangent vector display to determine which should be selected first. The Auto-concat function operates on two or more surface or curve entities. Auto-concat does not work on volume entities currently.
  2. The Extract function operates on a highlighted subset of an entity.
  3. The old entity is replaced by the new entity for Swap J/K, Swap K/L, Swap J/L, Reverse, Mirror, Scale, Translate and Rotate. The old entity is retained and the new entity/entities is/are created for Extract, Extrapolate, Concatenate, Split, Auto-concatenate and Smooth.
  4. The UNDO button will erase the effects of the last operation only. UNDO's with scale, translate, rotate may be subjected to round-off errors, i.e. entities after the UNDO may not be bitwise identical to the original under these operations.


The SRAP code is used to redistribute grid points on a curve or surface entity.
  1. It is assumed that the user is familiar with the terminology used for SRAP. See srap.html for explanation of usage.
  2. The current end spacings of the segment are displayed in Da_c and Db_c. The new end spacings of segment can be specified under Da_n and Db_n.


PROGRD is a tool for performing projection of a grid subset (active grids) onto a grid surface (reference grids). The reference surface can be a collection of panel networks or a surface triangulation. The features implemented in OVERGRID is a subset of the features available in the batch version of PROGRD in Chimera Grid Tools. The display colors for entities under the PROGRD module are as follows:
Reference surface             : yellow
Unprojected active entities   : green
Projected active entities     : red


The DIAGNOS module contains a number of grid diagnostic functions for surface and and volume entities.

The grid quality functions supported for structured surface and volume entities include:

The grid quality functions supported for unstructured surface triangulations include: Other diagnostics capabilities under this module include


The TRIGED module contains a number of grid manipulation functions for surface triangulations.


The SEAMCR tool can operate on two types of reference surfaces: multiple panel networks and triangulations. It is primarily used for creating surface curves.

For multiple panel networks, it can be used for

For surface triangulations, it can be used to create surface curves by


SURGRD is used to create structured surface grids from 1, 2, 3, or 4 initial curves using hyperbolic and algebraic methods. The reference geometry can consists of multiple panel networks or a surface triangulation.
  1. Once the SURGRD button is depressed from the main menu, the colors of all entities will change: all surfaces will become gray and will be assumed to be part of the reference surface; all curves will be colored individually and are available for selection as reference curves.
  2. After generating one set of surface grids, the user must hit UNDO or exit the overgrid session before trying to generate something else with SURGRD. This limitation will be removed in the future.
  3. Use the SAVE button to store surface grids generated and the input parameter file produced.
  4. It is assumed that the user is familiar with the terminology used for SURGRD. See surgrd.html for explanation of usage.


SBLOCK is a `block' surface grid generator which requires the reference surface geometry and the seam grids as input.


WKCUT is a wake cut surface grid generator for wing and cap grids.


HYPGEN s hyperbolic field grid generator for creating field (volume) grids from one or more surface grids. The user can select one or more surface entities before clicking on the HYPGEN button. Boundary conditions for multiple surface entities are automatically determined while the same stretching parameters (marching distance, number of points, grid spacings) are used for all the grids. Further details are found in the HYPGEN User's Manual which is available as a NASA TM.


BOXGR is a Cartesian box grid generator. It can be used to create box grids around selected entities.


This module can be used to determine the boundary conditions of all grids currently in memory. Topological boundary conditions: periodic, axis, constant plane, wake cut, are automated detected. Heuristic rules are used to estimate the locations of inviscid and viscous walls. The user should cycle through the grids and check the auto-selection and make modifications if needed. A color viewer is available to view the various boundary condition types conveniently (by grid and/or by type).


This module is used to define components hierarchy and relation motion dynamics. If the motion is prescribed, an animation can be viewed here prior to running the flow solver. XML files are used as interfaces to flow solvers.

A configuration is defined to be the complete collection of objects in a simulation. Each configuration is made up of a collection of components. Each component can be a structured grid, a set of triangles, or a container. A container is used to group a set of lower level components and is not linked to any geometry or grids. Each component can be positioned initially by applying a sequence of transforms (rotate, translate, mirror). This mechanism is used to place duplicated components into their proper initial positions. For example, the 3 blades of a rotor can all be read from an input file with all 3 in the same location. The second and third blades can be placed into their proper positions by a rotation transform.

Also, each component is allowed to have one parent or none at all. A component inherits the motion of its immediate parent. Each component can have no motion relative to the inertial reference frame or to its parent component, or be allowed to move relative to other components under Prescribed Rotation motion, Prescribed Translation motion, Table-Lookup motion or Aero6dof motion.

This tool can be used to

The Config.xml and Scenario.xml files are usable by FLOWCART and will soon be also usable by OVERFLOW version 2.

Format for Table-Lookup Motion

The input dynamics table file should contain one or more rows of data in the following format:

 Component_ID  T  xc  yc  zc  e1  e2  e3  e4


 Component_ID = integer that stores the component ID tag
 T            = time
 xc,yc,zc     = coordinates of component center of mass at time T
 e1,e2,e3,e4  = Euler parameters of component at time T

The first time entry for each component should be at T=0.0. The default assumes the components start their initial positions in inertial coordinates (e.g. as adopted by the FLOWCART solver). If the components start off in body coordinates (e.g. as adopted by the OVERFLOW-D solver), the first line in the file should contain only the string "body", and there should be a subsequent entry with T=-1.0 that contains xc,yc,zc of the component at its initial undisturbed, untransformed position (e1,e2,e3,e4 for this entry are ignored).

An optional contacts log file can also be read to indicate the times, locations and local surface normals of contact points. The format for this file is

 ID_1  ID_2  T  xc  yc  zc  nx  ny  nz  diam


 ID_1, ID_2 = component ID tags of component pair in contact
 T          = time of contact
 xc,yc,zc   = coordinates of contact point
 nx,ny,nz   = local surface normal at point of contact
 diam       = tolerance for contact detection

Non-dimensionalization of Component Inertial Properties and Loads

Non-dimensional variables are indicated with an asterisk.

Length scale              = L
Free stream fluid density = rho_0
Free stream sound speed   = c_0

mass              m* = m/(rho_0 L^3), 
moment of inertia I* = I/(rho_0 L^5)
applied force     F* = F/(rho_0 c_0^2 L^2)
applied moment    M* = M/(rho_0 c_0^2 L^3)


PEGASUS5 is a tool for performing domain connectivity. The OVERGRID interface can be used to prepare the namelist input required for PEGASUS 5.


GEN_X is a pre-processor for performing domain connectivity using OVERFLOW-D. It can be used to create X-ray maps for the hole cutters.


The CALCULATORS module contains

1. Freestream conditions calculator based on standard atmosphere

     Input : altitude, speed, reference length in dimensional units
     Output: Mach number, Reynolds number, pressure, temperature, density, sound speed,
             viscosity, mean free path

2. Mass properties calculator for triangulated objects
     Input : surface triangulation, density (constant)
     Output: mass, volume, surface area, center of mass, principal moments and axes of
             inertia, Euler parameters for transformation from inertial to principal
             axes coordinates

3. 6-dof units conversion

     Input : mass properties, gravity, applied forces/moments, etc. in dimensional units
     Output: corresponding parameters in non-dimensional units suitable for input to
             OVERFLOW-2 flow solver


The OVERFLOW button is used to access windows for preparing namelist input for the standard version of OVERFLOW (version 1.8+).


The OVERFLOW-2 button is used to access windows for preparing namelist input for the OVERFLOW-2 flow solver (version 2.0s+). Buttons are also available to execute the off-body Cartesian grid generation function, and the domain connectivity function of OVERFLOW-2.


This tool can be used to view different frames of grid and solution where each frame can contain one or more grid and solution surfaces. The following options are available.
                                         Grid frame       Solution frame
Steady state cases                           1                  1      
Steady/unsteady cases at different times     1               multiple
Moving/adaptive grid cases                multiple           multiple

Begin by specifying the surface slices to be read under Surface Specification. By default, the L=1 slice of each grid in current memory is automatically selected. For cases with adaptive grids, enter the number of near-body grids whose dimensions remain fixed with time. A cut plane option is available for extracting constant x, y, or z cuts on off-body Cartesian grids. The grid slice subsets defined here can be saved to a file for reload at another time.

The next step is to pick single or multiple frame for grid and q and read the files. The PLAY button will automatically cycle through the frames if multiple frames are read. The REC button will play and save each frame to a png image file, and the collection of png files can then be processed into a movie using an external program such as ffmpeg. Function options are available to plot all q variables in the q files, including those from turbulence models and species partial densities, common functions such as Mach number and velocity vectors. A log option is allowed for showing scalar functions. The function display can be made to appear in grid wireframes or contours.

After quitting this module, the grid and solution frames are released from memory. These have to be read in again for further viewing.

WARNING: there is currently no check for negative densities.


This interface can be used to prepare the input and execute the debris tracing code DEBRIS. Seven types of shapes are supported: general, box, cylinder, sphere, tumbling disk, disk with broadside to flow and frustum. For different shapes, different initial condition parameters are supported with two options for sample variation: uniform or random. For each parameter, a min and a max value are needed. For uniform distribution, the number of samples per parameter is specified and the samples are distributed uniformly over the given minmax range. For random distribution, the total number of samples is prescribed. For each such sample, a random value over the given range is automatically generated.

Currently, the initial positions are restricted to constant L surfaces. A convenient way to prescribe the initial positions is to click on the `Use highlighted' button to copy a highlighted subset (lower right window) into the J,K,L range entries for initial positions. For a uniform distribution, the initial velocity direction is the local surface normal direction if only one entry is prescribed. If more than one entry is prescribed, the initial velocity direction is varied over a hemisphere with axis aligned with the local normal. Display of initial positions and velocity vector directions can be toggled via the appropriate checkbuttons.

Clicking the DEBRIS button will execute the code (assumed to be in user's path or in the CGT bin directory) and display the trajectories in the graphics window. The impact points on L=1 surfaces are colored by the impact speed. Note that when `Minimal output' is selected, there is no information to determine impact points. In this case, all trajectories are assumed to end in impact points. Work is in progress to add various options and filters for viewing the trajectories.

An input file for the DPREP input preparation batch code is automatically written to ogdprep.i. This can be used to generate the DEBRIS code input file in batch mode.


This tool is used for viewing prismatic (strand) grids in the SAC format created by the sprout code, and AMR Cartesian grids. For the strand grid, intersection of the constant coordinate cut plane with each prism cell is computed which may result in 3, 4, or 5 intersections. The intersection polygons are then displayed as triangles, quads or pentagons. The following options are available for visualization of the cut plane intersections:

1. Display prism cut cells as wireframes, colored by same color or by component ID of triangles on surface triangulation

2. Display prism cut cells as shaded polygons which will reveal gaps between the trimmed prism cells

3. Highlight the cut cell polygons that belong to fringe cells which will show whether these are surrounded by any donor cells.

4. Display neighboring strands that straddle the cut plane.

5. Display the surface triangle face index for each intersection polygon. Each intersection polygon comes from a prism cell which belongs to a prism stack that can be traced down to a surface triangle. This option provides a map of the prism stacks and shows where they terminate on the cut plane and if they terminate at a fringe cell.

On the same display, the user can read in AMR Cartesian grids (in PLOT3D format for now) and display the different levels at the specified cut plane. Options are available to color by level, display wireframe grid lines or display just the grid bounding box outline. Having the prism cut and Cartesian cut in the same display provides a valuable tool for checking the AMR grid generator and for debugging interpolation stencil problems.

To be implemented


Chan, W. M., "Enhancements to the Grid Generation Script Library and Post-Processing Utilities in Chimera Grid Tools," 9th Symposium on Overset Composite Grid and Solution Technology, State College, Pennsylvania, October, 2008.

Chan, W. M., CAD Interface, Strand Grid Technology, and Other New Developments in Chimera Grid Tools 2.0, Proceedings of the 8th Symposium on Overset Composite Grids and Solution Technology, Houston, Texas, October, 2006.

Chan, W. M., The OVERGRID Interface for Computational Simulations on Overset Grids , AIAA Paper 2002-3188, 32nd AIAA Fluid Dynamics Conference, St. Louis, Missouri, June, 2002.

Chan,, W. M., Meakin, R. L. and Potsdam, M. P., CHSSI Software for Geometrically Complex Unsteady Aerodynamic Applications, AIAA Paper 2001-0593, January, 2001.

Murman, S., Chan, W. M., Aftosmis, M. J., Meakin, R. L., An Interface for Specifying Rigid-Body Motions for CFD Applications, AIAA Paper 2003-1237, 41st Aerospace Sciences Meeting and Exhibit, January, 2003.

Chan, W. M., Innovative Software Streamlines Overset Grid Generation , NAS News, Vol. 3, No. 3, May-June, 1998.


Funding for this work has been provided by the NASA Constellation Program under the Ares-V, Ares-I, and CEV projects. Past sponsors include the NASA CICT/CNIS Program the NASA High Performance Computing and Communications Program, the DOD HIARMS project, the DOD High Performance Computing Modernization Program under the CHSSI CFD-4 Project, the Advanced Subsonic Technology Program, and the Space Shuttle Program.

Questions and Comments

Questions and comments can be directed to William M. Chan at William.M.Chan@nasa.gov
Last modified: Tue Mar 09 11:29:00 2010