CN114880981B - Script generation method for parameterization unit - Google Patents
Script generation method for parameterization unit Download PDFInfo
- Publication number
- CN114880981B CN114880981B CN202210650375.7A CN202210650375A CN114880981B CN 114880981 B CN114880981 B CN 114880981B CN 202210650375 A CN202210650375 A CN 202210650375A CN 114880981 B CN114880981 B CN 114880981B
- Authority
- CN
- China
- Prior art keywords
- create
- unit
- parameterized
- category
- field
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000013515 script Methods 0.000 title claims abstract description 50
- 238000000034 method Methods 0.000 title claims abstract description 34
- 238000013461 design Methods 0.000 claims abstract description 50
- 230000006870 function Effects 0.000 claims abstract description 33
- 238000011156 evaluation Methods 0.000 claims abstract description 14
- 230000008569 process Effects 0.000 claims description 7
- 239000002131 composite material Substances 0.000 claims description 4
- 238000004519 manufacturing process Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 239000004065 semiconductor Substances 0.000 description 3
- 239000012141 concentrate Substances 0.000 description 2
- 230000008676 import Effects 0.000 description 2
- 230000006872 improvement Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000011712 cell development Effects 0.000 description 1
- 238000010276 construction Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000033001 locomotion Effects 0.000 description 1
- 230000010076 replication Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F30/00—Computer-aided design [CAD]
- G06F30/30—Circuit design
- G06F30/39—Circuit design at the physical level
- G06F30/392—Floor-planning or layout, e.g. partitioning or placement
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F30/00—Computer-aided design [CAD]
- G06F30/30—Circuit design
- G06F30/39—Circuit design at the physical level
- G06F30/398—Design verification or optimisation, e.g. using design rule check [DRC], layout versus schematics [LVS] or finite element methods [FEM]
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02P—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN THE PRODUCTION OR PROCESSING OF GOODS
- Y02P90/00—Enabling technologies with a potential contribution to greenhouse gas [GHG] emissions mitigation
- Y02P90/02—Total factory control, e.g. smart factories, flexible manufacturing systems [FMS] or integrated manufacturing systems [IMS]
Landscapes
- Engineering & Computer Science (AREA)
- Computer Hardware Design (AREA)
- Physics & Mathematics (AREA)
- Theoretical Computer Science (AREA)
- Evolutionary Computation (AREA)
- Geometry (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Architecture (AREA)
- Design And Manufacture Of Integrated Circuits (AREA)
Abstract
The invention provides a script generation method for a parameterization unit, which comprises the following steps: 1) Importing a layout design category, wherein the layout design category comprises a geometric figure category, an entity operation category and an attribute category; 2) Defining parameter attributes and default values of the parameterized units; 3) Designing the content of the parameterized unit by defining an evaluation function; 4) Calling global compiling function, defining the layout name of parameterized unit and the name of the layout library to which the parameterized unit belongs. The invention simplifies the script programming steps of the parameterization unit, can flexibly select the script language under the same architecture, can reduce the design threshold of the parameterization unit and quickly generate the parameterization unit script.
Description
Technical Field
The invention relates to the technical field of semiconductor design and production, in particular to a script generation method for a parameterized unit.
Background
Whether new or existing, the special needs of customers require a rapid set of process design Packages (PDKs) by the semiconductor manufacturing industry before mass production can be introduced. In practice, the content of the process design package is a major part of the library of parameterized cells required for providing the design.
The current design method of parameterization units can be implemented in a script program mode, and a compiler translates a script into a parameterization unit database. Parameterized cell development is actually a parameterized layout design, and parameterized cell designers need a certain expertise for the construction mode of hierarchical geometric figures and need to be quite familiar with the layout design principle. In order to enable a programmer to develop scripts quickly, common geometric design units, such as layer definition, shape modification, movement, replication, edge-to-angle alignment, and the like, overlap among geometric figures, and even combination and hierarchical control among geometric figures are generally packaged into a function library or a layout design object library. When the script is programmed, a programmer can develop various parameterized unit scripts with different specifications by calling the functions or generating specific layout design objects, however, a complex script architecture increases the design difficulty of the parameterized unit scripts.
Disclosure of Invention
In order to solve the defects existing in the prior art, the invention aims to provide a script generation method for a parameterization unit, which simplifies the script programming steps of the parameterization unit, can flexibly select a script language under the same architecture, can reduce the design threshold of the parameterization unit and can quickly generate the script of the parameterization unit.
In order to achieve the above object, the script generation method for parameterization unit provided by the present invention includes the following steps:
1) Importing a layout design category, wherein the layout design category comprises a geometric figure category, an entity operation category and an attribute category;
2) Defining parameter attributes and default values of the parameterized units;
3) Designing the content of the parameterized unit by defining an evaluation function;
4) Calling global compiling function, defining the layout name of parameterized unit and the name of the layout library to which the parameterized unit belongs.
Further, the geometric classes include create curves, create bars, create rectangular rings, create circular rings, create points, create ellipses, create lines, create polygons, create rectangles.
Further, the entity operation class includes creating class instances, creating buses, creating composite components, creating graphics, creating through holes, creating device contacts, creating layer enclosures, creating paths, creating segment paths, creating text, creating net lines, creating groups.
Further, the attribute class includes an acquisition terminal point, an acquisition unit name, an acquisition coordinate unit, an acquisition instance name, an acquisition graph, an acquisition unit library name, an acquisition network line, an acquisition boundary, an acquisition process information, and a setting and acquisition access right.
Further, the parameter attribute and the default value of the defined parameterization unit take a list variable as the parameter attribute and the default value of the defined parameterization unit, and each list member adopts the same format: [ field 1, field 2, field 3, field 4], wherein
The field 1 is used for identifying a parameter value;
The field 2 defines the data type of the parameter, which may be the data type representing a character string, an integer, a floating value, a boolean value;
Setting a default value according to the field 2 by the field 3;
The field 4 defines the parameter name displayed to the user of the parameterization unit, facilitating the user's understanding of the use of each parameter.
Furthermore, the design category is further materialized by defining the content of the evaluation function, the relation between the geometric figure and the figure is created and edited according to the parameterized unit specification of the design through the grammar of the adopted script and the function library provided by the design category.
In order to achieve the above object, the present invention further provides an apparatus for script generation of a parameterization unit, comprising a memory and a processor, wherein the memory stores a program running on the processor, and the processor executes the steps of the script generation method for a parameterization unit when running the program.
To achieve the above object, the present invention also provides a computer-readable storage medium having stored thereon computer instructions which, when executed, perform the steps of the script generating method for parameterizing a unit as described above.
Compared with the prior art, the script generation method for the parameterization unit has the following beneficial effects:
(1) The parameterized unit script is simple in structure, a designer only needs to concentrate on defining parameterized units, a complete function library is provided by using layout design categories, and a figure of entity layout and other related design functions are not required to be created by the designer;
(2) The invention adopts an object-oriented programming architecture, which can easily edit multi-level parameterized units, and simultaneously can provide the parameterized units for script designers by expanding function libraries in design categories, thereby improving the design flexibility and efficiency.
Additional features and advantages of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention.
Drawings
The accompanying drawings are included to provide a further understanding of the invention and are incorporated in and constitute a part of this specification, illustrate the invention and together with the embodiments of the invention, and do not limit the invention. In the drawings:
Fig. 1 is a flowchart of a script generation method for a parameterization unit according to the present invention.
Detailed Description
Embodiments of the present invention will be described in more detail below with reference to the accompanying drawings. While the invention is susceptible of embodiment in the drawings, it is to be understood that the invention may be embodied in various forms and should not be construed as limited to the embodiments set forth herein, but rather are provided to provide a more thorough and complete understanding of the invention. It should be understood that the drawings and embodiments of the invention are for illustration purposes only and are not intended to limit the scope of the present invention.
It should be understood that the various steps recited in the method embodiments of the present invention may be performed in a different order and/or performed in parallel. Furthermore, method embodiments may include additional steps and/or omit performing the illustrated steps. The scope of the invention is not limited in this respect.
The term "including" and variations thereof as used herein are intended to be open-ended, i.e., including, but not limited to. The term "based on" is based at least in part on. The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments. Related definitions of other terms will be given in the description below.
It should be noted that references to "one", "a plurality" and "a plurality" in this disclosure are intended to be illustrative rather than limiting, and those skilled in the art will appreciate that "one or more" is intended to be construed as "one or more" unless the context clearly indicates otherwise. "plurality" is understood to mean two or more.
Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings.
Example 1
Fig. 1 is a flowchart of a script generation method for a parameterization unit according to the present invention, and a detailed description will be made below of the script generation method for a parameterization unit according to the present invention with reference to fig. 1.
In step 101, a layout design class is imported.
In an embodiment of the present invention, the design classes include, but are not limited to, the following open functions:
first category: a geometric class, comprising: creating a curve, creating a bar, creating a rectangular ring, creating a circular ring, creating a point, creating an ellipse, creating a line, creating a polygon, and creating a rectangle.
The second category: a class of entity operations, comprising: creating class instances, creating buses, creating composite components, creating graphics, creating vias, creating device contacts, creating layer enclosures, creating paths, creating segment paths, creating text, creating net lines, creating groups.
Third category: an attribute class comprising: the method comprises the steps of obtaining a terminal point, obtaining a unit name, obtaining a coordinate unit, obtaining an instance name, obtaining a graph, obtaining a unit library name, obtaining a network line, obtaining a boundary, obtaining process information, and setting and obtaining access rights.
In step 102, the parameter attributes and default values of the parameterized units are defined.
In the embodiment of the invention, the list variable is used as the parameter attribute and the default value for defining the parameterized unit. Each list member is in the same format: [ field 1, field 2, field 3, field 4], wherein
Field 1: for identifying parameter values.
Field 2: the data type of the parameter is defined, which may be a string, an integer, a floating value, a boolean value, etc.
Field 3: according to field 2, the value is defaulted.
Field 4: and defining the parameter names displayed to the parameterization unit user, so that the user can understand the purpose of each parameter conveniently.
In step 103, the design of the parameterized cell content is performed by defining an evaluation function.
In the embodiment of the present invention, the evaluation function further materializes the design category in step 101, and through the function library provided by the design category, the designer can create and edit the geometric figure and the relation between figures according to the parameterized unit specification being designed through the grammar of the adopted script.
Defining the evaluation function corresponds to defining a physical layout cell, which includes all design data of the layout cell.
In step 104, the layout names of the parameterized cells are defined, as are the layout library names to which they belong.
In the embodiment of the invention, a global compiling function is called, and the names of parameterized units and a layout unit library to which the parameterized units belong are defined.
The step of generating the parameterized unit script simplifies the design flow of the parameterized unit by an object-oriented design method, a designer only needs to concentrate on defining the evaluation function, and other works related to the layout database are processed by the layout design class, and the architecture can respond to the improvement of the future semiconductor process and expand the function library in the layout design class for the script designer of the parameterized unit to use. The application program architecture of the parameterization unit script designs a highly complex parameterization unit in a concise way.
Example 2
The script generation method for parameterization unit of the present invention is further described below in conjunction with the specific embodiment using the C language as an example of the design class function library and the Python language as an example of the script.
According to step 101, a layout design class is imported.
Design classes include, but are not limited to, the following open functions:
first category: a geometry class whose creation function is exemplified by:
i. creating a curve ：createArc(unsigned layerNum,unsigned purposeNum,const auBox&box,double startAngle,double stopAngle)
Creating a stripe shape ：createBar(unsigned layer,unsigned purpose,const auDirection dir,const char*netName＝"",const auPoint,const auLocation,const char*groupName＝"")
Creating a rectangular ring ：createContactRing(const char*cutLayer,const char*cutPurpose,unsigned int numRows＝1,unsigned int gapDistance＝0,const char*netName＝"",const char*polyLayer＝"",const char*polyPurpose＝"",const char*metalLayer＝"",const char*metalPurpose＝"",const char*diffusionLayer＝"",const char*diffusionPurpose＝"",const char*implantLayer＝"",const char*implantPurpose＝"")
Creation of a circular ring ：createDonut(unsigned layerNum,unsigned purposeNum,const auPoint¢er,unsigned radius,unsigned holeRadius)
V. creation Point ：createDot(unsigned layerNum,unsigned purposeNum,const auPoint¢er,unsigned width＝0,unsigned height＝0)
Creating an ellipse: CREATEELLIPSE (unsigned layerNum, unsigned purposeNum, const auBox & box)
Creating a line: CREATELINE (unsigned layerNum, unsigned purposeNum, const auPointArray & pa)
Creating a polygon: createPolygon (unsigned layer, unsigned purpose, const auPolygon & poly)
Creating a rectangle: CREATERECT (unsigned layerNum, unsigned purposeNum, const auBox & box)
The second category: an entity operation class whose creation function is exemplified by:
i. creating a bus: createBusNet (const char. Name, unsigned start, unsigned stop, unsigned step)
Creating a composite component: createCompoundComponent (const char name=null)
Creating a graph: CREATESHAPES (unsigned layerNum, unsigned purposeNum, const deque < auPolygon > & polyArray)
Creating a through hole: CREATESTDVIA (const agViaDef x viaDef, const auTransform & trans, const agViaParam x params = NULL)
Creation of device contacts ：createDeviceContact(const char*topLayer,const char*topPurpose,const char*bottomLayer,const char*bottomPurpose,const char*viaLayer,const char*viaPurpose,const auBox&deviceBox,agGapStyle::Type gapType＝agGapStyle::MIN_CENTER,unsigned int minRows＝0,unsigned int minCols＝0,unsigned int layer1Ext＝0,unsigned int layer2Ext＝0,unsigned int viaSpace＝0,unsigned int viaWidth＝0,const char*groupName＝"")
Creating a layer enclosure: createLayerBlockage (int layerNum, const auPolygon & points)
Creating a path ：createPath(unsigned layer,unsigned purpose,unsigned width,const auPointArray&pa,agPath::Style style＝agPath::Truncate,unsigned beginExt＝0,unsigned endExt＝0)
Viii creation of segment paths ：createPathSeg(unsigned layer,unsigned purpose,unsigned width,const auPoint&p1,const auPoint&p2,agPathSeg::Style style,unsigned ext＝0)
Ix. creation of text ：createText(unsigned layer,unsigned purpose,const char*text,const auPoint&origin,unsigned height,agText::Orient orient＝agText::R0,agText::Align align＝agText::CC,agText::Font font＝agText::Euro,bool overbar＝false,bool drafting＝true)
X, creating a net-shaped line: CREATENET (const char. Name, auSignalType sigType =augignalType. Signal)
Creating a group: createGroup (constchar name=null)
A third class, an attribute class, which creates examples as follows:
i. Acquiring a terminal point: getTerms () const
Acquiring unit name: GETCELLNAME () const
Obtaining the coordinate units: getDBUPerUU () const
Acquisition unit instance: getInsts () const
V. obtaining a graph: GETSHAPES () const
Obtaining a cell library name: getLibName () const
Obtaining a net-shaped wire: getNets () const
Acquisition boundary: getPRBoundary () const
And ix. obtaining process information: getTech () const
Checking write permission: isWritable () const
According to step 102, parameter attributes and default values of the parameterized units are defined.
The list variable is used as a parameter attribute and a default value for defining the parameterized unit. Each list member is in the same format: [ field 1, field 2, field 3, field 4].
The following is an example of a script having list variables as parameter attributes defining parameterized elements:
paramTable＝[['layer','String',"CO",'ContactLayer'],
['width','Double',0.32,'ContactWidth']]
Field 1: for identifying parameter values. In the example the string layer, width, identifies two different parameters.
Field 2: the data type of the parameter is defined. May be a string, an integer, a floating number, etc., a boolean value, etc. The parameter data types in the examples are String, double, respectively.
Field 3: default values are based on field 2. The default values in the example are the string "CO" and floating point number 0.32, respectively.
Field 4: and defining the parameter names displayed to the parameterization unit user, so that the user can understand the purpose of each parameter conveniently. Here, the constant is fixed as a string, and ContactLayer is used in the example, there is no blank space between Contact and Layer, so that the user using the parameterization unit can understand that the parameter represents the Layer used to set the Contact.
According to step 103, the design of the parameterized cell content is performed by defining an evaluation function.
Wherein the evaluation function is PCELLEVAL (self, design). The evaluation function further materializes the design class in step 101, and through the function library provided by the design class, the designer can create and edit the required geometric figure and the relation between figures according to the parameterized unit specification being designed through the grammar of the adopted script. Defining the evaluation function corresponds to defining a physical layout cell, which includes all design data of the layout cell.
According to step 104, the layout names of the parameterized units and the belonging layout library names are defined.
The following is a complete script example according to steps 101 through 104, using the CO layer to create a rectangle with coordinates (0, 0), length and width being the default value of 0.32 for the parameter width:
Wherein from emPythonSOS import imports design categories DEF PCELLEVAL (design) define evaluation functions, paramTable define parameter values, emdesign. Createpondpcell (libName, "cont", cont) define parameterization units in the database named cont, and compile this script into parameterization units.
Example 3
The embodiment of the invention also provides a script generation device for the parameterization unit, which comprises a memory and a processor, wherein the memory stores a program running on the processor, and the processor executes the steps of the script generation method for the parameterization unit when running the program.
Example 4
The embodiment of the invention also provides a computer readable storage medium, on which computer instructions are stored, the computer instructions execute the steps of the script generation method for the parameterization unit when running, and the script generation method for the parameterization unit is referred to the description of the previous section and will not be repeated.
Those of ordinary skill in the art will appreciate that: the foregoing description is only a preferred embodiment of the present invention, and the present invention is not limited thereto, but it is to be understood that modifications and equivalents of some of the technical features described in the foregoing embodiments may be made by those skilled in the art, although the present invention has been described in detail with reference to the foregoing embodiments. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present invention should be included in the protection scope of the present invention.
Claims (6)
1. A script generation method for a parameterized unit, comprising the steps of:
1) Importing a layout design category, wherein the layout design category comprises a geometric figure category, an entity operation category and an attribute category, and the attribute category comprises an acquisition terminal point, an acquisition unit name, an acquisition coordinate unit, an acquisition instance name, an acquisition graph, an acquisition unit library name, an acquisition net line, an acquisition boundary, an acquisition process information and a setting and acquisition access right;
2) Defining parameter attributes and default values of the parameterized units;
3) Designing the content of the parameterized unit by defining an evaluation function;
4) Calling a global compiling function, and defining the layout name of the parameterized unit and the name of the layout library to which the parameterized unit belongs;
The design category is further described in a materialization mode through defining the content of the evaluation function, and geometric figures and relations between figures required by editing are created and edited according to the parameterized unit specification of the design through the grammar of the adopted script through a function library provided by the design category.
2. The script generation method for a parameterized cell of claim 1, wherein the geometry class comprises create curves, create bars, create rectangular rings, create circular rings, create points, create ellipses, create lines, create polygons, create rectangles.
3. The script generation method for a parameterized unit of claim 1, wherein the entity operation classes comprise create class instances, create buses, create composite components, create graphics, create through holes, create device contacts, create layer enclosures, create paths, create segment paths, create text, create net-shape lines, create groups.
4. The script generation method for a parameterization unit according to claim 1, wherein the parameter attributes and default values defining the parameterization unit are list variables as parameter attributes and default values defining the parameterization unit, and each list member adopts the same format: [ field 1, field 2, field 3, field 4], wherein
The field 1 is used for identifying a parameter value;
the field 2 defines the data type of the parameter, which includes the data type representing character string, integer, floating value, boolean value;
Setting a default value according to the field 2 by the field 3;
The field 4 defines the parameter name displayed to the user of the parameterization unit, facilitating the user's understanding of the use of each parameter.
5. An apparatus for script generation for a parameterized element, comprising a memory and a processor, the memory having stored thereon a program running on the processor, the processor executing the steps of the script generation method for a parameterized element of any of claims 1-4 when the program is run.
6. A computer readable storage medium having stored thereon computer instructions, which when run perform the steps of the script generation method for a parameterized unit of any of claims 1-4.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210650375.7A CN114880981B (en) | 2022-06-09 | 2022-06-09 | Script generation method for parameterization unit |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210650375.7A CN114880981B (en) | 2022-06-09 | 2022-06-09 | Script generation method for parameterization unit |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN114880981A CN114880981A (en) | 2022-08-09 |
| CN114880981B true CN114880981B (en) | 2024-07-09 |
Family
ID=82681261
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210650375.7A Active CN114880981B (en) | 2022-06-09 | 2022-06-09 | Script generation method for parameterization unit |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114880981B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116011368B (en) * | 2023-02-03 | 2024-09-24 | 深圳华大九天科技有限公司 | Method for automatically generating script through EDA layout |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103838930A (en) * | 2014-03-12 | 2014-06-04 | 中国科学院微电子研究所 | Method and system for realizing parameterized unit based on graphic technology editor |
| CN109992808A (en) * | 2017-12-30 | 2019-07-09 | 杭州广立微电子有限公司 | A method of quickly generating parameterized units |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7793248B1 (en) * | 2005-11-23 | 2010-09-07 | Altera Corporation | Method and apparatus for parameterizing hardware description language code in a system level design environment |
| CN102930088B (en) * | 2012-10-22 | 2015-10-14 | 杭州广立微电子有限公司 | A kind of method producing parameterized units |
| CN111079369B (en) * | 2019-12-11 | 2023-01-31 | 成都华大九天科技有限公司 | Method for scaling instance by using variable parameterization unit |
-
2022
- 2022-06-09 CN CN202210650375.7A patent/CN114880981B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103838930A (en) * | 2014-03-12 | 2014-06-04 | 中国科学院微电子研究所 | Method and system for realizing parameterized unit based on graphic technology editor |
| CN109992808A (en) * | 2017-12-30 | 2019-07-09 | 杭州广立微电子有限公司 | A method of quickly generating parameterized units |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114880981A (en) | 2022-08-09 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US5281558A (en) | Cloning method and system for hierarchical compaction | |
| US8392873B2 (en) | Methods and apparatus for implementing model-based software solution development and integrated change management | |
| US5568396A (en) | Identifying overconstraints using port abstraction graphs | |
| US5890176A (en) | Object-oriented document version tracking method and apparatus | |
| US20040153979A1 (en) | System and method for generating a two-dimensional yield map for a full layout | |
| US20130151551A1 (en) | Computer-implemented method of geometric feature detection | |
| CN110427215A (en) | A kind of program version mRNA differential display mRNA method and device applied to front end exploitation | |
| US9830417B1 (en) | Methods and systems for generation and editing of parameterized figure group | |
| US20140013313A1 (en) | Editor/Development Tool for Dataflow Programs | |
| US6915252B1 (en) | Method and system for ensuring consistency of design rule application in a CAD environment | |
| CN114880981B (en) | Script generation method for parameterization unit | |
| US11227085B2 (en) | Method and operation method for displaying DRC in classification manner in PCB design | |
| CN101763261A (en) | Method, system and device for extracting, converting and loading data | |
| CN103838930A (en) | Method and system for realizing parameterized unit based on graphic technology editor | |
| CN117725767B (en) | Automatic generation method, plug-in, system, terminal and medium for parameterized component model | |
| CN112433701A (en) | Industrial software development project implementation flow, content and code generation method and device | |
| Anlauff et al. | Formal aspects of and development environments for montages | |
| KR100807061B1 (en) | Automatic part design method using Excel file as drawing command database and recording medium storing the program | |
| CN113407186B (en) | Control execution method, control execution device, terminal and readable storage medium | |
| Liu et al. | Using transition systems to unify uml models | |
| Lutteroth | Automated reverse engineering of hard-coded GUI layouts | |
| CN111984244A (en) | Method and system for realizing on-line IDE with intelligent contract annotation analyzer | |
| CN114219882A (en) | 3D rendering engine construction method and device, computer equipment and storage medium | |
| CN114970413B (en) | Object-oriented parameterized unit design method | |
| Cyre et al. | Knowledge visualization from conceptual structures |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |