leDefineMPPTemplate

leDefineMPPTemplate(
 ?techId              d_techId
 ?name                S_name
 ?layer               list(layerName layerPurpose)
 [ ?width             n_width ]
 [ ?justification     S_justification ]
 [ ?offset            n_offset ]
 [ ?endType           S_endType ]
 [ ?beginExt          n_beginExt ]
 [ ?endExt            n_endExt ]
 [ ?choppable         g_choppable ]

 [ ROD Connectivity Arguments ]
 [ ?offsetSubPath     l_offsetSubpathArgs... ]
 [ ?encSubPath        l_encSubpathArgs... ]
 [ ?subRect           l_subrectArgs... ]

) ; end leDefineMPPTemplate
=> t / nil

 ; ROD Connectivity Arguments
 [ ?termIOType             S_termIOType ]
 [ ?pin                     g_pin ]
 [ ?pinAccessDir           tl_pinAccessDir ]
 [ ?pinLabel               g_pinLabel ]
 [ ?pinLabelHeight         n_pinLabelHeight ]
 [ ?pinLabelLayer          txl_pinLabelLayer ]
 [ ?pinLabelFont           S_pinLabelFont ]
 [ ?pinLabelDrafting        g_pinLabelDrafting ]
 [ ?pinLabelOrient         S_pinLabelOrient ]
 [ ?pinLabelOffsetPoint     l_pinLabelOffsetPoint ]
 [ ?pinLabelJust           S_pinLabelJust ]
 [ ?pinLabelRefHandle      S_pinLabelRefHandle ]
 ; end of ROD Connectivity Arguments

 ;l_offsetSubpathArgs 
 list(
  list(
   ?layer             list(layerName layerPurpose)
   [ ?width           n_width ]
   [ ?sep             n_sep ]
   [ ?justification   S_justification ]
   [ ?beginOffset     n_beginOffset ]
   [ ?endOffset       n_endOffset ]
   [ ?choppable       g_choppable ]
   [ Repeat ROD Connectivity Arguments here ]
   ) ;End of first offset subpath list
   ...  
  ) ;End of offset subpath lists
 ;End of l_offsetSubpathArgs

 ;l_encSubpathArgs 
 list(
  list(
   ?layer             list(layerName layerPurpose)
   [ ?enclosure       n_enclosure ]
   [ ?beginOffset     n_beginOffset ]
   [ ?endOffset       n_endOffset ]
   [ ?choppable       g_choppable ] 
   [ Repeat ROD Connectivity Arguments here ]
   ) ;End of first enclosure subpath list
   ...  
  ) ;End of enclosure subpath lists
 ;End of l_encSubpathArgs

 ;l_subrectArgs 
 list(
  list(
   ?layer              list(layerName layerPurpose)
   [ ?width            n_width ]
   [ ?length           n_length ]
   [ ?gap              S_gap ]
   [ ?sep              n_sep ]
   [ ?justification    S_justification ]
   [ ?beginOffset      n_beginOffset ]
   [ ?endOffset        n_endOffset ]
   [ ?beginSegOffset   n_beginSegmentOffset
   [ ?endSegOffset     n_endSegmentOffset
   [ ?space            n_space ]
   [ ?choppable        g_choppable ]
   [ Repeat ROD Connectivity Arguments here ]
   [?diagonal g_diagonalSubRect]
   ) ;End of first subrectangle list
   ...  
  ) ;End of subrectangle lists
 ;End of l_subrectArgs

Description

Provides the structure for defining the field names and default values for one multipart path (MPP) in an ASCII file. This information is referred to as an MPP template. A multipart path is a single relative object design (ROD) object consisting of one or more parts at level zero in the hierarchy on the same or on different layers. The purpose of an MPP template is to create MPPs in layout cellviews using predefined values. You can define any number of MPP templates in a single ASCII file by specifying leDefineMPPTemplate once for each MPP template; each template must be identified by a template name (t_name) that is unique within the ASCII file.

Arguments

d_techId	The database ID of the technology library associated with the current cellview.
S_name	Character string enclosed in double quotation marks specifying the name of the MPP template. The name must be unique within the MPP templates in the ASCII file. Do not assign the name `New`; it is a reserved name. Default: none

All other arguments for leDefineMPPTemplate have the same names, definitions, valid values, and default values as the arguments for the rodCreatePath function. For a detailed description of each argument, see the Arguments section of the rodCreatePath function.

Value Returned

`t`	Returned if the argument list is created successfully.
`nil`	Returned if the argument list is not created successfully.

ASCII MPP Template File

When you load an ASCII MPP template file, the system checks the names of the ASCII MPP templates against the names of MPP templates that already exist in the technology file in virtual memory. If there is a name conflict, the system displays a message in the CIW saying that an MPP template in the ASCII file is replacing an existing MPP template. The existing template is overwritten in virtual memory only. If you do not want to overwrite the original MPP template in your binary technology library on disk, do not save changes to the technology file. You can also avoid overwriting existing templates by changing the matching names in your ASCII file. For more information, see Template templateName is replacing an existing template by same name.

The system merges the ASCII MPP template definitions into the technology file in virtual memory. When you choose the Virtuoso Layout Suite Create – Multipart Path command (and press F3), the system displays the names of all MPP templates MPP Template list in the Create Multipart Path form.

You can load ASCII files in any of the following ways:

In Virtuoso Layout Suite, with the Create – Multipart Path command, using the Load Template option.

In the CIW, with the following statement:

load "pathToFile/templateFilename.il"

For example,

load "../skill/mppTemplates.il"

In the .cdsinit file
You can identify ASCII MPP template files in your .cdsinit file. The system automatically executes the .cdsinit file when the Cadence^® design framework II product starts, and loads the identified files.
In the libInit.il file
You can attach ASCII MPP template files to your library by identifying them in a libInit.il file. The system automatically executes the libInit.il file when a library is opened and loads attached files.
Avoid using graphical SKILL functions such as hiSetBindKey in your libInit.il file; doing so will result in an error. For more information, see What to Avoid in the libInit.il File.
To attach a file to a library:
- Place the file within the library directory.
- In the library directory, create or update a file named libInit.il.
- Within the libInit.il file, write a load statement as follows:
```
load "pathToFile/templateFilename.il"
```

Loading MPP templates from an ASCII file affects only the temporary version of your technology library in virtual memory. If you want the loaded templates and changes you make to their values with the Create Multipart Path form to persist beyond the end of the current editing session, you must save the changes to your binary technology library on disk before you exit the software. Remember that MPP templates loaded from ASCII files overwrite templates with matching names in the technology file in virtual memory, and when you save changes to your technology file, the virtual memory version overwrites your technology library on disk.

You can create an ASCII MPP template file:

With a text editor
With Virtuoso Layout Suite by using the Save Template option on the Create Multipart Path form and saving to ASCII

The following example shows an ASCII file containing the definitions for two MPP templates.

When you create an ASCII template file with a text editor, you need to substitute your own library and technology file names for the variables myLibraryName and myTechFileName in the example.
If you enter an invalid technology file name, the system displays a warning message in the CIW and no templates are loaded.
When you save the values in the Create Multipart Path form to ASCII, the system replaces the myLibraryName and myTechFileName variables with the name of the current library and the name of the current technology file.

If you load an ASCII file that was created with the Create Multipart Path form, make sure you are using the same library and technology file that was current when the ASCII file was created.

;; This procedure identifies the technology library and technology file names, and
;; opens the technology file in read-only mode.If the technology library does not
;; open, the procedure displays an error message and exits.If the technology library
;; opens,the procedure continues, and reads the leDefineMPPTemplate functions, 
;; each of which define the fields and values for a multipart path (MPP).


prog( 
    ( tech techLibName techFileName)
     techLibName  =         "myLibraryName"
     techFileName =         "myTechFileName"
     tech         =         techOpenTechFile( techLibName techFileName "r" )

     if(tech==nil 
  then
   return(nil)
  ) ; end if

    ; Template1 defines an MPP consisting of only a master path.

    leDefineMPPTemplate(
     ?techId            tech
  ?name             "template1"
  ?layer             list("poly1" "drawing")
  ?width             0.600000
  ?choppable         t
  ?endType           "flush"
  ?justification     "center"
  ?offset            0.700000
  ?termIOType        "switch"
  ?pin               t
  ?pinAccessDir      list( "bottom" "left" "right" )

    ) ; end leDefineMPPTemplate function for template1

    ; Template2 defines an MPP consisting of a master path, three offset subpaths, 
    ; three enclosure subpaths, and three sets of subrectangles.

    leDefineMPPTemplate(
        ; Master path
     ?techId          tech
     ?name            "Template2"
     ?layer           "cellBoundary"
     ?width           0.600000

      ; Three offset subpaths

      ?offsetSubPath   
      list(
                            list(
                                  ?layer           list("pwell" "drawing")
                                  ?width           1.000000
                                  ?choppable       t
                                  ?sep             2.000000
                            ) ; end of first sublist
                            list(
                                  ?layer           list("poly1" "drawing")
                                  ?width           1.000000
                                  ?choppable       t
                                  ?sep             4.000000
                            ) ; end of second sublist
                            list(
                                  ?layer           list("metal1" "drawing")
                                  ?width           1.000000
                                  ?choppable       t
                                  ?sep             6.000000
                            ) ; end of third sublist
                ) ; end of offset subpath lists

      ; Three enclosure subpaths

      ?encSubPath      
      list(
                            list(
                                  ?layer           list("metal2" "drawing")
                                  ?enclosure       0.100000
                                  ?choppable       t
                                  ?beginOffset     0.100000
                                  ?endOffset       0.200000
                ) ; end of first sublist
                            list(
                                  ?layer           list("metal3" "drawing")
                                  ?enclosure       0.150000
                                  ?choppable       t
                                  ?beginOffset     0.200000
                                  ?endOffset       0.300000
                ) ; end of second sublist
                            list(
                                  ?layer           list("ndiff" "drawing")
                                  ?enclosure       0.180000
                                  ?choppable       t
                                  ?beginOffset     0.300000
                                  ?endOffset       0.400000
                            ) ; end of third sublist
                ) ; end of enclosure subpath lists

      ; Three sets of subrectangles

      ?subRect         
      list(
                            list(
                                  ?layer           list("pdiff" "drawing")
                                  ?width           0.500000
                                  ?length          0.600000
                                  ?choppable       t
                                  ?sep             0.200000
                                  ?space           1.000000
                            ) ; end of first sublist
                            list(
                                  ?layer           list("pwell" "drawing")
                                  ?width           0.600000
                                  ?length          0.800000
                                  ?choppable       t
                                  ?sep             0.500000
                                  ?space           3.000000
                            ) ; end of second sublist
                            list(
                                  ?layer           list("poly1" "drawing")
                                  ?width           0.800000
                                  ?length          1.000000
                                  ?choppable       t
                                  ?sep             2.000000
                                  ?space           5.000000
                            ) ; end of third list
                ) ; end of subrectangle lists
    ) ; end leDefineMPPTemplate function for template2

) ; end prog

Differences Between leDefineMPPTemplate and rodCreatePath Syntax

The syntax for specifying an MPP template with leDefineMPPTemplate is based on the syntax of the rodCreatePath function. Most arguments are the same and have the same default values. The following are the differences between the syntax for an MPP template specified with leDefineMPPTemplate and rodCreatePath:

For some arguments, the data type is more restricted for leDefineMPPTemplate than it is for rodCreatePath:
- For the ?layer argument, leDefineMPPTemplate requires a list; rodCreatePath accepts a text string or an integer, or a list specifying the layer or layer-purpose pair.
- For arguments with the data type S_, leDefineMPPTemplate requires a character string (the data type is t_ for text); rodCreatePath allows either a character string or a symbol.
For the remaining arguments that leDefineMPPTemplate and rodCreatePath have in common, the argument definitions, valid values, and default values are identical.
leDefineMPPTemplate has one additional argument: t_name
You cannot specify an expression as a value for any of the leDefineMPPTemplate arguments.

leDefineMPPTemplate does not contain the following rodCreatePath arguments:

d_cvId	The current cellview is used.
S_name	The system generates a default ROD name when you create an MPP in a cellview; you can change it in the ROD Name field on the Create ROD Multipart Path form or in the Edit Properties form.
S_netName	When the MPP template you choose includes the definition of pin connectivity, to create an MPP in a layout cellview, you must enter a value for the Net Name field in the Create ROD Multipart Path form.
S_termName	When the MPP template includes the definition of pin connectivity, the system assigns the net name you enter for terminal name.
l_pts	Click in the layout cellview to specify the point list.
l_prop	There is no property field in the Create Multipart Path forms, so this argument has been omitted.

leDefineMPPTemplate does not contain the rodCreatePath arguments listed below because these arguments represent an alternate way of specifying a point list for an MPP, and the point list varies for each occurrence of an MPP within a layout cellview.
dl_fromObj txf_size l_startHandle l_endHandle

Virtuoso Layout Suite SKILL Reference
Product Version IC23.1, November 2023