Appendix B
Index Variable Types
| Bartels :: Bartels AutoEngineer :: BAE Documentation :: User Language Programmer's Guide :: Index Variable Types |
Bartels User Language - Programmer's GuideAppendix B
|
|
This appendix describes the Bartels User Language index variable types definitions, providing alphabetically sorted reference lists and index type descriptions which are grouped according to the corresponding caller types.
| B.1 | Index Reference |
 | B.1.1 | Standard Index Variable Types (STD) |
| B.1.2 | Schematic Capture Index Variable Types (CAP) |
| B.1.3 | Layout Index Variable Types (LAY) |
| B.1.4 | CAM View Index Variable Types (CV) |
| B.1.5 | IC Design Index Variable Types (ICD) |
| B.2 | Standard Index Description (STD) |
| B.3 | Schematic Capture Index Description (CAP) |
| B.4 | Layout Index Description (LAY) |
| B.5 | CAM View Index Description (CV) |
| B.6 | IC Design Index Description (ICD) |
Each Bartels User Language index variable type is assigned to one of the caller types STD, CAP, LAY or ICD. This section lists the index variable types for each caller type.
The following index variable types are assigned to caller type STD; i.e., they can be accessed from any of the Bartels AutoEngineer interpreter environments:
| BAEPARAM | Bartels AutoEngineer Parameter |
| GLOBALVAR | Global User Language Variable |
The following index variable types are assigned to caller type CAP; i.e., they can be accessed from the Schematic Editor interpreter environment:
| C_ATTRIBUTE | SCM Part Attribute |
| C_BUSTAP | SCM Bus Tap |
| C_CNET | SCM Logical Net List |
| C_CONBASE | SCM Connection Segment Group |
| C_CONSEG | SCM Connection Segment |
| C_FIGURE | SCM Figure Element |
| C_LEVEL | SCM Signal Level |
| C_MACRO | SCM Library Element |
| C_NREF | SCM Named Macro Reference |
| C_POINT | SCM Polygon Point |
| C_POLY | SCM Polygon |
| C_POOL | SCM Pool Element |
| C_TEXT | SCM Text |
| CL_ALTPLNAME | Layout Net List Alternate Part Package |
| CL_ATTRIBUTE | Layout Net List Attribute |
| CL_CNET | Layout Net List |
| CL_CPART | Layout Net List Part Entry |
| CL_CPIN | Layout Net List Part Pin Entry |
The following index variable types are assigned to caller type LAY; i.e., they can be accessed from the Layout Editor, the Autorouter and the CAM Processor interpreter environments:
| L_ALTPLNAME | Layout Net List Alternate Part Package Type |
| L_ATTRIBUTE | Layout Net List Attribute |
| L_CNET | Layout Net List |
| L_CPART | Layout Net List Part Entry |
| L_CPIN | Layout Net List Part Pin Entry |
| L_DRCERROR | Layout DRC Error Marker |
| L_DRCERROROK | Layout DRC Error Acceptance |
| L_DRILL | Layout Drill Hole |
| L_FIGURE | Layout Figure Element |
| L_LEVEL | Layout Signal Level |
| L_LINE | Layout Trace |
| L_MACRO | Layout Library Element |
| L_NREF | Layout Named Macro Reference |
| L_POINT | Layout Polygon Point |
| L_POLY | Layout Polygon |
| L_POOL | Layout Pool Element |
| L_POWLAYER | Layout Power Layer |
| L_TEXT | Layout Text |
| L_UREF | Layout Unnamed Macro Reference |
The following index variable types are assigned to caller type CV; i.e., they can be accessed from the CAM View interpreter environment:
| CV_DATASET | CAM View Data Set |
The following index variable types are assigned to caller type ICD; i.e., they can be accessed from the Chip Editor interpreter environment:
| I_ATTRIBUTE | IC Design Net List Attribute |
| I_CNET | IC Design Net List |
| I_CPART | IC Design Net List Part Entry |
| I_CPIN | IC Design Net List Part Pin Entry |
| I_FIGURE | IC Design Figure Element |
| I_LEVEL | IC Design Signal Level |
| I_LINE | IC Design Trace |
| I_MACRO | IC Design Library Element |
| I_NREF | IC Design Named Macro Reference |
| I_POINT | IC Design Polygon Point |
| I_POLY | IC Design Polygon |
| I_POOL | IC Design Pool Element |
| I_TEXT | IC Design Text |
| I_UREF | IC Design Unnamed Macro Reference |
This section describes the Bartels User Language index variable types for general User Language data access (STD).
The BAEPARAM index variable type provides access to the list of the currently activated BAE parameters. The structure definition of BAEPARAM is:
index BAEPARAM { // BAE Parameter Index
int IDCODE; // Parameter Type/Ident. Code
int TYP; // Parameter Data Type:
// 1 = int
// 2 = double
// 4 = string
int VALINT; // Parameter Integer Value (if TYP is 1)
double VALDBL; // Parameter Double Value (if TYP is 2)
string VALSTR; // Parameter String Value (if TYP is 4)
};
The source code of the
baeparam.ulh User Language include file provides the list of valid parameter type codes (i.e., valid values for
IDCODE) as well as function templates for retrieving specific BAE parameter values.
The GLOBALVAR index variable type provides access to the list of the global User Language values currently defined with the varset User Language system function. The structure definition of GLOBALVAR is:
index GLOBALVAR { // Global User Language Variable Index
string NAME; // Global Variable Name
int TYP; // Global Variable Data Type:
// 1 = int
// 2 = double
// 3 = char
// 4 = string
};
Once a global User Language variable has been scanned with the GLOBALVAR index, the varget User Language system function can be used to retrieve its value.
This section describes the Bartels User Language index variable types for the Schematic Capture data access (CAP).
The C_ATTRIBUTE index variable type provides access to the part attributes defined on the currently loaded SCM sheet. The structure definition of C_ATTRIBUTE is:
index C_ATTRIBUTE { // Attribute Index
string NAME; // Attribute Name
string VALUE; // Attribute Value
};
The
C_ATTRIBUTE index can only be applied as
of-index for the attribute list of
C_NREF.
The C_BUSTAP index variable type provides access to the bus connectors (bus taps) of the currently loaded SCM sheet. The structure definition of C_BUSTAP is:
index C_BUSTAP { // Bustap Index
string NAME; // Bustap Name
double X; // Bustap X Coordinate (STD2)
double Y; // Bustap Y Coordinate (STD2)
double ANGLE; // Bustap Rotation Angle (STD3)
int MIRROR; // Bustap Mirror Mode (STD14)
index C_MACRO MACRO; // Link to Bus Tap Macro
index C_CONBASE CON; // Link to Segment Group
index C_CONSEG SEG; // Link to Connection Segment
};
Each bus tap is placed on a bus connection segment. The bus tap rotation angle is a multiple of 90 degree. The
CON index variable is a backward link to the connection segment group containing the bus tap. The
SEG index variable provides a cross link to the connection segment on which the bus tap is placed.
The C_CNET index variable type provides access to the logical net list of the currently loaded SCM sheet. The structure definition of C_CNET is:
index C_CNET { // Logical Net List Index
string NAME; // Net Name
int NUMBER; // Net Tree Number
int NETGLO; // Net Global Flag:
// 0 = Local Net Definition
// 1 = Global Net Definition
int BUSNET; // Bus Net Number
};
The C_CONBASE index variable type provides access to the connection segment group of a specific column and/or row of the currently loaded SCM sheet. The structure definition of C_CONBASE is:
index C_CONBASE { // Connection Segment Group Index
int ORI; // Orientation:
// 0 = Horizontal
// 1 = Vertical
double X; // Base X Coordinate (STD2)
double Y; // Base Y Coordinate (STD2)
int SN; // Connection Segment Count
index C_CONSEG; // Connection Segment List
index C_BUSTAP; // Bus Tap List
};
A
C_CONBASE index contains all connection segments of a specific column (orientation vertical) and/or row (orientation horizontal), including all bus taps defined on these connections. The group's connection segment and bus tap lists can be accessed through corresponding
forall-of loops.
The C_CONSEG index variable type provides access to the connection segments of the currently loaded SCM sheet. The structure definition of C_CONSEG is:
index C_CONSEG { // Connection Segment Index
double X1; // Segment X Coordinate 1 (STD2)
double Y1; // Segment Y Coordinate 1 (STD2)
double X2; // Segment X Coordinate 2 (STD2)
double Y2; // Segment Y Coordinate 2 (STD2)
int BUSFLAG; // Segment Bus Flag:
// 0 = Normal Segment
// 1 = Bus Segment
int GROUP; // Segment Group Flag (STD13)
index C_CONBASE CON; // Link to Segment Group
};
Connection segments always are placed orthogonal. This means that either the X coordinates are identical (orientation vertical) or, otherwise, the Y coordinates are identical (orientation horizontal). The
CON index variable provides a backward link to the connection segment group which contains the corresponding connection segment.
The C_FIGURE index variable type provides access to all placed figure elements (polygons, connections, macro references, texts) of the currently loaded SCM element. The structure definition of C_FIGURE is:
index C_FIGURE { // Figure Element Index
int TYP; // Element Type (CAP3)
string NAME; // Element Name
double SIZE; // Element Size (STD2)
double X; // Element X Coordinate (STD2)
double Y; // Element Y Coordinate (STD2)
double ANGLE; // Element Rotation Angle (STD3)
int MIRROR; // Element Mirror Mode (STD14)
int GROUP; // Element Group Flag (STD13)
index C_POOL POOL; // Link to Pool Element
index C_POLY POLY; // Link to Polygon Element
index C_CONBASE CONBASE;// Link to Connection Segment Group
index C_NREF NREF; // Link to Named Reference Element
index C_TEXT TEXT; // Link to Text Element
};
The
NAME variable either denotes the name for named macro references or denotes the string of a text element.
On SCM symbol level,
NAME holds the SCM symbol part name pattern. The
POOL variable provides a cross link to the library pool element which builds up the figure element. The figure element attributes can be changed with the
scm_elem*chg functions. A feature for scanning the complete figure element data with all hierarchy levels is provided with the
cap_scanfelem function.
The C_LEVEL index variable type provides access to the connectivity levels, i.e., the net list and/or signal levels of the currently loaded SCM sheet. The structure definition of C_LEVEL is:
index C_LEVEL { // Connectivity Level Index
int IDNUM; // Level Identification Number
int BUSFLAG; // Level Bus Flag
int SEGFLAG; // Level Segment Connection Mode (Bit Pattern):
// 1 = Segment connected to level
// 2 = Contact areas connected to level
int ERRFLAG; // Level Error Flag
int HIGHLIGHT; // Level Highlight Flag
int DISPLAY; // Level Display Attributes
int CNN; // Level Net Count
index C_CNET; // Level Net List
};
The signal level's net list can be accessed through a corresponding
forall-of loop.
The C_MACRO index variable type provides access to the macros, i.e., the library elements (symbol, label, marker) used on the currently loaded SCM element. The structure definition of C_MACRO is:
index C_MACRO { // Macro Definition Index
string NAME; // Macro Name
double MLX; // Left Macro Border (STD2)
double MLY; // Lower Macro Border (STD2)
double MUX; // Right Macro Border (STD2)
double MUY; // Upper Macro Border (STD2)
double MNX; // Macro Origin X Coordinate (STD2)
double MNY; // Macro Origin Y Coordinate (STD2)
int CLASS; // Macro Class Code (STD1)
int TAGSYM; // Macro Tag Symbol/Label Mode (CAP5)
int COMP; // Macro Status (STD16)
string PNAMEPAT; // Macro Part Name Pattern
};
The
PNAMEPAT variable holds the part name pattern defined for SCM symbol macros.
The C_NREF index variable type provides access to the named macro references, i.e., the name-specified library elements placed on the currently loaded SCM element. These are parts and/or labels on SCM sheet level or pins on symbol and/or label hierarchy level. The structure definition of C_NREF is:
index C_NREF { // Named Reference Index
string NAME; // Reference Name
double X; // Reference X Coordinate (STD2)
double Y; // Reference Y Coordinate (STD2)
double ANGLE; // Reference Rotation Angle (STD3)
int MIRROR; // Reference Mirror Mode (STD14)
int TAGPTYP; // Reference Tag Pin Type (CAP6)
index C_MACRO MACRO; // Link to Macro
index C_ATTRIBUTE; // Attribute List
};
The
MACRO variable provides a cross link for accessing the referenced library element. The part attribute list can be accessed through a corresponding
forall-of loop.
The C_POINT index variable type provides access to the polygon points of a specific polygon. The structure definition of C_POINT is:
index C_POINT { // Polygon Point Index
double X; // Polygon Point X Coordinate (STD2)
double Y; // Polygon Point Y Coordinate (STD2)
int TYP; // Polygon Point Type (STD15)
};
The
C_POINT index can only be applied as
of-index for the point list in
C_POLY.
The C_POLY index variable type provides access to the polygons (areas, lines) defined on the currently loaded SCM element. The structure definition of C_POLY is:
index C_POLY { // Polygon Index
int TYP; // Polygon Type (CAP2)
double WIDTH; // Polygon Line Width (STD2)
double DASHLEN; // Polygon Dash Length (STD2)
double DASHSPC; // Polygon Dash Relative Spacing
int DASH; // Polygon Dash Mode
int PN; // Polygon Point Count
index C_POINT; // Polygon Point List
};
The polygon point list of the polygon can be accessed through a corresponding
forall-of loop.
The C_POOL index variable type provides access to the currently loaded pool elements. The structure definition of C_POOL is:
index C_POOL { // Pool Element Index
int TYP; // Pool Element Typ (CAP4)
int REFCNT; // Pool Element Reference Count
index C_POOL NXT; // Link to Next Pool Element
index C_POOL REF; // Link to Reference Pool Element
index C_POLY POLY; // Link to Polygon Element
index C_CONBASE CONBASE;// Link to Connection Segment Group
index C_NREF NREF; // Link to Named Reference Element
index C_TEXT TEXT; // Link to Text Element
index C_MACRO MACRO; // Link to Library Element
index C_BUSTAP BUSTAP; // Link to Bustap Element
};
The
C_POOL index is used for processing library definitions with the
cap_scanpool system function. The
REFCNT variable specifies, how often the pool element is currently referenced. The
NXT and
REF variables allow for fast pool element list traversal.
The C_TEXT index variable type provides access to the text data defined on the currently loaded SCM element. The structure definition of C_TEXT is:
index C_TEXT { // Text Index
string STR; // Text String
double X; // Text X Coordinate (STD2)
double Y; // Text Y Coordinate (STD2)
double ANGLE; // Text Rotation Angle (STD3)
double SIZE; // Text Size (STD2)
double WIDTH; // Text Line Width (STD2)
int MIRROR; // Text Mirror Mode (STD14)
int MODE; // Text Mode/Style (CAP1|CAP7)
int CLASS; // Text Class Bits
};
The CL_ALTPLNAME index variable type provides access to the alternate part package type list of the currently loaded layout net list. The structure definition of CL_ALTPLNAME is:
index L_ALTPLNAME { // Alternate Part Package Type Index
string PLNAME; // Layout Library Name
};
The CL_ATTRIBUTE index variable type provides access to the part and net attributes of the currently loaded layout net list. The structure definition of CL_ATTRIBUTE is:
index CL_ATTRIBUTE { // Attribute Index
string NAME; // Attribute Name
string VALUE; // Attribute Value
};
The CL_CNET index variable type provides access to the nets of the currently loaded layout net list. The structure definition of CL_CNET is:
index CL_CNET { // Layout Net Index
string NAME; // Net Name
int NUMBER; // Net Tree Number
int PRIOR; // Net Routing Priority
double RDIST; // Net Minimum Distance (STD2)
int PINN; // Net Pin Count
index CL_CPIN; // Net Pin List
index CL_ATTRIBUTE; // Net Attribute List
};
The net tree number is used for identifying the net. The
cap_getlaytreeidx function provides access to the
CL_CNET index for a given net tree number. The minimum distance applies to the traces of the net; this distance must at minimum be kept to copper structures not belonging to the corresponding net. The net pin and/or attribute lists can be accessed through corresponding
forall-of loops.
The CL_CPART index variable type provides access to the parts of the currently loaded layout net list. The structure definition of CL_CPART is:
index CL_CPART { // Layout Netlist Part Index
string NAME; // Part Name
string PLNAME; // Part Physical Library Name
int PEQUC; // Part Equivalence Code
int PINN; // Part Pin Count
int FPINN; // Part Free Pin Count
index CL_CPIN; // Part Pin List
index CL_ALTPLNAME; // Part Alternate Physical Names List
index CL_ATTRIBUTE; // Part Attribute List
};
The part pin and/or attribute lists can be accessed through corresponding
forall-of loops. Component swaps can be applied on parts with identical equivalence codes to optimize the placement.
The CL_CPIN index variable type provides access to the part pins of the currently loaded layout net list. The structure definition of CL_CPIN is:
index CL_CPIN { // Layout Netlist Part Pin Index
string NAME; // Pin Name
double RWIDTH; // Pin Routing Width (STD2)
int TREE; // Pin Net Tree Number
int GATE; // Pin Gate Number
int GEQUC; // Pin Gate Equivalence Code
int GEQUP; // Pin Equivalence Code
int GGRPC; // Pin Gate Group Number
int GPNUM; // Pin Gate Relative Number
index CL_CNET CNET; // Link to Pin Net
index CL_CPART CPART; // Link to Pin Part
index CL_ATTRIBUTE; // Pin Attribute List
};
The pin routing width defines the width for routing to the next connection point. The
CNET and
CPART variables provide backward links to the corresponding layout net list nets and parts, respectively. The
GATE,
GEQUC,
GEQUP,
GGRPC and
GPNUM variables can be used to check pin/gate swap allowance.
This section describes the Bartels User Language index variable types for the Layout data access (LAY).
The L_ALTPLNAME index variable type provides access to the connection list part alternate physical library name list of the currently loaded layout. The structure definition of L_ALTPLNAME is:
index L_ALTPLNAME { // Alternate Phys. Lib. Name Index
string PLNAME; // Physical Library Name
};
The L_ATTRIBUTE index variable type provides access to the connection list part or net attributes of the currently loaded layout. The structure definition of L_ATTRIBUTE is:
index L_ATTRIBUTE { // Attribute Index
string NAME; // Attribute Name
string VALUE; // Attribute Value
};
The L_CNET index variable type provides access to the connection list nets of the currently loaded layout. The structure definition of L_CNET is:
index L_CNET { // Connection List Net Index
string NAME; // Net Name
int NUMBER; // Net Tree Number
int PRIOR; // Net Routing Priority
double RDIST; // Net Minimum Distance (STD2)
int VIS; // Net Visibility Flag
int PINN; // Net Pin Count
index L_CPIN; // Net Pin List
index L_ATTRIBUTE; // Net Attribute List
index L_POOL UNRPOOL; // Link to Unroutes Pool Element
};
The net tree number is used for identifying the net. The
lay_gettreeidx function provides access to the
L_CNET index for a given net tree number. The minimum distance applies to the traces of the net; this distance must at minimum be kept to copper structures not belonging to the corresponding net. The net pin and/or attribute list can be accessed by applying a corresponding
forall-of loop. The
UNRPOOL variable provides access to the unrouted connections of the net; the corresponding airlines can be processed with the
lay_scanpool system function.
The L_CPART index variable type provides access to the connection list parts of the currently loaded layout. The structure definition of L_CPART is:
index L_CPART { // Connection List Part Index
string NAME; // Part Name
string PLNAME; // Part Physical Library Name
int USED; // Part Placement (and Group Selection) Code:
// 0 = Part not placed
// 1 = Part placed
// 2 = Part placed and selected to group
int PEQUC; // Part Equivalence Code
int PINN; // Part Pin Count
int FPINN; // Part Free Pin Count
index L_MACRO MACRO; // Link to Macro
index L_CPIN; // Part Pin List
index L_ALTPLNAME; // Part Alternate Physical Names List
index L_ATTRIBUTE; // Part Attribute List
};
The part pin and/or attribute lists can be accessed through corresponding
forall-of loops. Component swaps can be applied on parts with identical equivalence codes to optimize the placement.
The L_CPIN index variable type provides access to the connection list part pins of the currently loaded layout. The structure definition of L_CPIN is:
index L_CPIN { // Net List Pin Index
string NAME; // Pin Name
double RWIDTH; // Pin Routing Width (STD2)
int TREE; // Pin Net Tree Number
int GATE; // Pin Gate Number
int GEQUC; // Pin Gate Equivalence Code
int GEQUP; // Pin Equivalence Code
int GGRPC; // Pin Gate Group Number
int GPNUM; // Pin Gate Relative Number
index L_CNET CNET; // Link to Pin Net
index L_CPART CPART; // Link to Pin Part
};
The pin routing width defines the width for routing to the next connection point. The
CNET and
CPART variables provide backward links to the corresponding connection list net and part entries, respectively. The
GATE,
GEQUC,
GEQUP,
GGRPC and
GPNUM variables can be used for checking pin/gate swap allowance.
The L_DRCERROR index variable type provides access to the error markers displayed by the design rule check on the currently loaded layout element. The structure definition of L_DRCERROR is:
index L_DRCERROR { // DRC Error Marker Index
int TYP; // DRC Error Type:
// 1 = Copper distance violation
// 2 = Doc. layer keepout area violation
// 3 = Doc. layer keepout area height violation
// 4 = HF Design Rule Violation
// 5 = Invalid dropped polygon range
int LAYER; // DRC Error Marker Layer (LAY1)
double RLX; // DRC Error Marker Left Border (STD2)
double RLY; // DRC Error Marker Lower Border (STD2)
double RUX; // DRC Error Marker Right Border (STD2)
double RUY; // DRC Error Marker Upper Border (STD2)
double CHKDIST; // DRC Error DRC Clearance Distance (STD2)
double ERRDIST; // DRC Error Current Clearance Distance (STD2)
string IDSTR; // DRC Error Id String
index L_FIGURE FIG1; // DRC Error Element 1
index L_FIGURE FIG2; // DRC Error Element 2
};
The L_DRCERROROK index variable type provides access to the DRC error acceptance settings of the currently loaded layout element. The structure definition of L_DRCERROROK is:
index L_DRCERROROK { // Layout DRC Error Acceptance Index
string IDSTR; // DRC Error Id String
};
The L_DRILL index variable type provides access to the drill holes defined of the currently loaded padstack. The structure definition of L_DRILL is:
index L_DRILL { // Drilling Index
double X; // Drilling X Coordinate (STD2)
double Y; // Drilling Y Coordinate (STD2)
double RAD; // Drilling Radius (STD2)
int CLASS; // Drilling Class Code (LAY5)
};
The L_DRILL index contains the placement data of the drilling on the corresponding padstack, when using L_DRILL in the drill scan functions of lay_scanfelem, lay_scanall or lay_scanpool. The coordinates on the layout and/or part can be retrieved from the transformed coordinates of the drill scan function.
The L_FIGURE index variable type provides access to all placed figure elements (polygons, traces, macro references, texts, drills) of the currently loaded layout element. The structure definition of L_FIGURE is:
index L_FIGURE { // Figure Element Index
int TYP; // Element Type (LAY6)
string NAME; // Element Name
double SIZE; // Element Size (STD2)
double X; // Element X Coordinate (STD2)
double Y; // Element Y Coordinate (STD2)
double ANGLE; // Element Rotation Angle (STD3)
int MIRROR; // Element Mirror Mode (STD14)
int LAYER; // Element Layer/Class (LAY1 | LAY5)
int GROUP; // Element Group Flag (STD13)
int FIXED; // Element Fixed Flag (STD11 | STD12)
int TREE; // Element Net Tree Number
index L_POOL POOL; // Link to Pool Element
index L_POLY POLY; // Link to Polygon Element
index L_LINE LINE; // Link to Trace Element
index L_NREF NREF; // Link to Macro Reference (named)
index L_UREF UREF; // Link to Macro Reference (unnamed)
index L_TEXT TEXT; // Link to Text Element
};
The
NAME variable holds either the name of a named macro reference or the string of a text element.
For elements of
TYP 7 (intern),
NAME return the standard via padstack macro name if the internal element is a standard via definition.
The
LAYER variable specifies the element layer number, except for drill elements where it denotes the drill class. The
POOL variable provides a cross link to the library pool element which builds up the figure element. The figure element attributes can be changed with the
ged_elem*chg functions. A feature for scanning the complete figure element data with all hierarchy levels is provided with the
lay_scanfelem function.
The L_LEVEL index variable type provides access to the connectivity levels, i.e., the net list and/or signal levels of the currently loaded layout. The structure definition of L_LEVEL is:
index L_LEVEL { // Connectivity Level Index
int LEVVAL; // Level Value (LAY7)
};
The L_LINE index variable type provides access to the path and/or trace data defined on the currently loaded layout and/or part. The structure definition of L_LINE is:
index L_LINE { // Line Path Index
double WIDTH; // Line Path Width (STD2)
int LAYER; // Line Path Layer (LAY1)
int TREE; // Line Path Tree Number
int PN; // Line Path Point Count
index L_POINT; // Line Path Point List
};
The L_MACRO index variable type provides access to the macros, i.e., the library elements (part, padstack, pad) used on the currently loaded layout element. The structure definition of L_MACRO is:
index L_MACRO { // Macro Definition Index
string NAME; // Macro Name
double MLX; // Left Macro Border (STD2)
double MLY; // Lower Macro Border (STD2)
double MUX; // Right Macro Border (STD2)
double MUY; // Upper Macro Border (STD2)
double MNX; // Macro Origin X Coordinate (STD2)
double MNY; // Macro Origin Y Coordinate (STD2)
int CLASS; // Macro Class Code (STD1)
int COMP; // Macro Status (STD16)
};
The L_NREF index variable type provides access to the named macro references, i.e., the name-specified library elements placed on the currently loaded element. These are parts on layout hierarchy level, or padstacks on part hierarchy level. The structure definition of L_NREF is:
index L_NREF { // Named Reference Index
string NAME; // Reference Name
double X; // Reference X Coordinate (STD2)
double Y; // Reference Y Coordinate (STD2)
double ANGLE; // Reference Rotation Angle (STD3)
int LAYOFF; // Reference Layer Offset (LAY1)
int MIRROR; // Reference Mirror Flag (STD14)
index L_MACRO MACRO; // Link to Macro
};
The
MACRO variable provides a cross link for accessing the referenced library element.
The L_POINT index variable type provides access to the polygon points of a specific polygon or trace element. The structure definition of L_POINT is:
index L_POINT { // Polygon Point Index
double X; // Polygon Point X Coordinate (STD2)
double Y; // Polygon Point Y Coordinate (STD2)
int TYP; // Polygon Point Type (STD15)
};
The
L_POINT index can be applied just as
of-index for the point lists in
L_POLY and/or
L_LINE.
The L_POLY index variable type provides access to the polygons (passive copper, forbidden areas, board outline, active copper, documentary lines, documentary areas, copper fill workareas, hatched areas, split power plane areas) defined on the currently loaded layout element. The structure definition of L_POLY is:
index L_POLY { // Polygon Index
int LAYER; // Polygon Layer (LAY1)
int TREE; // Polygon Net Tree Number
int TYP; // Polygon Type (LAY4)
int MVIS; // Polygon Mirror Mode (LAY3) and/or:
// LAY3 + 4 = Dashed Polygon
// LAY3 + 8 = Dotted Polygon
double WIDTH; // Polygon Line Width (STD2)
double DASHLEN; // Polygon Dash Length (STD2)
double DASHSPC; // Polygon Dash Relative Spacing
int PN; // Polygon Point Count
index L_POINT; // Polygon Point List
};
The polygon net tree number is only valid for active copper, copper fill workareas, hatched areas and split power plane areas. The lay_scanfelem and/or lay_scanall function must be used to check the signal level of passive copper.
The L_POOL index variable type provides access to the currently loaded pool elements. The structure definition of L_POOL is:
index L_POOL { // Pool Element Index
int TYP; // Pool Element Type (LAY8)
int REFCNT; // Pool Element Reference Count
int LAYER; // Pool Element Layer (LAY1)
index L_POOL NXT; // Link to Next Pool Element
index L_POOL REF; // Link to Reference Pool Element
index L_POLY POLY; // Link to Polygon Element
index L_LINE LINE; // Link to Trace Element
index L_NREF NREF; // Link to Macro Reference (named)
index L_UREF UREF; // Link to Macro Reference (unnamed)
index L_TEXT TEXT; // Link to Text Element
index L_DRILL DRILL; // Link to Drill Element
index L_DRCERROR DRCERR;// Link to DRC Error Element
index L_MACRO MACRO; // Link to Library Element
};
The
L_POOL index is used for processing library definitions with the
lay_scanpool system function. The
REFCNT variable specifies, how often the pool element is currently referenced. The
NXT and
REF variables allow for fast pool element list traversal.
The index variable type L_POWLAYER provides access to the power layers defined on the currently loaded layout. The structure definition of L_POWLAYER is:
index L_POWLAYER { // Power Layer Index
index L_CNET CNET; // Link to Power Layer Net
index L_LEVEL LEVEL; // Link to Power Layer Level
int LAYER; // Power Layer Code (LAY1)
};
The
CNET variable provides access to the net defined with the corresponding power layer. The
LEVEL variable can be used to check the signal level of the corresponding power layer.
The L_TEXT index variable type provides access to text data defined on the currently loaded layout element. The structure definition of L_TEXT is:
index L_TEXT { // Text Index
string STR; // Text String
double X; // Text X Coordinate (STD2)
double Y; // Text Y Coordinate (STD2)
double ANGLE; // Text Rotation Angle (STD3)
double SIZE; // Text Size (STD2)
double WIDTH; // Text Line Width (STD2)
int LAYER; // Text Layer (LAY1)
int MIRROR; // Text Mirror Flag (STD14)
int MODE; // Text Mode (LAY2)
};
The L_UREF index variable type provides access to the unnamed macro references, i.e., the library elements placed on the currently loaded element without name-specification. These are vias on layout and/or part hierarchy level or pads on padstack hierarchy level. The structure definition of L_UREF is:
index L_UREF { // Unnamed Reference Index
int TREE; // Reference Net Tree Number
double X; // Reference X Coordinate (STD2)
double Y; // Reference Y Coordinate (STD2)
double ANGLE; // Reference Rotation Angle (STD3)
int LAYOFF; // Reference Layer Offset (LAY1)
int MIRROR; // Reference Mirror Flag (STD14)
index L_MACRO MACRO; // Link to Macro
};
The
MACRO variable provides a cross link for accessing the referenced library element. The
LAYOFF variable is only valid for pads on padstack hierarchy level.
This section describes the Bartels User Language index variable types for the CAM View data access (CV).
The CV_DATASET index variable type provides access to the currently loaded CAM View data sets. The structure definition of CV_DATASET is:
index CV_DATASET { // Data Set
int IDX; // Data Set Index
int TYP; // Data Set Type
int LLAYER; // Data Set Line Layer (LAY1)
int FLAYER; // Data Set Flash Layer (LAY1)
double XOFF; // Data Set X Offset (STD2)
double YOFF; // Data Set Y Offset (STD2)
int MIRROR; // Data Set Mirror Flag (STD14)
string NAME; // Data Set File Name
};
This section describes the Bartels User Language index variable types for the IC Design data access (ICD).
The I_ATTRIBUTE index variable type provides access to the connection list part or net attributes of the currently loaded IC layout. The structure definition of I_ATTRIBUTE is:
index I_ATTRIBUTE { // Attribute Index
string NAME; // Attribute Name
string VALUE; // Attribute Value
};
The I_CNET index variable type provides access to the connection list nets of the currently loaded IC layout. The structure definition of I_CNET is:
index I_CNET { // Connection List Net Index
string NAME; // Net Name
int NUMBER; // Net Tree Number
int PRIOR; // Net Routing Priority
double RDIST; // Net Minimum Distance (STD2)
int PINN; // Net Pin Count
index I_CPIN; // Net Pin List
index I_ATTRIBUTE; // Net Attribute List
index I_POOL UNRPOOL; // Link to Unroutes Pool Element
};
The net tree number is used for identifying the net. The
icd_gettreeidx function provides access to the
I_CNET index for a given net tree number. The minimum distance applies to the traces of the net; this distance must at minimum be kept to copper structures not belonging to the corresponding net. The net pin and/or attribute list can be accessed through a corresponding
forall-of loop. The
UNRPOOL variable provides access to the unrouted connections of the net; the corresponding airlines can be processed with the
icd_scanpool system function.
The I_CPART index variable type provides access to the connection list parts of the currently loaded IC layout. The structure definition of I_CPART is:
index I_CPART { // Connection List Part Index
string NAME; // Part Name
string PLNAME; // Part Physical Library Name
int USED; // Part Placement Code:
// 0 = Part not placed
// 1 = Part placed
int PEQUC; // Part Equivalence Code
int PINN; // Part Pin Count
int FPINN; // Part Free Pin Count
index I_MACRO MACRO; // Link to Macro
index I_CPIN; // Part Pin List
index I_ATTRIBUTE; // Part Attribute List
};
The part pin and/or attribute lists can be accessed through corresponding
forall-of loops. Component swaps can be applied on parts with identical equivalence codes to optimize the placement.
The I_CPIN index variable type provides access to the connection list part pins of the currently loaded IC layout. The structure definition of I_CPIN is:
index I_CPIN { // Net List Pin Index
string NAME; // Pin Name
double RWIDTH; // Pin Routing Width (STD2)
int TREE; // Pin Net Tree Number
int GATE; // Pin Gate Number
int GEQUC; // Pin Gate Equivalence Code
int GEQUP; // Pin Equivalence Code
int GGRPC; // Pin Gate Group Number
int GPNUM; // Pin Gate Relative Number
index I_CNET CNET; // Link to Pin Net
index I_CPART CPART; // Link to Pin Part
};
The pin routing width defines the width for routing to the next connection point. The
CNET and
CPART variables provide backward links to the corresponding connection list net and part entries, respectively. The
GATE,
GEQUC,
GEQUP,
GGRPC and
GPNUM variables can be utilized for checking pin/gate swap allowance.
The index variable type I_FIGURE provides access to all placed figure elements (polygons, traces, macro references, texts) of the currently loaded IC Design element. The structure definition of I_FIGURE is:
index I_FIGURE { // Figure Element Index
int TYP; // Element Type (CAP3)
string NAME; // Element Name
double SIZE; // Element Size (STD2)
double X; // Element X Coordinate (STD2)
double Y; // Element Y Coordinate (STD2)
double ANGLE; // Element Rotation Angle (STD3)
int MIRROR; // Element Mirror Mode (STD14)
int LAYER; // Element Layer (ICD1)
int GROUP; // Element Group Flag (STD13)
int FIXED; // Element Fixed Flag (STD11)
int TREE; // Element Net Tree Number
int RULEOBJID; // Element Rule System Object Id
index I_POOL POOL; // Link to Pool Element
index I_POLY POLY; // Link to Polygon Element
index I_LINE LINE; // Link to Trace Element
index I_NREF NREF; // Link to Macro Reference (named)
index I_UREF UREF; // Link to Macro Reference (unnamed)
index I_TEXT TEXT; // Link to Text Element
};
The
NAME variable holds either the name for a named macro reference or the string of a text element. The
LAYOUT variable specifies the element layer number. The
POOL variable provides a cross link to the library pool element which builds up the figure element. The figure element attributes can be changed with the
ced_elem*chg functions. A feature for scanning the complete figure element data with all hierarchy levels is provided with the
icd_scanfelem function.
The I_LEVEL index variable type provides access to the connectivity levels, i.e., the net list and/or signal levels of the currently loaded IC layout. The structure definition of I_LEVEL is:
index I_LEVEL { // Connectivity Level Index
int LEVVAL; // Level Value (ICD6)
};
The I_LINE index variable type provides access to the path and/or trace data defined on the currently loaded IC layout. The structure definition of I_LINE is:
index I_LINE { // Line Path Index
double WIDTH; // Line Path Width (STD2)
int LAYER; // Line Path Layer (ICD1)
int TREE; // Line Path Tree Number
int PN; // Line Path Point Count
index I_POINT; // Line Path Point List
};
The I_MACRO index variable type provides access to the macros, i.e., the library elements (cell, pin) used on the currently loaded IC Design element. The structure definition of I_MACRO is:
index I_MACRO { // Macro Definition Index
string NAME; // Macro Name
double MLX; // Left Macro Border (STD2)
double MLY; // Lower Macro Border (STD2)
double MUX; // Right Macro Border (STD2)
double MUY; // Upper Macro Border (STD2)
double MNX; // Macro Origin X Coordinate (STD2)
double MNY; // Macro Origin Y Coordinate (STD2)
int CLASS; // Macro Class Code (STD1)
int COMP; // Macro Status (STD16)
};
The I_NREF index variable type provides access to the named macro references, i.e., the name-specified library elements placed on the currently loaded element. These are cells on IC layout hierarchy level or pin on cell hierarchy level. The structure definition of I_NREF is:
index I_NREF { // Named Reference Index
string NAME; // Reference Name
double X; // Reference X Coordinate (STD2)
double Y; // Reference Y Coordinate (STD2)
double ANGLE; // Reference Rotation Angle (STD3)
double SCALE; // Reference Scale Factor
int MIRROR; // Reference Mirror Flag (STD14)
index I_MACRO MACRO; // Link to Macro
};
The
MACRO variable provides a cross link for accessing the referenced library element.
The I_POINT index variable type provides access to the polygon points of a specific polygon or trace element. The structure definition of I_POINT is:
index I_POINT { // Polygon Point Index
double X; // Polygon Point X Coordinate (STD2)
double Y; // Polygon Point Y Coordinate (STD2)
int TYP; // Polygon Point Type (STD15)
};
The
I_POINT index can only be applied as
of-index for the point lists in
I_POLY and/or
I_LINE.
The I_POLY index variable type provides access to the polygons (active areas, forbidden areas, outline, documentary lines) defined on the currently loaded IC Design element. The structure definition of I_POLY is:
index I_POLY { // Polygon Index
int LAYER; // Polygon Layer (ICD1)
int TREE; // Polygon Net Tree Number
int TYP; // Polygon Type (ICD4)
int MVIS; // Polygon Mirror Mode (ICD3)
int PN; // Polygon Point Count
index I_POINT; // Polygon Point List
};
The polygon net tree number is only valid for active areas. The icd_scanfelem and/or icd_scanall function must be used to check the signal level of passive copper.
The I_POOL index variable type provides access to the currently loaded pool elements. The structure definition of I_POOL is:
index I_POOL { // Pool Element Index
int TYP; // Pool Element Type (ICD7)
int REFCNT; // Pool Element Reference Count
int LAYER; // Pool Element Layer (ICD1)
index I_POOL NXT; // Link to Next Pool Element
index I_POOL REF; // Link to Reference Pool Element
index I_POLY POLY; // Link to Polygon Element
index I_LINE LINE; // Link to Trace Element
index I_NREF NREF; // Link to Macro Reference (named)
index I_UREF UREF; // Link to Macro Reference (unnamed)
index I_TEXT TEXT; // Link to Text Element
index I_MACRO MACRO; // Link to Library Element
};
The
I_POOL index is used for processing library definitions with the
icd_scanpool system function. The
REFCNT variable specifies, how often the pool element is currently referenced. The
NXT and
REF variables allow for fast pool element list traversal.
The I_TEXT index variable type provides access to text data defined on the currently loaded IC Design element. The structure definition of I_TEXT is:
index I_TEXT { // Text Index
string STR; // Text String
double X; // Text X Coordinate (STD2)
double Y; // Text Y Coordinate (STD2)
double ANGLE; // Text Rotation Angle (STD3)
double SIZE; // Text Size (STD2)
int LAYER; // Text Layer (ICD1)
int MIRROR; // Text Mirror Flag (STD14)
int MODE; // Text Mode (ICD2)
};
The I_UREF index variable type provides access to the unnamed macro references, i.e., the library elements placed on the currently loaded element without name specification. These are vias on IC layout hierarchy level. The structure definition of I_UREF is:
index I_UREF { // Unnamed Reference Index
int TREE; // Reference Net Tree Number
double X; // Reference X Coordinate (STD2)
double Y; // Reference Y Coordinate (STD2)
double ANGLE; // Reference Rotation Angle (STD3)
double SCALE; // Reference Scale Factor
int MIRROR; // Reference Mirror Flag (STD14)
index I_MACRO MACRO; // Link to Macro
};
The
MACRO variable provides a cross link for accessing the referenced library element.
| Bartels :: Bartels AutoEngineer :: BAE Documentation :: User Language Programmer's Guide :: Index Variable Types |
Index Variable Types
© 1985-2025 Oliver Bartels F+E