Bartels User Language - Programmer's Guide B.4 Layout Index Description (LAY)

This section describes the Bartels User Language index variable types for the Layout data access (LAY).

L_ALTPLNAME - Layout Net List Alternate Part Package Type

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
      };

L_ATTRIBUTE - Layout Net List Attribute

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
      };

L_CNET - Layout Net List

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.

L_CPART - Layout Net List Part Entry

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.

L_CPIN - Layout Net List Part Pin Entry

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.

L_DRCERROR - Layout DRC Error Marker

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
      };

L_DRCERROROK - Layout DRC Error Acceptance

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
      };

L_DRILL - Layout Drill Hole

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.

L_FIGURE - Layout Figure Element

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.

L_LEVEL - Layout Signal Level

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)
      };

L_LINE - Layout Trace

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
      };

L_MACRO - Layout Library Element

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)
      };

L_NREF - Layout Named Macro Reference

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.

L_POINT - Layout Polygon Point

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.

L_POLY - Layout Polygon

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.

L_POOL - Layout Pool Element

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.

L_POWLAYER - Layout Power Layer

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.

L_TEXT - Layout Text

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)
      };

L_UREF - Layout Unnamed Macro Reference

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.

Layout Index Description (LAY)
© 1985-2025 Oliver Bartels F+E