WO2000021003A1 - Method and system for mesh generation - Google Patents

Abstract

A method and a system are provided for deriving a mesh from a picture, design, or any other image information source. The method comprises steps of dividing the image into a grid of cells of arbitration resolution, assigning to each cell in the mesh a property, creating a correspondence table relating a cell property found in the image to a specific information, and generating a heterogeneous mesh, reflecting the information in the correspondence table, the mesh being suitable for execution of a numerical procedure.

Description

Method and System for Mesh Generation

Shmuel L. Weissman

CROSS-REFERENCE TO RELATED APPLICATIONS

This application depends for priority upon U.S. Provisional Patent Application Serial No. 60/103,634, entitled METHOD AND SYSTEM OF MESH GENERATION FOR QUASI-CHAOTIC ASSEMBLAGES filed October 8, 1 998, which is incorporated herein by reference.

BACKGROUND OF THE INVENTION 1 . Field of the Invention

The present invention relates generally to a method for calculation and implementation of numerical simulation meshes in quasi-chaotic systems, and more particularly to mesh generation for systems containing a very large number of heterogeneous components.

2. Definitions

The following glossary of terms will prove helpful to the reader in understanding the method and system of the present invention.

Chaotic geometry: A geometry that cannot be described by simple mathematical means; Geometrical: Division of a domain into smaller "simple" sub-domains resulting in a discretization mesh or grid;

Domain: A part of space of interest;

Grid/Mesh: A discrete geometric representation of a specific domain;

Image: A mapping that defines what objects fill individual cells in a grid;

Process: A phenomenon marked by changes that lead toward a particular result;

Quasi-chaotic geometry: A geometry composed of a large number of regular and irregular sub-geometries. Finite element: A numerical method for solving differential equations. 3. Description of the Available Art

Abstract processes can be described by partial differential equations, known in the art as "PDEs." PDEs can also be used to describe specific processes when tailored to a specific domain. Such specific problems, together with end conditions (known in the art as boundary conditions) are referred to in the art as boundary value problems ("BVPs"), or, if time is involved as well, initial boundary value problems ("IBVPs").

Analytical (or exact) solutions for BVPs and IBVPs are available only for the most simplistic cases. For more complex cases, process description can only be approximated through the use of numerical methods such as finite elements, finite differences, and boundary elements. The fundamental idea common to all of these numerical methods is that of divide and conquer. The most straightforward manifestation of the divide and conquer approach is the finite element analysis ("FEA") method. Finite element technology became a significant design tool when, in the early 1960s, engineers at Boeing found FEA useful to analyze aircraft structures. Indeed, it was Boeing's Dr. Clough who coined the term "Finite Elements." Since then, the finite element method has matured and is now the main tool used in modeling aerospace, automobile, civil, and mechanical engineering problems.

FEA utilizes a mesh overlaid upon a representation of the subject matter

(domain) under analysis. The first step in FEA is dividing the domain of interest into many small and geometrically simple (e.g., triangles or squares, or their three- dimensional equivalents, pyramids and cubes), non-overlapping sub- domains (i.e., such that there is a one-to-one mapping of points contained in the representation of the global domain into the assembly of sub-domains). This process is referred to as "geometrical discretization" or "mesh construction."

In each of these sub-domains a number of key points are selected. For example, if the sub-domain is contained in a three-dimensional space and has the shape of a brick, then a common choice is to select the eight corners of the brick as the key points. In finite element terminology, these key points are referred to as nodes. The geometry of the sub-domain is next determined by interpolation or approximation of the nodes. It is important to note that granularity begets precision — that is, the true geometry of a domain can be better approximated if the domain is divided into a larger number of smaller sub- domains, or if each sub-domain is allowed a more complex description, or if these two approaches are somehow combined. Next, the values of the state variables of the process (e.g., temperature) at the nodes are interpolated as well. The interpolation is constrained to maintain a desired minimal degree of continuity across the elements' boundaries, in accordance with the governing PDEs. In this manner, an infinitely dimensional problem is reduced to a finite dimensional one (i.e., a finite number of unknowns describes the entire process throughout the domain). Moreover, because the interpolation functions are known entities, it is possible to compute all the derivatives explicitly and at the element level. As a result, the problem is converted from solving PDEs into the solution of a finite system of algebraic equations.

A repetition of this simple process can approximate a more complex global process. Again, just as with geometry, approximation may be improved if either the number of processes is increased, or the complexity of each simple process is allowed to increase, or a combination of the two.

The most common approach to FEA is to use the same interpolation technique for both geometry and process description. Elements formulated with this approach are referred to as "isoparametric elements," and the interpolating functions are termed "shape functions." The shape functions are typically constructed so that at every point within the domain they sum to 1 , ensuring a one-to-one mapping of points within the domain. As a result, if the nodal values in some parts of a mesh change but the values of the nodes associated with a specific element did not, then the process within that element remains unchanged.

In early use of FEA, users manually specified the locations of each node, and the nodes connected to each element. However, as models grew to include millions of nodes and elements in single meshes, this approach became inadequate, and automatic mesh generators emerged (e.g., PATRUN, available from MacNeal Schwendler Corporation). These mesh generation schemes, also referred to in the relevant art as pre-processors, generate meshes through graphical user interfaces ("GUIs"). The approach is to divide the body under analysis into sub-systems that can be approximated using regular shapes, or using "b-splines" and "b-surfaces." These "regular" shapes are then discretized using automatic algorithms, where the user simply specifies a typical element size and the types of elements to use throughout the domain.

While such mesh generation procedures are well suited to many applications, there is a small, but important, class of problems for which these procedures break down. In the available method, users are required to specify the outline of each component and then the procedure to fill in the actual finite element mesh. However, for chaotic or semi-chaotic geometries (referred to herein in combination as quasi-chaotic assemblages), including microprocessors and other integrated circuit devices made through a photolithographic process, the shear number of components renders the current approach non-feasible (it would require too much time for effective execution). Therefore, a new procedure is required that will minimize or eliminate user involvement in mesh generation for quasi-chaotic assemblages.

SUMMARY OF THE INVENTION

The present invention addresses the shortcomings of the available art by providing an improved method for deriving a mesh from a picture, design, or any other image information source. The method comprises a) dividing the image into a grid of cells of arbitrary resolution; b) assigning to each cell in the mesh a property; c) creating a correspondence table relating a cell property found in the image to a specific information; and d) generating a heterogeneous mesh, reflecting the information in the correspondence table, the mesh being suitable for execution of a numerical procedure.

A first advantage of the present invention is therefore the time savings allowed the user in generating a mesh suitable for a quasi-chaotic assemblage.

Another advantage of the present invention is the enablement of rapid system modeling for quasi-chaotic assemblages.

It should be noted that in providing these and other advantages, mapping of cell properties into modeling properties (materials and element types) need not be one-to-one. For example, one could map a number of cell properties to the same material.

These and other advantages of the invention, as well as the details of a preferred embodiment, will be more fully understood from the following specification and drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates a quasi-chaotic two-dimensional mesh of a two-phase material. FIGs. 2 and 3 provide flowcharts illustrating the method of the present invention as it might be implemented as an executable software program.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT Referring first to FIG. 1 , there is illustrated a quasi-chaotic two- dimensional image of a two-phase material (a simplified asphalt image, in this case) including a few thousand objects. To construct a mesh for this image using the method of the present invention requires only a few minutes of human effort, and a small amount of average-speed computer time. By contrast, using the conventional methods found in commercial finite element packages today would require days of human time to construct a less efficient mesh.

Applying the method of the present invention to the image of FIG. 1 involves, first, dividing the volume into a number of regions and matching adjacent regions at their shared boundary. This objective can be achieved by having the same division on the boundary, or using master-slave algorithms, or employing generalized contact algorithms, as will be understood by those skilled in the art.

In many quasi-chaotic systems such as integrated circuits (chips) and composite materials (e.g., asphalt concrete and cement concrete), the system under analysis is characterized by a large number of distributed components wherein events take place, and an equally large number of components, occupying most of the domain, wherein little variation is found. From a practical perspective, these low variation zones are of interest only in so far as it is desirable to know what is happening at their boundaries (i.e., where they come in contact with the other, more-meaningful and varied components). Thus, the general procedure of the present invention can be described as follows.

First, an image is generated, or an image source designated (in many instances the starting point for the mesh construction is either a picture, or the output of a CAD system). Next, properties are assigned to each discrete image element, which are referred to as "pixels" in imaging terminology, and a correspondence table is created. Next, a mesh is generated for each property. Finally, all meshes are joined using standard techniques, as will be understood by those skilled in the relevant art.

In a preferred embodiment, a volume (area in two dimensions) mesh is generated only for those properties deemed above a certain threshold of interest. For properties considered to be of marginal importance, only the boundaries are modeled, preferably by boundary elements. Finally, all meshes are combined into a single global mesh using the standard techniques described above and known to those skilled in the relevant art. It should be noted that it is possible to perform this procedure in stages where after generating a number of sub-meshes, they are joined into combined sub-meshes, thus possibly reducing the amount of system resources required to carry out the mesh generation.

Where an image already exists, the user need only specify the image source, identify the size of the image, and provide a relational table relating image properties (e.g., color) to a specified property type. Next, if the user wishes to use different types of approximations for different parts (e.g., identified by different colors in the image), the user need only repeat these steps, each time masking all but the relevant portion (i.e., only a fraction of the total mesh is generated with each pass). After all parts of the mesh are formed, they can be easily integrated into a single mesh using available mesh generation products. Thus, the contrast to the available art is clear. Under existing schemes, the user must delve into the details of the mesh to identify each component, which for quasi-chaotic assemblages may be in the millions. With the method and system of the present invention, this process is primarily performed by a computer through the construction of a correspondence table.

Using this approach, good simulation accuracy can be achieved using much simpler meshes than those provided by the methods of the available art. Moreover, the amount of time required to manually generate meshes remains very small. For example, using this approach can reduce the number of elements found in a mesh for FIG. 1 by a factor of two and the amount of total simulation time by a factor of 10 or more. Manual time for mesh generation remains a couple of minutes, while computer time (using a simple personal computer) is only about 20 minutes— still a small amount of time compared with standard mesh-generation procedures.

One particular, and preferred, application of the method and system of the present invention is in the modeling of integrated circuit devices dies. A particular device die might include millions of individual components. Modeling such a device can be accomplished by one of two ways using the method and system of the present invention. With an image source, such as a three-dimensional ("3D") image of a chip, or a two-dimensional ("2D") image of a chip subsection if desired, each transistor type is easily identified through a certain display property, such as color. A relational mapping table is then created that maps each type of component (identified in the image by a color in our example) with a specified model. It should be noted that such mapping does not have to be one-to-one (for example many colors may be mapped to a single model).

To further decrease any inefficiencies found in the above-described device die modeling method, a second, more economical method may be preferred. A relational map is created. Next, a mesh is generated for those components considered above a certain "importance" threshold. At the end of this step, there remain voids where there are missing components or insulation layers. Finally, boundary elements are generated on the surface defining the less important components. These surfaces coincide with the boundaries of the important objects or the boundary of the chip itself.

If computer resources are limited, the chip may be subdivided into non- overlapping sub-components, and either of the two described processes would be repeated for each of the sub-components. The analysis phase could be carried out using sub-structuring techniques. This additional partitioning step reduces the amount of computer memory needed for building a complete mesh, thereby potentially reducing costs.

Where the image provided represents a set of masks destined for a production line, the approach is somewhat more elaborate and requires more intensive computing resources. A uniform mesh is generated for the chip, where any subdivision is only geometrical, and not by component type. A mask is then used to "tunnel" the chip (that is, to define a set of elements that are eliminated). Relational maps are then used for doping and calculating metal deposits to add to materials, and to identify properties. Tunneling and mapping is repeated for every mask layer, and boundary elements are placed on the boundary of the "voids" left after tunneling.

To further describe the method and system of the present invention, and to fully enable the reader of this disclosure to execute the invention, the included software code illustrates a complete system and method for generating a 2D mesh of 4-node quadrilateral elements. The generated meshes have arbitrary detail complexity, useful for modeling quasi-chaotic systems. In reviewing the provided code, it should be noted that: 1 ) If mesh generation is successful, the code returns a value of 1 . If a NULL pointer to the image file is received, the provided code returns a value of -1 . If the function failed to get requested memory from the system, the provided code returns a value of -2. In either case where the function failed to generate the mesh, the memory allocated will be released.

2) Element and node numbers are not stored explicitly. Rather, they are obtained from the location of the node/element in the respective coor/elCont arrays. Therefore, to comply with "C" programming conventions, the element/node numbering starts with zero, and the node connectivity entries in elCont refer to the row number in the coor array.

3) It is up to the user to provide the association vector "mat," which relates values in the image file to actual material models. The provided code does not check for errors in mapping, which may lead to an erroneous mesh generation and even to segmentation violation. Error checking could be easily added by one skilled in the relevant art. An error should occur only if the image file contains values larger than the dimension of the mat vector.

4) By convention, a value of 0 entered in the mat vector indicates to the provided code that when a number corresponding to this entry on the image file is encountered, no element is generated.

5) Execution begins with allocation of memory for all possible nodes and elements. Excess memory is released before exiting this function.

6) The node numbering resulting from the provided code is not optimal. Therefore, the user is advised to renumber the nodes in order to minimize system bandwidth requirements.

7) The provided code generates meshes bounded by a rectangular in an active coordinate system. A generalization of the exemplary method and system provided into nonrectangular meshes is straightforward, and can be obtained by simply replacing the linear interpolation used in the provided code in generation of the nodal coordinates, as will be understood by one skilled in the relevant art. 8) The provided code is built around the assumption that the image file is first ordered by x, then by y (i.e., the image is stored row-wise).

In sum, the provided code would be used in combination with techniques well known in the relevant art to execute the following steps:

a) dividing the volume of interest into a uniform grid of arbitrary resolution (selected to meet the needs of the numerical simulation - this process is termed "pixelation" in image processing);

b) assigning to each cell in the grid a property (e.g., color - unless the process begins with an actual image, in which case this step would be redundant)

c) creating a correspondence table relating a cell property to specific mesh information (e.g., material and element type);

d) generating a mesh for the numerical procedure (e.g., using a finite element method - the geometry of each element being fully defined by the geometry of each cell in the grid, and the material and type of element being defined by the correspondence table and cell property).

This code is subject to the copyright of the assignee of the present invention.

CODE LISTING

/*INPUT: elType an integer indicating the type of element (e.g., 1 isoparametric, 2 b-bar) fimage pointer to a file containing the image (an array of integers) mat array containing points correlating number in the image file with specific material models. By convention mat[i] = 0 indicates that no element should be generated. Note: it is assumed herein that the dimension of mat is greater than the largest integer in the image file xRange ranges of x and y coordinates xRange[0][0] = xMin xRange[0][1 ] = xMax xRange[1 ][0] = yMin xRange[1 ][1 ] = yMax xDiv number of elements in the x direction yDiv number of elements in the y direction OUTPUT: coor an array of nodal coordinates coor[0] node number coor[1 ] x-coordinate coor[2] y-coordinate elCont element connectivity array (nodes are numbered counter-clockwise) elCont[0] element material type elContπ ϊ number of node # 1 elCont[2] number of node # 2 elCont[3] number of node # 3 elCont[4] number of node # 5 numElmt number of elements generated numNode number of nodes generated

7

#include < stdio.h > #include < stdlib.h > #include < string. h > #include < math.h >

#define FAILED -1 #define MEMFAIL -2 #define SUCCESS 1

int mesh2DQ4(FILE *f image, double * * *coor, double xRange[2][2], int *mat, int * * *elCont, int *numNode, int *numElmt, int xDiv, int yDiv) { double dx, dy, x, y; double * *ICoor; int I, j, k, m, n; int prop; int xDiv1 , yDiv1 ; int *INode, * *elC; int elNode[5];

/* Make sure fin does exist */ if(fimage = = NULL) { return FAILED;

}

/* define number of nodes & elements in a fully populated mesh */ xDivl = xDiv + 1; yDivl = yDiv + 1; *numNode = xDivl * yDivl; *numElmt = xDiv * yDiv;

/* allocate memory for local coordinates & elements */

ICoor = (double **) calloc(*numNode, sizeof (double *)); jfdCoor = = NULL) { return MEMFAIL;

} ICoorfO] = (double *) calloc(*numNode * 2, sizeof(double)); if (ICoor[0] = = NULL) { free(ICoor); return MEMFAIL; ford = 1; I < *numNode; l+ +) {

ICoorfi] = ICoor[i-1] + 3; } elC = (int **) calloc(*numElmt, sizeof (int *)); if(elC = = NULL) { free(ICoor[0]); free(ICoor); return MEMFAIL;

} elC[0] = (int *) calloc(*numElmt * 5, sizeof(int)); if(elC[0] = = NULL) { free(ICoor[0]); free(ICoor); free(elC); return MEMFAIL; } for(l = 1; I < *numElmt; l+ +) { elCϊi] = elC[i-1] + 5; }

INode = (int *) calloc(*numNode, sizeof(int)); if(INode = = NULL) { free(ICoor[0]); free(ICoor); free(elC); free(INode); return MEMFAIL;

}

/* Generate nodes */ dx = (xRange[0][1] - xRange[0][0]) / xDiv; dy = (xRange[1][1] - xRange[1][0]) / xDiv; k = 0; y = xRange[1][0]; ford = 0; I < yDivl; I++) { x = xRange[0][0]; for(j = 0; j < xDivl; j+ +) { INode[k] = 0; /* mark as unattached */ ICoor[k][0] = x; /* x coordinate */ ICoor[k][1] = y; /* y coordinate */

+ +k; x + = dx; } y + = dy;

}

/* Generate elements */

*numElmt = 0; ford = 0; I < yDiv; I++) { for(j = 0; j < xDiv; j+ +) {

/* Get property for next element */ fscanf(fimage, "%d", &prop); if (prop = = EOF) { free(ICoor[0]); free(ICoor); free(elC[0]); free(elC); free(INode); return FAILED;

}

/* mesh is generated only for elements whose mat[prop] != 0 */ if (mattprop] I = 0) { elNode[1] = I * yDivl + j; elNode[2] = elNode[1] + 1; elNode[3] = elNode[2] + xDivl; elNode_4J = elNode[1] + xDivl; elC[*numElmt][0] = mat[prop]; for(m = 1; m < 5; m++) { elC[*numElmt][m] = elNode[m];

INodetelNodelm]] = 1;

}

+ +(*numElmt); }

}

/* number used nodes */ m = 0; ford = 0; I < *numNode; l+ +) { if(INode[i] == 1) {

INodeii] = m + + ; } else { INodeii] = -1;

, } }

I = *numNode;

*numNode = m; m = I;

/* move all used nodes to start of list */ k = m; do {

-k; } while(INode[k] = = -1 ); ford = 0; I < k; I + + ) { if (INodeii] = = -1 ) { INodeii] = INodelk]; INodelk] = I; for(n = 0; n < 2; n + + ) { ICoorlilln] = ICoor[k]In];

} do {

~k; } while(INode[k] = = 0 && k > I); > ^}

/* modify element's connectivity */ {

/* free local memory and excess element memory */ free(&elC[*numElmt][0]); free(elC + *numElmt); free(INode); free(&ICoor[*numNode][0]); freejlCoor + *numNode);

/* set pointers and return */ *elCont = elC;

*coor = ICoor; return SUCCESS; }

END

Referring next to the flowcharts of figures 2 and 3, the inventive process begins by obtaining an image of the desired object, as illustrated in FIG. 2. The image is then discretized at a desired resolution, and each cell is assigned a property (e.g., color). Each property is assigned a priority, which can be as simple as "important" or "unimportant." A table is then generated that relates the image property to mesh attributes such as element type, material model, and material constants. Next, each property used in the image is visited. For each property, all the image cells are visited and each is meshed according to the priority assigned to the property. If the property is above a specified threshold, then each cell is represented by a volume or area element in accordance with the specifications in the correspondence table. If the property has a priority less than the threshold, only boundary elements are generated along the boundary of the sub-domain occupied by the current property in the discretized image. (The flowchart of FIG. 3 describes the process of identifying the boundary, as described below).

After the mesh associated with the current property is generated, it is assembled into the global mesh, and the next property is addressed. When all properties have been addressed, the mesh is completed, and the procedure ends.

Turning next to FIG. 3, here it is assumed that the cells in the image are ordered in a vector, and they have been sorted by property. First, all cells in the image whose property is the current property are initialized by marking each edge of each cell with a zero. Next, all cells of current property are traversed, and 1 is added to each of the edges. When all the cells have been visited, the system returns to the first cell (of the current property). A new traversal of the cells then begins, changing the edge values for those edges whose value is greater than 1 to zero. Thus, upon completion of the second pass, all boundaries of the sub-domain associated with the current property are composed of all cell edges that are marked with 1.

Thus, a general description of the system and method of using the present invention as well as a preferred embodiment of the present invention have been set forth above. Those having skill in the art to which the present invention pertains will now, as a result of the applicant's teaching herein, perceive various modifications and additions which may be made to the invention. Accordingly, all such modifications and additions are deemed to be within the scope of the invention which is to be limited only by the claims appended hereto.

Claims

Claims

What is claimed is: 1 . A method of generating a mesh for a numerical method for mathematically modeling a domain, the method comprising the steps of: a) providing an image of the domain; b) dividing the image into a grid of cells of arbitrary resolution; c) assigning to each cell in the grid a property; d) creating a correspondence table relating each of the cell properties to a characteristic of an overall mesh.

2. The method of claim 1 further comprising varying overall mesh granularity in a manner dependent upon the correspondence table.

3. The method of claim 1 , wherein the numerical method comprises a finite element method.

4 A method of generating a mesh for numerical simulation of an integrated circuit device, the method comprising the steps of: a) providing an image of the device; b) dividing the image into a grid of cells, the grid having arbitrary resolution; c) assigning to each cell in the grid a device property; d) creating a correspondence table relating each of the device properties to a characteristic of a device mesh.

5. The method of claim 4, further comprising varying device mesh granularity in a manner dependent upon said correspondence table.

6. A system for generating a mesh for a numerical method for mathematically modeling a domain, the system comprising: a) means for providing an image of the domain; b) means for dividing the image into a grid of cells of arbitrary resolution; c) means for assigning to each cell in the grid a property; d) means for creating a correspondence table relating each of the cell properties to a characteristic of an overall mesh.

7. The system of claim 6 further comprising means for varying overall mesh granularity in a manner dependent upon the correspondence table.

8. The system of claim 6, wherein the numerical method comprises a finite element method.

9 A system of generating a mesh for numerical simulation of an integrated circuit device, the system comprising: a) means for providing an image of the device; b) means for dividing the image into a grid of cells, the grid having arbitrary resolution; c) means for assigning to each cell in the grid a device property; d) means for creating a correspondence table relating each of the device properties to a characteristic of a device mesh.

1 0. The system of claim 9, further comprising means for varying device mesh granularity in a manner dependent upon said correspondence table.

1 1 . A computer-usable apparatus useful for generating a numerical mesh, the system comprising means for: a) providing an image of a domain; b) dividing the image into a grid of cells of arbitrary resolution; c) assigning to each cell in the grid a property; d) creating a correspondence table relating each of the cell properties to a characteristic of an overall mesh.