Multiprocessor computer overset grid method and apparatus

Abstract

A multiprocessor computer overset grid method and apparatus comprises associating points in each overset grid with processors and using mapped interpolation transformations to communicate intermediate values between processors assigned base and target points of the interpolation transformations. The method allows a multiprocessor computer to operate with effective load balance on overset grid applications.

Claims

We claim:

1. A method for efficiently processing a field simulation acting upon or reacting to a geometrically complex configuration using an overset grid application on a multiprocessor computer, wherein an overset grid application comprises a plurality of overset grids and interpolation coefficients defining communication between points in different overset grids, comprising:

a) defining an overset grid application representative of a geometrically complex configuration;

b) associating each point within each overset grid with a processor by

determining the number of points within said overset grid to associate with each of the processors in the multiprocessor computer, wherein the processing load on each processor is balanced; and

for each processor, selecting said number points from said overset grid for association with said processor as a subgrid, wherein communication between said subgrids is minimized;

c) selecting an initial overset subgrid;

d) determining values for points in said initial overset subgrid;

e) selecting a second overset subgrid;

f) selecting interpolation transformations from base points in said initial overset subgrid to target points in said second overset subgrid, and using said interpolation transformations and said base points to determine field values for said target points;

g) repeating steps c) through g) using said second overset subgrid as the initial overset subgrid until a terminal condition of the field simulation is reached.

2. The method of claim 1, wherein the step of determining the number of points to associate with each processor comprises dividing the number of points in said overset grid by the number of processors in the multiprocessor computer.

3. The method of claim 1, wherein the step of selecting said number of points comprises dividing said overset grid into subgrids, wherein each of said subgrids corresponds to a processor and includes the determined number of points to be associated with said processor.

4. The method of claim 3, wherein the step of dividing said overset grid into subgrids includes adjusting the boundaries of each of said subgrids to minimize communications between subgrids.

5. The method of claim 4, wherein the subgrids are defined

for a 2 dimensional grid application, to minimize the total of the ratios of the perimeter distance to surface area for each of said subgrids; or

for a 3 dimensional grid application, to minimize the total of the ratios of surface area to volume of each of said subgrids.

6. The method of claim 1, wherein the step of associating each point within each overset grid with a processor further comprises, for each interpolation transformation, establishing communication paths from processors associated with base points of said interpolation transformation to processors associated with target points of said interpolation transformation.

7. A method of preparing a field simulation using an overset grid application for efficient operation on a multiprocessor computer comprising:

defining an overset grid application representative of a geometrically complex configuration;

partitioning each said overset grid into a number of subgrids equal to the number of processors upon which said grid application will be operated on by said computer;

associating each subgrid with a different processor;

forming a connectivity table identifying, for each interpolation t formation in the overset grid application, processors associated with said interpolation tansformation's base points and target points; and

processing said subgrids until a terminal condition of the field simulation is reached.

8. The method of claim 7, wherein the connectivity table further identifies, for each point on a boundary of a subgrid, processors associated with neighboring points in the same or adjacent overset grids.

9. The method of claim 7, wherein points for each subgrid are defined such that the total surface area to volume ratio of the subgrids is substantially minimized, which minimizes total communication time between subgrids for computational efficiency.

10. A method of efficiently operating a multiprocessor computer to process a field simulation acting upon or reacting to a complex geometry using an overset grid application, wherein said overset grid application comprises a plurality of overset grids partitioned into a number of subgrids equal to the number of processors, associations of points within each subgrid with a processor for that subgrid, and a connectivity table identifying processors associated with neighboring points on subgrid boundaries and processors associated by base and target points of interpolation transformations, said method comprising:

a) accepting definitions of a plurality of subgrids into the multiprocessor;

b) accepting associations of points within each subgrid with processors into the multiprocessor;

c) accepting a connectivity table into said multiprocessor;

d) selecting an initial overset subgrid from the overset grid application;

e) determining values for points in said initial overset subgrid;

f) selecting a second overset subgrid from said overset grid application;

g) using the interpolation transformations, said connectivity table, and said values for points in said initial overset subgrid to determine field values for some of the points in said second overset subgrid;

h) determining values for other field points in said second overset subgrid; and

i) repeating steps f) through h) using said second overset subgrid as the initial overset subgrid until a terminal condition of said field simulation is reached.

11. The method of claim 5 wherein the step of determining the number of points to associate with each processor comprises

dividing the number of grid points in all overset grids by a user-supplied number of subgrids, this result being an average number of grid points per subgrid;

dividing the number of grid points in each grid by the average number of grid points per subgrid, wherein a small remainder from this division is an indication of desirable load balance; and

increasing the number or size of subgrids if such change yields better load balance.

Description

BACKGROUND OF THE INVENTION

This invention relates to the field of multiprocessor computer operation, specifically efficient operation of multiprocessor computers using overset grids.

The overset grid approach for computing field simulations around geometrically complex configurations has been widely used since its inception in the early 1970s. The overset grid approach is attractive because a complex geometry can be divided into its inherently simpler parts while maintaining the overall complex geometry. Each part can then be gridded separately, a less complicated process than gridding the entire complex geometry. The grid can be computationally re-combined in a solver to yield a smooth solution within and across each grid domain. The overset grid approach has continued to mature in the serial computing environment, for example, seeing use in well-known compressible and incompressible Navier-Stokes flow solvers.

An overset grid application typically begins with a background grid. The background grid can cover the whole problem space. Other grids covering portions of the problem space can also be defined. For example, a fine grid can be defined covering a portion of the problem space where higher resolution is desired. The background and other grids can each be called an "overset grid". FIG. 1 illustrates these concepts. Overset grid G1 encompasses a problem space and corresponds to simulation of phenomena throughout the problem space. Overset grid G2 encompasses a region of the problem space near object J where higher resolution simulation is required. Interpolation transformations (not shown) allow values from one overset grid (for example, G1) to be used to establish values in the other overset grid (for example, G2), assuring that the simulation is consistent across both overset grids G1, G2. Overset grid G2 allows high resolution where high resolution is required, while overset grid G1 allows low resolution (and consequently low execution time) where low resolution is acceptable.

In operation, a computer determines values for points in a first overset grid. Boundary conditions for a second overset grid can be determined by interpolating selected values from the first overset grid or from other overset grids. The computer then determines values for the other points in the second overset grid. Selected values from the second overset grid can then be used in interpolations to determine boundary conditions for other overset grids. The process can repeat until a terminal condition is reached, such as, for example, convergence of a simulation.

Overset grid applications are well-suited for problems where varying resolution or varying problem complexity indicate different grids. Unfortunately, overset grids have not fared well on multiprocessor computers. The wide range of possible overset grid sizes can lead to poor load balance, limiting the multiprocessor computer's performance. Also, communication and interpolation of boundary conditions can be problematic when overset grids are subdivided amongst multiple processors.

Accordingly, there is a need for a multiprocessor computer overset grid method and apparatus that maintains substantial load balance and efficient communication and interpolation of boundary conditions in overset grid applications.

SUMMARY OF THE INVENTION

The present invention provides a multiprocessor computer overset grid method and apparatus that maintains substantial load balance and efficient communication and interpolation of boundary conditions in overset grid applications. The present method comprises associating points in each overset grid with processors and using mapped interpolation transformations to communicate intermediate values between processors associated with base and target points of the interpolation transformations.

Each point in each overset grid is first associated with a processor. An initial overset grid is then selected, and values for points in the initial overset grid are determined (for example, by computational simulation of physical phenomena). A second overset grid is then selected. Values can then be determined for points in the second overset grid that are target points of interpolation transformations from base points in the initial overset grid. Values can then be determined for the remaining points in the second overset grid. The process can be repeated, using the second overset grid as the initial overset grid, until a terminal condition is reached.

Static load balance can be fostered in the association of overset grid points with processors. Each overset grid can have a certain number of points assigned to each of the processors, for example, each processor can be assigned a substantially equal number of points from each overset grid if the workload associated with the points is substantially similar. Each processor will consequently have substantially the same workload during operation, assuring effective load balance. Additionally, the points in each overset grid can be assigned to processors to maximize efficiency, for example, by minimizing the surface area to volume ratio of each processor's assigned points if communication costs are of concern.

Advantages and novel features will become apparent to those skilled in the art upon examination of the following description or may be learned by practice of the invention. The objects and advantages of the invention may be realized and attained by means of the instrumentalities and combinations particularly pointed out in the appended claims.

DESCRIPTION OF THE FIGURES

The accompanying drawings, which are incorporated into and form part of the specification, illustrate embodiments of the invention and, together with the description, serve to explain the principles of the invention.

FIG. 1 is an illustration of an overset grid application.

FIG. 2 is a flow diagram according to the present invention.

FIG. 3 is a flow diagram according to the present invention.

FIG. 4 is an illustration of mapping of interpolation transformations, base points, and target points.

FIG. 5 is a flow diagram according to the present invention.

FIG. 6 is a flow diagram according to the present invention.

FIG. 7 is an illustration of message passing between processors.

FIG. 8 is an example of results attained with the present invention.

FIGS. 9(a,b,c) is an example of results attained with the present invention.

FIGS. 10(a,b) is an example of results attained with the present invention.

FIGS. 11 (a,b,c,d) is an example of results attained with the present invention.

FIGS. 12(a,b) is an example of results attained with the present invention.

FIGS. 13(a,b) is an example of results attained with the present invention.

DETAILED DESCRIPTION OF THE INVENTION

The present invention provides a multiprocessor computer overset grid method and apparatus that maintains substantial load balance and efficient communication and interpolation of boundary conditions in overset grid applications. The present method comprises associating points in each overset grid with processors and using mapped interpolation transformations to communicate intermediate values between processors assigned base and target points of the interpolation transformations.

FIG. 2 is a flow diagram according to the present invention. Each point in each overset grid is associated with a processor 21. An initial overset grid is selected 22, and values for points in the initial overset grid determined 23. For example, values can be determined by computational simulation of a physical process. A second overset grid is then selected 24. Interpolation transformations from base points in the initial overset grid to target points in the second overset grid can be used to determine values for the target points in the second overset grid 25. Values can then be determined for the remaining points in the second overset grid 26. For example, values can be determined for the remaining points by computation simulation of a physical process using values at the target points as boundary conditions. The process can be repeated, using the second overset grid as the initial overset grid, until a terminal condition is reached 27. For example, the process can be repeated for a selected number of timesteps, or until the values in the overset grids assume some selected characteristics.

FIG. 3 is a flow diagram of the association of points with processors. The points in each overset grid 31 are associated with processors. A number of processors to associate with an overset grid can be determined 32. All the processors can be associated with each overset grid. Alternatively, each overset grid can be associated with a subset of the processors. If less than all the processors are to be associated with the overset grid, then the determined number of processors is selected 33. Next, the number of points within the overset grid to associate with each of the selected processors can be determined 34. Where the workload per point is substantially equal, the number of points can be chosen so that number of associated points is substantially uniform across the selected processors. If the workload per point varies, the number of points can be chosen so that the workload across the selected processors will be substantially uniform. Similarly, if the processors capabilities vary, the number of points can be chosen so that execution time will be substantially uniform.

The determined number of points can then be selected from the overset grid for association with each processor 35. Selection of points can be accomplished in various ways. For example, points can be selected in a variety of randomly-dimensioned cubic subdomains. If the application has communication locality, and the multiprocessor can exploit communication locality, then points can be selected so that each processor has points associated therewith defining a subgrid of the overset grid. Communication efficiency can then be maximized by minimizing the surface area to volume ratio of the subgrids. The association of overset grid points with processors is accomplished for each of the overset grids in the overset grid application.

The association of overset grid points with processors also determines mapping of interpolation transformations. FIG. 4 shows an example of interpolation transformation mapping according to the present invention. Interpolation transformation f accepts values for base points B1, B2, B3, and B4 in overset grid G2 as inputs and yields a value for target point T1 in overset grid G1. Base points B1 and B2 from overset grid G2 are associated with processor Px. Base points B3 and B4 from overset grid G2 are associated with processor Py. Target point T1 in overset grid G1 is associated with processor Pz.

After values for points (including points B1, B2, B3, and B4) in overset grid G2 are determined, interpolation transformation f can be used to determine a value for target point T1 in overset grid G1. Interpolation transformation f must be mapped to allow communication with processors Px, Py (associated with its base points), and with processor Pz (associated with its target point). This can be done by establishing communication paths from processors Px, Py to processor Pz, and allowing processor Pz to process interpolation transformation f. Alternatively, a communication path can be established from processor Px to processor Py and allowing processor Py to process interpolation transformation f. A second communication path can then allow processor Py to communicate the value determined for target point T1 to processor Pz. Those skilled in the art will appreciate various other suitable mapping arrangements.

Information identifying processors associated with neighboring points in the same overset grid (where inter-processor communication can be required to solve a single overset grid) and points related by interpolation transformations (where inter-processor communication can be required to solve successive overset grids) can be maintained in a connectivity table accessible to each processor. A single global connectivity table can be maintained, although efficiency can suffer on distributed memory multiprocessors. On distributed memory multiprocessors, only those parts of the connectivity table required by the points associated with a given processor need be kept local to the processor. Accessing required information from the connectivity table accordingly can be a strictly local access, increasing the overall efficiency of the multiprocessor.

EXAMPLE IMPLEMENTATION

The method of the present invention was applied to overset grid applications in a software implementation known as "BREAKUP", described in "A User's Guide for Breakup: A Computer Code for Parallelizing the Overset Grid Approach," Barnette, Sandia National Laboratories SAND98-0701, April 1998, incorporated herein by reference. Details of the BREAKUP implementation are presented below, followed by sample results.

Overview

An overview flow chart for the BREAKUP parallel overset grid method is presented in FIG. 5. The flow chart illustrates that the method was designed to minimally impact the serial overset grid approach. The serial-to-parallel modifications needed to implement the approach involve the requirement that the grids need additional preparation for the parallel solver, and that the solver must be modified via message passing calls for use on a parallel computer. The method currently implemented is such that all codes, including BREAKUP, visualization codes, and pre- and post-processing codes, run on a workstation. The solver, of course, is run on a multiprocessor computer.

Overset Grid-to-Overset Grid Communications

Overset grids require the capability to communicate with overlapped or embedded grids. In the example implementation, PEGSUS 4.0, described by Suhs and Tramel in "PEGSUS 4.0 User's Manual," AEDC-TR-91-8, Calspan Corporation/AEDC Operations, Arnold AFB, Tennessee, USA, incorporated herein by reference, was used to generate interpolation coefficients for grid-to-grid communications where separate grids overlap. Solvers that are PEGSUS-based use the interpolation coefficients and data from other influencing grids to update boundary conditions in overlapped regions on each grid as the governing equations are solved. Other codes exist to generate the interpolation coefficients. However, BREAKUP was configured to read the output of PEGSUS only.

Parallel Overset Grid Construction

BREAKUP may be considered as a preprocessor to PEGSUS-based parallel solvers and, as such, represents the cornerstone to the parallel overset grid approach. An overview flow chart of BREAKUP is presented in FIG. 6. The primary purpose of BREAKUP is to prepare the output of PEGSUS for parallel computing. PEGSUS output includes the overset (known as composite in PEGSUS jargon) grids, the iblank array that flags grid points for special handling in the solver, and an interpolation coefficient file used for grid-to-grid communication. BREAKUP divides each overset grid into subgrids corresponding to the user-specified number of processors in a multiprocessor computer system (including heterogeneous multiprocessors, homogenous multiprocessors, and distributed computing environments). BREAKUP computes the total number of grid points, computes the average number of grid points per processor, and divides each grid into subgrids such that a near-uniform distribution of grid points exists on each processor. Separate overset grids are divided such that the grid's perimeter-to-area ratio in 2-D, or surface-to-volume ratio in 3-D, is minimized. The subgrids are assigned to individual processors in a sequential manner with no regard to optimal communication paths between adjacent processors. This means that in the BREAKUP implementation of the present invention there is no guarantee that two subgrids from different overset grids requiring high communications costs will lie adjacent or even close to each other to minimize latency. Such capabilities could be added, however. Breakup also constructs connectivity tables for intra-grid and overset grid communications.

Dividing the overset grids into subgrids results in a significant amount of message passing between processors, as illustrated in FIG. 7. This is due to the necessity for grid-to-grid communications as well as intra-grid communication. Intra-grid communication is defined as message passing between subgrids of a unique overset grid. Grid-to-grid communication is defined as message passing between subgrids of separate overset grids. For grid-to-grid communications, the additional boundaries resulting from forming subgrids requires appropriate interpolation coefficients corresponding to each new subgrid. The interpolation coefficients are the same as those computed by the PEGSUS code. BREAKUP searches the PEGSUS coefficients and correlates them to the appropriate subgrids.

As mentioned above, intra-grid communication results from overlapping subgrids of an individual, unique overset grid. Adjacent subgrids align point-to-point by definition and, therefore, require no interpolation coefficients. However, the solver must know where to send and receive boundary information for intra-grid, as well as grid-to-grid, communications. BREAKUP constructs connectivity tables for both grid-to-grid and intra-grid communications such that each processor has the correct data to update its subgrid. The table for grid-to-grid communications contains the processor location of each pair of interpolation coefficients and those points on other processors (i.e., subgrids) which require the coefficients. The solver must be modified to use the tables to update grid boundary data. More detail regarding connectivity tables is given below.

Load Balance

Load balancing on parallel processors means that each processor should have the same, or nearly the same, work. In practice, this can be difficult to achieve since the size of individual overset grids can significantly vary in any given problem.

The approach to load-balancing subgrids in BREAKUP is as follows. First, BREAKUP determines the total number of grid points in all grids and divides by the number of user-specified subgrids (or processors) required. This gives the average number of grid points per processor. Next, the number of grid points in each individual overset grid is divided by this number to give the total number of processors that will be dedicated to that grid. Of course, this number seldom, if ever, is a whole number. BREAKUP is programmed to sequentially enlarge subgrid boundaries within the said grid to encompass more grid points that remain after calculating the number of processors per grid. This process ensures that the subgrid boundaries remain flexible enough to encompass all grid points. Also, it keeps the impact on load balancing to a minimum while keeping fixed the number of processors assigned to that grid.

If it happens that many grid points are left over, it becomes possible to better load balance the original grids with a larger number of processors. In this case, the code outputs a message to the effect that the grids cannot be optimally subdivided on the specified number of processors. BREAKUP then calculates the nearest number of processors over which the grids would be better load balanced. The user is then queried to either input a new value for the number of processors required or accept the new number and continue.

It is possible that BREAKUP will be given a small enough grid that cannot be subdivided. In this case, BREAKUP will leave the small grid intact. The premise is that, if there are only a few, these relatively small grids will not have a significant impact on the load balancing of the entire set of overset grids. That is, only a few processors with very small grids will have to wait on the many other processors to finish a solution time step.

Speed-Up

Speed-up occurs by minimizing communications between subgrids and maximizing the computational work performed on each processor. Communication occurs at the grid boundaries and hence is proportional to the grid's surface area. Computational work is performed at each grid point and is therefore proportional to the grid volume. Hence, it is advantageous when subdividing the grid to minimize its surface area and maximize its volume. Once the number of processors assigned to each overset grid is known, BREAKUP determines all the 3-factors of that number and finds the minimum value of the ratio of subgrid surface area to volume.

Sample Breakup Output

An example of how BREAKUP handles load-balancing and speed-up will illustrate the process. Assume a user has the six grids shown in Table 1, with the grid size indicated by j, k, and l. Each grid has the total number of points listed.

        TABLE 1
        Grid #       j        k        l       Total Points
           1         3       77       53          12243
           2         3       249      20          14940
           3         3       240      20          14400
           4         3       135      20           8100
           5         3       234      20          14040
           6         3       133      20           7980

    TABLE 2
                                                     Number of
                              Average number of grid processors for
    Grid #  Total points in grid points per processor   each grid
       1          12243               4481               3
       2          14940               4481               3
       3          14400               4481               3
       4          8100                4481               2
       5          14040               4481               3
       6          7980                4481               2

              TABLE 3
              ITAG          J           K           L
                1           1           1           3
                2           1           3           1
                3           3           1           1

           TABLE 4
             ITAG          surf/vol        min(surf/vol)
              1            0.805848           0.805848
              2            0.782325           0.782325
              3            2.063710           0.782325

          TABLE 5
          N/Jmax = 1/3 ==> approx. 3 pts/subgrid in J direction
          M/Kmax = 3/77 ==> approx. 26 pts/subgrid in K direction
          P/Lmax = 1/53 ==> approx. 53 pts/subgrid in L direction

                             TABLE 6
                  Final subgrid dimensions are:
    Grid#  Jcube   Kcube    Lcube   Jmax    Kmax    Lmax   Total
      1      1       1        1       3      27      53    4293
      2      1       2        1       3      26      53    4134
      3      1       3        1       3      26      53    4134

    TABLE 7
    cZone#  Jbeg  Jend  Jinc  Kbeg  Kend  Kinc  Lbeg  Lend  Linc
       1      1     3     1    27    27     1     1    53     1
       2      1     3     1     2     2     1     1    53     1
       2      1     3     1    28    28     1     1    53     1
       3      1     3     1     2     2     1     1    53     1
       2      1     3     1     1     1     1     1    53     1
       1      1     3     1    26    26     1     1    53     1
       3      1     3     1     1     1     1     1    53     1
       2      1     3     1    27    27     1     1    53     1
       4      1     3     1    85    85     1     1    20     1
       5      1     3     1     2     2     1     1    20     1

                                    TABLE 8
                              477 Base subzone #1
     1  22  43   0.0000000E+00   6.2530622E-02   3.8906133E-01   4   1  76  20
     1  22  43   0.0000000E+00   2.5979275E-01   4.2713684E-01   4   1  73  20
     1  21  43   1.0000000E+00   8.2356793E-01   2.7348068E-01   4   2  79  20
     2  21  43   1.0000000E+00   9.1715431E-01   3.2546192E-01   4   3  78  20
                             1035 Base subzone #2
     1  15  46   0.0000000E+00   2.9964754E-01   9.7948408E-01   4   1  12  20
     1   6  35   1.0000000E+00   2.9722536E-01   6.7863387E-01   4   2  28  20
     1  15  48   0.0000000E+00   5.0462323E-01   9.6113777E-01   4   1   5  20
     2  16  49   1.0000000E+00   5.2282799E-01   3.2107067E-01   4   3   2  20

        TABLE 9
        main                       chooser
        base_search                average
        get_zone                   break (see above)
        breakup_for_fun            link_overlap
        average                    patch_2d
        break                      link_overset
        get_global_index           decimate
        global_indices             get_global_index
        grid_point_comparison      get_zone
        min_surf_vol_ratio         sort
        out1planetoplt3d_break     index
        get_global_index           nobreak
        read_zone                  decimate
        read_zone_header           get_zone
        out1planetoproc_break      out1planetoplt3d_nobreak
        get_global_index           read_zone
        read_ibplot                read_zone_header
        read_intout                out1planetoproc_nobreak
        read_zone                  read_ibplot
        read_zone_header           read_intout
        outallplanestoplt3d_break  read_zone
        get_global_index           read_zone_header
        read_zone                  outallplanestoplt3d_nobreak
        read_zone_header           read_zone
        outallplanestoproc_break   read_zone_header
        get_global_index           outallplanestoproc_nobreak
        read_ibplot                read_ibplot
        read_intout                read_intout
        read_zone                  read_zone
        read_zone_header           read_zone_header
        subgrid_dimensions         read_zone
        write_subgrids             read_zone_header
        get_global_index           sort (see above)
        global_indices             footer
        grid_point_comparison      fdate
        min_surf_vol_ratio         header
        read_grid_header           fdate
        subgrid_dimensions         read_compout
        write_subgrids (see above) read_ibplot
        breakup_grids              write_grids
        average                    read_intout
        break (see above)          target_search
        read_grid_header           get_zone
        (continued next column)    write_base_target_points
                                   write_unravel

            TABLE 10
            INTOUT             interpolation coefficient file
            COMPOUT            composite (overset) grid file
            IBPLOT             iblank file

    TABLE 11
    UNRAVELED              main output file to show user what BREAKUP did
    BREAKUP.OUT            condensed version of screen output
    POINTS_OUT             PLOT.D file for interpolation and boundary points
    MESH_OUT               PLOT:D file for the `iblank`ed mesh
    3D_OVERSET_TABLE       file containing base (points used for interpolation)
     and target zones
                           (points to be interpolated), indices, interpolation
     coefficients
    2D_OVERSET_TABLE       decimated version of file 3D_OVERSET_TABLE for
     two-dimensional
                           problems
    GRIDS2D                PLOT3D file for all 2-D grids or subgrids
    GRIDS3D                PLOT3D file for all 3-D grids or subgrids
    3D_PATCH_TABLE         table of 3-D grid overlap links between subgrids of
     an overset grid
    2D_PATCH_TABLE         table of 2-D grid overlap links between subgrids of
     an overset grid
    GRID_ORIGINAL.G        Original grid file in subroutine
    GRID_DIVIDED.G         PLOT3 D file of subgrids generated by BREAKUP
    2Dxxxx.FMT             2D subgrid files where each subgrid is written to a
     separate file; xxxx =
                           0000 to 9999
    3Dxxxx.FMT             3D subgrid files where each subgrid is written to a
     separate file;
                           xxxx = 0000 to 9999

• Inventors
  Barnette, Daniel W.; Ober, Curtis C.;
• Assignee
  Sandia Corporation (Albuquerque, NM)
• Published
  Feb-11-2003
• Current US Classes:
  703/2
  703/22
  718/105
• Application #
  078895
• International Classes
  G06F 017/50; G06F 017/17
• Field of Search
  703/2 703/22 709/100 709/104 709/105 709/106 709/245
• Examiner
  Frejd; Russell
• Agent
  Grafe; V. Gerald, Libman; George H.
• US Patent References:
  5371852