Bartels :: Bartels AutoEngineer :: BAE Documentation :: User Language Programmer's Guide :: Index Variable Types :: Schematic Capture Index Description (CAP)

Bartels User Language - Programmer's Guide

B.3 Schematic Capture Index Description (CAP)

This section describes the Bartels User Language index variable types for the Schematic Capture data access (CAP).

C_ATTRIBUTE - SCM Part Attribute

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.

C_BUSTAP - SCM Bus Tap

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.

C_CNET - SCM Logical Net List

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

C_CONBASE - SCM Connection Segment Group

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.

C_CONSEG - SCM Connection Segment

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.

C_FIGURE - SCM Figure Element

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.

C_LEVEL - SCM Signal Level

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.

C_MACRO - SCM Library Element

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.

C_NREF - SCM Named Macro Reference

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.

C_POINT - SCM Polygon Point

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.

C_POLY - SCM Polygon

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.

C_POOL - SCM Pool Element

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.

C_TEXT - SCM Text

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

CL_ALTPLNAME - Layout Net List Alternate Part Package Type

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

CL_ATTRIBUTE - Layout Net List Attribute

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

CL_CNET - Layout Net List

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.

CL_CPART - Layout Net List Part Entry

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.

CL_CPIN - Layout Net List Part Pin Entry

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.

Bartels :: Bartels AutoEngineer :: BAE Documentation :: User Language Programmer's Guide :: Index Variable Types :: Schematic Capture Index Description (CAP)