GLISTER SKILL API Functions

xmodelCreateDefaultConfig(
      libName
      cellName
      viewName
      [ configName ]
      [ inMemory ]
)
=> configId

libName	Library name of the design cellview.
cellName	Cell name of the design cellview.
viewName	View name of the design cellview.
configName	Desired configuration view name (default: “config”).
inMemory	Optional flag whether to create an in-memory configuration (default: nil).

configId

The created configuration view object ID.

xmodelCreateDefaultConfig( "myLib" "myCell" "schematic" "config" )

xmodelEditConfig(
      [ libName ]
      [ cellName ]
      [ viewName ]
      [ mode ]
)

libName	Library name of the configuration view (default: nil).
cellName	Cell name of the configuration view (default: nil).
viewName	View name of the configuration view (default: nil).
mode	Access mode (“r”: read, “w”: write, “a”: append). (default: “r”).

None

xmodelEditConfig( "myLib" "myCell" "config" "a" )

xmodelEditParam(
      [ libName ]
      [ cellName ]
      [ viewName ]
)

libName cellName viewName

Library/cell/view names of the model schematic view (default: library/cell/view names of the currently-editing cellview).

None

xmodelEditParam( "myLib" "myCell" "schematic" )

xmodelGenNetlist(
      [ libName ]
      [ cellName ]
      [ viewName ]
      [ simDir ]
      [ simulator ]
      [ verbose ]
)
=> ( sim_dir netlist_dir )

libName cellName viewName	Library/cell/view names of the top-level design cellview (default: those of the currently-editing cellview).
simDir	Simulation directory to store the generated netlist files (if not specified or nil, it is derived from $XMODEL_SIMDIR and the cellview name).
simulator	Simulator specifier in : format determining the netlist format. The possible values for the model_simulator field are: xmodel and those for the spice_simulator field are those used by the Cadence netlisters (e.g. hspiceD, spectre, veriloga, …). Default is set by the values of two SKILL variables: xmodelModelSimulator and xmodelSpiceSimulator (e.g. “xmodel:hspiceD”).
verbose	If t, display verbose messages during netlisting (default: t).

sim_dir	The path to the simulation directory.
netlist_dir	The path to the netlist directory (usually /models).

xmodelGenNetlist( "myLib" "myCell" "schematic" )

xmodelDispNetlist(
      [ libName ]
      [ cellName ]
      [ viewName ]
      [ simDir ]
)

libName cellName viewName	Library/cell/view names of the top-level design cellview (default: those of the currently-editing cellview).
simDir	Simulation directory to store the generated netlist files (if not specified or nil, it is derived from $XMODEL_SIMDIR and the cellview name).

None

xmodelDispNetlist( "myLib" "myCell" "schematic" )

xmodelRunSim(
      [ libName ]
      [ cellName ]
      [ viewName ]
      [ simDir ]
      [ prepOnly ]
      [ runOnly ]
      [ wait ]
)
=> t

libName cellName viewName	Library/cell/view names of the top-level design or testbench cellview (default: those of the currently-editing cellview).
simDir	Simulation directory storing the generated netlist files. (if not specified or nil, it is derived from $XMODEL_SIMDIR and the cellview name).
prepOnly	If t, prepare simulation directory and do not run the simulation (default: nil).
runOnly	If t, run simulation within the specified simulation directory (simDir) without examining whether the netlist files need to be generated (default: nil).
wait	If t, run the simulation in foreground mode and wait until the simulation is completed (default: nil).

t

xmodelRunSim( "myLib" "myCell" "tb_run" )

xmodelStopSim()

=> t

None

t

xmodelStopSim()

xmodelOpenWave(
      [ libName ]
      [ cellName ]
      [ viewName ]
      [ simDir ]
)

libName cellName viewName	Library/cell/view names of the top-level design or testbench cellview (default: those of the currently-editing cellview).
simDir	Simulation directory storing the simulation results. (if not specified or nil, it is derived from $XMODEL_SIMDIR and the cellview name).

None

xmodelOpenWave( "myLib" "myCell" "tb_run" )

xmodelAddProbe(
      [ window ]
      [ netName ]
      [ repeat ]
)

window	ID of the schematic editor window (default: ID of the currently editing window).
netName	The name of the net to be probed from the window. If it is not specified or nil, the procedure enters into an interactive mode for the user to select the net from the schematic window using a mouse click.
repeat	If t, the procedure stays in the interactive mode for further selection of nets to be probed.

None

xmodelAddProbe()

xmodelDisplayAllProbes(
      [ window ]
)

window

ID of the schematic editor window (default: ID of the currently editing window).

None

xmodelDisplayAllProbes()

xmodelDeleteAllProbes(
      [ window ]
)

window

ID of the schematic editor window (default: ID of the currently editing window).

None

xmodelDeleteAllProbes()

xmodelDispSplash()

None

None

xmodelDispSplash()

xmodelDialogImport(
      [ libName ]
      [ filePath ]
)

libName	Optional argument setting the default library name in the GUI dialog window.
filePath	Optional argument setting the default file path to the model file in the GUI dialog window.

None

xmodelDialogImport()

xmodelOpenCellView(
      libName
      cellName
      [ viewName ]
      [ accessMode ]
      [ uiMode ]
)

libName cellName viewName	Library, cell, view names of the xmodel-type cellview. The default view name is “xmodel”.
accessMode	Access mode (“r”: read, “w”: write, “a”: append). Default is “r”.
uiMode	User interface mode (“text” for text-based interface and “gui” for GUI-based interface). Default is “text”.

None

xmodelOpenCellView( "myLib" "myCell" "xmodel" "a" )

xmodelImportCellView(
      srcFile
      libName
      [ cellName ]
      [ viewName ]
      [ genSymbol ]
      [ checkSyntax ]
      [ uiMode ]
)
=> t

srcFile	Name of the XMODEL source file to be imported.
libName	Library name of the xmodel-type cellview to be created.
cellName	Cell name of the xmodel-type cellview to be created. The XMODEL source file must define a module with the matching name. If not specified or nil, the name of the first module found in the XMODEL source file is used as the cell name.
viewName	View name of the xmodel-type cellview to be created (default: “xmodel”).
genSymbol	If t, generate a symbol view from the port list defined in the XMODEL source file (default: t).
checkSyntax	If t, check the syntax of the XMODEL source file before importing (default: t).
uiMode	User interface mode (“text” for text-based interface and “gui” for GUI-based interface). Default is “text”.

t

xmodelImportCellView( "model.sv" "myLib" "myCell" )

xmodelUpdateCellView(
      libName
      cellName
      [ viewName ]
      [ genSymbol ]
      [ uiMode ]
)

libName	Library name of the xmodel-type cellview.
cellName	Cell name of the xmodel-type cellview.
viewName	View name of the xmodel-type cellview (default: “xmodel”).
genSymbol	If t, update a symbol for the xmodel-type cellview with the newly extracted port definitions (default: t).
uiMode	User interface mode (“text” for text-based interface and “gui” for GUI-based interface). Default is “text”.

None

xmodelUpdateCellView( "myLib" "myCell" "xmodel" t )

xmodelCheckCellView(
      libName
      cellName
      [ viewName ]
      [ uiMode ]
)

Value Returned

Example

xmodelCheckCellView( "myLib" "myCell" "xmodel" )

Check and update the properties of the xmodel-type cellview myLib:myCell:xmodel if they are inconsistent with the information stored in the XMODEL source file.

XMODEL Testbench Cellview Management

The SKILL API functions in this category provide a procedural way of creating a new XMODEL testbench cellview, opening it in the XMODEL Testbench Editor, and running the simulation as specified in the XMODEL testbench cellview.

xmodelCreateTestbench

xmodelCreateTestbench(
      [ libName ]
      [ cellName ]
      [ viewName ]
)

Description

Create a new testbench cellview with default attributes.

Arguments

Value Returned

Example

xmodelCreateTestbench( "myLib" "myCell" "tb" )

Create a new testbench cellview myLib:myCell:tb with default attributes.

xmodelOpenTestbenchEditor

xmodelOpenTestbenchEditor(
      [ libName ]
      [ cellName ]
      [ viewName ]
)

Description

Open a testbench cellview in the XMODEL Testbench Editor. With the XMODEL Testbench Editor, user can control various options and attributes for performing XMODEL simulations in the GLISTER environment.

Arguments

Value Returned

Example

xmodelOpenTestbenchEditor( "myLib" "myCell" "tb" )

Open a testbench cellview myLib:myCell:tb in the XMODEL Testbench Editor.

xmodelRunTestbench

xmodelRunTestbench(
      libName
      cellName
      viewName
      mode
)

Description

Execute an operation as defined in the testbench view. The supported operations include generating netlists, displaying the netlists, running the simulation, and plotting waveforms. These operations correspond to the actions available in the XMODEL Testbench Editor.

Arguments

Value Returned

Example

xmodelRunTestbench( "myLib" "myCell" "tb" "runsim" )

Start the XMODEL simulation as specified in the testbench cellview myLib:myCell:tb.

MODELZEN Menu Actions

The SKILL API functions in this category provide a procedural way of performing the actions available in the GLISTER/MODELZEN pull-down menu, such as running the MODELZEN either in an interactive or batch mode and opening the dialog window for setting the MODELZEN options.

modelzenRunInteractive

modelzenRunInteractive(
      [ ?libName libName ]
      [ ?cellName cellName ]
      [ ?viewName viewName ]
      [ ?netlistSimulator netlistSimulator ]
      [ ?runDir runDir ]
      [ ?netlistDir netlistDir ]
      [ ?simDir simDir ]
      [ ?outDir outDir ]
      [ ?configFile configFile ]
      [ ?corner corner ]
      [ ?logFile logFile ]
      [ ?forceSim forceSim ]
      [ ?modelView modelView ]
      [ ?showCompletionMsgBox showCompletionMsgBox ]
)

=> processId

Description

Start an interactive session to generate structural models from circuit schematics using MODELZEN. An interactive session interacts with the user through a graphical user interface such as displaying the progress, asking for user confirmation, and notifying the completion. This is the action triggered when the GLISTER->Run MODELZEN pull-down menu is selected.

Basically, the model generation session consists of the following four steps:

1. Generating circuit netlists (e.g. spectre or hspiceD netlists) from the circuit schematics using the method defined in the modelzenGenNetlist() procedure.
2. Extracting the MODELZEN properties included in the circuit schematics.
3. Generating structural models from the circuit netlists using MODELZEN.
4. Import the generated XMODEL source files into the Cadence Virtuoso design database.

Many of the argument options of this procedure use the default values defined by the modelzenDefault… SKILL variables if they are not explicitly specified. The values of those SKILL variables can be set at start-up or modified from the Set MODELZEN Options dialog box which can be invoked by selecting the GLISTER->Set MODELZEN Options pull-down menu. For more details, please refer to the MODELZEN User Guide.

Arguments

Value Returned

Example

modelzenRunInteractive( "myLib" "myCell" "schematic" )

Start an interactive session to generate structural models of a top-level circuit schematic cellview myLib:myCell:schematic using MODELZEN.

modelzenRunBatch

modelzenRunBatch(
      [ ?libName libName ]
      [ ?cellName cellName ]
      [ ?viewName viewName ]
      [ ?netlistSimulator netlistSimulator ]
      [ ?runDir runDir ]
      [ ?netlistDir netlistDir ]
      [ ?simDir simDir ]
      [ ?outDir outDir ]
      [ ?configFile configFile ]
      [ ?corner corner ]
      [ ?logFile logFile ]
      [ ?forceSim forceSim ]
      [ ?modelView modelView ]
)

Description

Start a non-interactive (i.e. batch) session to generate structural models from circuit schematics using MODELZEN. A non-interactive session does not interact with the user during the process of model generation and is suitable for generating a set of models using a batch script.

Basically, the model generation session consists of the following four steps:

1. Generating circuit netlists (e.g. spectre or hspiceD netlists) from the circuit schematics using the method defined in the modelzenGenNetlist() procedure.
2. Extracting the MODELZEN properties included in the circuit schematics.
3. Generating structural models from the circuit netlists using MODELZEN.
4. Import the generated XMODEL source files into the Cadence Virtuoso design database.

Many of the argument options of this procedure use the default values defined by the modelzenDefault… SKILL variables if they are not explicitly specified. The values of those SKILL variables can be set at start-up or modified from the Set MODELZEN Options dialog box which can be invoked by selecting the GLISTER->Set MODELZEN Options pull-down menu. For more details, please refer to the MODELZEN User Guide.

Arguments

Value Returned

Example

modelzenRunBatch( "myLib" "myCell" "schematic" )

Generate structural models of a top-level circuit schematic cellview myLib:myCell:schematic using MODELZEN in a batch mode.

modelzenDialogSetOptions

modelzenDialogSetOptions()

Description

Open a GUI dialog for setting MODELZEN options. This is the action triggered when the GLISTER->Set MODELZEN Properties pull-down menu is selected.

Arguments

Value Returned

Example

modelzenDialogSetOptions()

Open a GUI dialog for setting MODELZEN options.

MODELZEN Property Editing and Management

The SKILL API functions in this category provide ways of managing the MODELZEN properties defined on schematic cellviews, such as on the pin or cell instances as well as importing or exporting them from/to a file.

modelzenOpenPropBrowser

modelzenOpenPropBrowser(
      [ ?libName libName ]
      [ ?cellName cellName ]
      [ ?viewName viewName ]
      [ ?hierMode hierMode ]
)

Description

Open the MODELZEN Property Browser. Using the MODELZEN Property Browser, users can browse the MODELZEN properties defined for the cellview’s pins or instances. This is the action triggered when the GLISTER->Edit MODELZEN Properties pull-down menu is selected.

Arguments

Value Returned

Example

modelzenOpenPropBrowser( "myLib" "myCell" "schematic" )

Open the MODELZEN Property Browser to browse the MODELZEN properties defined for the cellview myLib:myCell:schematic.

modelzenDialogEditPropObj

modelzenDialogEditPropObj(
      [ objId ]
)

Description

Open a GUI dialog window for editing MODELZEN property of a pin or instance object. If no object is selected or specified, it opens the MODELZEN Property Browser window.

Arguments

Value Returned

Example

modelzenDialogEditPropObj( pinId )

Open a GUI dialog window for editing MODELZEN property of an object (e.g. pin).

modelzenSetPropPin

modelzenSetPropPin(
      pinInst
      [ ?portDir portDir ]
      [ ?sigType sigType ]
      [ ?sigDesc sigDesc ]
      [ ?useBuf useBuf ]
      [ ?level1 level1 ]
      [ ?level0 level0 ]
      [ ?thres1 thres1 ]
      [ ?thres0 thres0 ]
      [ ?strength strength ]
)
=> pinInst

Description

Set the MODELZEN properties of a pin. By defining custom MODELZEN properties, users can individually control the type, direction, conversion levels, and thresholds for each pin in the generated model.

Arguments

Value Returned

Example

modelzenSetPropPin( pinId ?level1 2.5 ?level0 0.0 )

Set the MODELZEN properties of a pin. For instance, set the pin instance’s conversion level for logic 1 at 2.5 and conversion level for logic 0 at 0.0.

modelzenSetPropInst

modelzenSetPropInst(
      instId
      [ ?type type ]
      [ ?level_dc level_dc ]
      [ ?level_ac level_ac ]
      [ ?vmax vmax ]
      [ ?vmin vmin ]
      [ ?instterms instterms ]
      [ ?vpos vpos ]
      [ ?vneg vneg ]
      [ ?vd vd ]
      [ ?vg vg ]
      [ ?vs vs ]
      [ ?vb vb ]
)

Description

Set the MODELZEN properties of an instance. By defining custom MODELZEN properties, users can individually control the way each device instance is mapped to an XMODEL primitive by MODELZEN.

For more detailed descriptions on the model-specific attributes such as level_dc and level_ac, please refer to the MODELZEN User Guide.

Arguments

Value Returned

Example

modelzenSetPropInst( instId ?type "nmosfet" ?level_dc "pwl" ?level_ac 1 )

Set the MODELZEN properties of a pin. For instance, map the instance to an nmosfet primitive with DC accuracy level of “pwl” and AC accuracy level of 1.

modelzenDeleteProp

modelzenDeleteProp(
      libName
      [ cellName ]
      [ viewName ]
      [ instName ]
)

Description

Clear all MODELZEN properties defined for a library, cell, view, or instance. If all arguments are specified, it clears the MODELZEN properties defined for one particular instance of a particular cellview. If the instName argument is nil or not specified, it clears the MODELZEN properties for all the instances of the cellview. If the viewName argument is nil or not specified, it clears the MODELZEN properties for all the views of the cell. If the cellName argument is nil or not specified, it clears the MODELZEN properties for all the cells in the library.

Arguments

Value Returned

Example

modelzenDeleteProp( "myLib" "myCell" "schematic" )

Clear all MODELZEN properties defined in the cellview myLib:myCell:schematic.

modelzenLoadPropFile

modelzenLoadPropFile(
      [ filename ]
      [ merge ]
)
=> filename

Description

Load a MODELZEN property file into the Cadence design database. A MODELZEN property file is a file that describes the MODELZEN properties defined for the pins or instances of a set of cellviews in XML format. With modelzenSavePropFile() and modelzenLoadPropFile(), you can export and import MODELZEN properties to/from the Cadence design database, respectively.

Arguments

Value Returned

Example

modelzenLoadPropFile( "dbinfo_myCell.xml" )

Load a MODELZEN property file into the Cadence design database.

modelzenSavePropFile

modelzenSavePropFile(
      config
    [ filename ]
)
=> filename

Description

Save the MODELZEN properties defined in the Cadence design database into a MODELZEN property file. A MODELZEN property file is a file that describes the MODELZEN properties defined for the pins or instances of a set of cellviews in XML format. With modelzenSavePropFile() and modelzenLoadPropFile(), you can export and import MODELZEN properties to/from the Cadence design database, respectively.

The config argument is a configuration view ID, specifying the design hierarchy for GLISTER to export the MODELZEN properties from. GLISTER will traverse the design hierarchy as specified in the configuration view and export all MODELZEN properties encountered into an XML format file.

Arguments

Value Returned

Example

modelzenSavePropFile( configId "dbinfo_myCell.xml" )

Save the MODELZEN properties defined within the design hierarchy as specified by the configuration view into a file.

modelzenGenDBInfo

modelzenGenDBInfo(
      netlistDir
     [ libName ]
     [ cellName ]
     [ viewName ]
)
=> filename

Description

Export the MODELZEN properties defined in the Cadence design database into a MODELZEN design information (DBInfo) file. A MODELZEN design information file is a file that exports the MODELZEN properties defined for the design hierarchy in XML format for the purpose of generating models with MODELZEN. Due to their different purposes, the XML files generated by modelzenGenDBInfo() and modelzenSavePropFile() may differ and may not be used interchangeably.

The netlistDir is a location of the netlist directory and modelzenGenDBInfo() assumes that a Cadence OSS netlister has already performed netlisting within that directory and looks for various mapping information for instance and net names (e.g. current/map file).

If such mapping information cannot be found (e.g. using a non-OSS netlister), modelzenGenDBInfo() creates a default configuration that traverses down the schematic views in the design hierarchy and uses it to export the MODELZEN properties for all the design cellviews encountered. Users may override modelzenMapInstName() and modelzenMapNetName() functions to define any name translations that the netlister uses. In this case, the libName, cellName, and viewName arguments must be specified with the library, cell, and view names of the top-level cellview. Otherwise, the function skips the generation of design information file.

Arguments

Value Returned

Example

modelzenGenDBInfo( "modelzen.run/netlist/mylib.mycell:schematic" )

Exports the MODELZEN properties defined within the design hierarchy as specified by the design mapping information contained in the specified netlist directory.

modelzenGenDBInfo( "dbinfo/export" "mylib" "mycell" "schematic" )

Exports the MODELZEN properties defined in the specified top-level cellview and its hierarchies using a default configuration view even when the Cadence OSS design mapping information is not found within the specified directory.

GLISTER License Management

The SKILL API functions in this category provide a way to get the check-out status of the GLISTER license and force its check-in.

xmodelLicenseStatus

xmodelLicenseStatus()

=> t/nil

Description

Checks whether the current Cadence® Virtuoso® session has checked-out the GLISTER license.

Arguments

Value Returned

Example

xmodelLicenseStatus()

Returns the check-out status of the GLISTER license.

xmodelLicenseCheckIn

xmodelLicenseCheckIn()

=> t

Description

Checks-in the GLISTER license currently being used. No action if the license is not checked out.

Arguments

Value Returned

Example

xmodelLicenseCheckIn()

Returns the GLISTER license currently being used.

Overridable Functions for User Customization

The SKILL API functions in this category can be overridden by users to define customized behaviors for the SPICE/Spectre circuit netlisting during the GLISTER netlisting or MODELZEN model generation. For instance, one can control the pin ordering, define special mappings for the net or instance names, and generate netlists using their own in-house procedures.

xmodelGenNetlistSPICE

xmodelGenNetlistSPICE(
      libName
      cellName
      viewName
      simulator
)
=> netlistFile

Description

Generate the hierarchical SPICE netlist from a circuit schematic cellview. The procedure is called while GLISTER generates a mixed-mode co-simulation netlists. In other words, when GLISTER traverses the design hierarchy and meets a cell that can only be netlisted using the Cadence analog netlister (i.e. circuit schematic), GLISTER invokes this xmodelGenNetlistSPICE() procedure to extract the SPICE netlists of the cell and its child cells.

Note that the generated netlist must define the top-level circuits within a subcircuit definition. The default definition of xmodelGenNetlistSPICE() redefines the netlist formatter to enforce this condition for the Cadence ADE netlister.

Arguments

Value Returned

Example

procedure( xmodelGenNetlistSPICE( libName cellName viewName simulator 
                                     @key ( useTopCellSubckt t ) )
    let( ( netlistFile netlistDir saved_poport )
        ; initialize netlist formatter
        case( simulator
            ( "hspiceD"     xmodelNetlisterInitHspiceD() )
            ( "spectre"     xmodelNetlisterInitSpectre() )
            ( t
                simulator( simulator )
                warn( "Unsupported netlisting format '%s'; proceeding with the basic ADE netlister." simulator )
            )
        )

        ; ADE netlisting with silent output
        status = errset(
            let( ()
                saved_poport = poport
                poport = outfile( "/dev/null" )

                design( libName cellName viewName )
                xmodelNetlistOption = if( useTopCellSubckt then list( "use_topcellsubckt" ) else nil )
                unless( netlistFile = createNetlist( ?recreateAll t ?display nil )
                    error( "error occurred while netlisting %s.%s:%s." libName cellName viewName )
                )
                ocnCloseSession()

                close( poport )
                poport = saved_poport
            )
            t
        )

        if( status == nil then
            close( poport )
            poport = saved_poport
            error( "GLISTER is aborted while %s netlisting the cellview %s.%s:%s." simulator libName cellName viewName )
        )

        ; restore the default netlist formatter
        case( simulator
            ( "hspiceD"     xmodelNetlisterRestoreHspiceD() )
            ( "spectre"     xmodelNetlisterRestoreSpectre() )
        )

        ; return netlist filename
        netlistDir = xmodelGetDirName( netlistFile )
        strcat( netlistDir "/netlist" )
    )
)

xmodelGetPinOrder

xmodelGetPinOrder(
      cellview
)
=> pinList

Description

Returns the desired ordering of the cellview’s pins when GLISTER netlists its module definition or instances with ordered port connections.

Arguments

Value Returned

Example

procedure( xmodelGetPinOrder( cellview )
    schGetPinOrder( cellview )
)

modelzenGenNetlist

modelzenGenNetlist(
      libName
      cellName
      viewName
      simulator
)
=> netlistFile

Description

Generate the hierarchical circuit netlist from a circuit schematic cellview. This procedure is used by MODELZEN to extract the circuit netlist of the cellview before generating the structural models. Users can override this procedure to define any site-specific customizations for circuit netlisting.

Arguments

Value Returned

Example

procedure( modelzenGenNetlist( libName cellName viewName simulator )
    let( ( netlistFile netlistDir )
        ; initialize simulator
        simulator( simulator )

        ; generate netlist
        design( libName cellName viewName )
        unless( netlistFile = createNetlist( ?recreateAll t ?display nil )
            error( "error occurred while netlisting %s.%s:%s." libName cellName viewName )
        )
        ocnCloseSession()

        ; return netlist filename
        netlistDir = xmodelGetDirName( netlistFile )
        strcat( netlistDir "/netlist" )
    )
)

modelzenGetPinOrder

modelzenGetPinOrder(
      cellview
)
=> pinList

Description

Returns the desired ordering of the cellview’s pins when MODELZEN creates the model for the corresponding cellview.

Arguments

Value Returned

Example

procedure( modelzenGetPinOrder( cellview )
    schGetPinOrder( cellview )
)

modelzenMapInstName

modelzenMapInstName(
      instName
)
=> mappedInstName

Description

User-customizable function to define the mapping between the instance names used in the schematic cellviews and those used in the circuit netlists generated by the modelzenGenNetlist() method.

In case the user’s customized modelzenGenNetlist() procedure changes the instance names (e.g. prepending ‘M’ to all transistor instance names) during the netlist generation, it is necessary to define the same name mapping in this function so that MODELZEN can correctly apply the MODELZEN properties the user may have defined for those instances with the changed names.

Arguments

Value Returned

Example

procedure( modelzenMapInstName( instname )
    instname
)

modelzenMapNetName

modelzenMapNetName(
      netName
)
=> mappedNetName

Description

User-customizable function to define the mapping between the net names used in the schematic cellviews and those used in the circuit netlists generated by the modelzenGenNetlist() method.

In case the user’s customized modelzenGenNetlist() procedure changes the net names (e.g. prepending “NET_” to all net names starting with a number literal) during the netlist generation, it is necessary to define the same name mapping in this function so that MODELZEN can correctly apply the MODELZEN properties the user may have defined for those nets with the changed names.

Arguments

Value Returned

Example

procedure( modelzenMapNetName( netname )
    netname
)