User Guide: Heatwave 2019.02

HeatWave
2019.02
User Guide
Notices
© Keysight Technologies, Inc. 1983-2019
1400 Fountaingrove Pkwy., Santa Rosa, CA 95403-1738, United States
All rights reserved.
No part of this documentation may be reproduced in any form or by any means (including electronic stor-
age and retrieval or translation into a foreign language) without prior agreement and written consent from
Keysight Technologies, Inc. as governed by United States and international copyright laws.
Restricted Rights Legend

If software is for use in the performance of a U.S. Government prime contract or subcontract, Software is
delivered and licensed as "Commercial computer software" as defined in DFAR 252.227-7014 (June 1995),
or as a "commercial item" as defined in FAR 2.101(a) or as "Restricted computer software" as defined in
FAR 52.227-19 (June 1987) or any equivalent agency regulation or contract clause.
Use, duplication or disclosure of Software is subject to Keysight Technologies’ standard commercial li-
cense terms, and non-DOD Departments and Agencies of the U.S. Government will receive no greater than
Restricted Rights as defined in FAR 52.227-19(c)(1-2) (June 1987). U.S. Government users will receive
no greater than Limited Rights as defined in FAR 52.227-14 (June 1987) or DFAR 252.227-7015 (b)(2)
(November 1995), as applicable in any technical data.
Portions of this software are licensed by third parties including open source terms and conditions.
For detail information on third party licenses, see Notice.
Publication Date: February 13, 2019

Table of Contents
1 HeatWave 1
1.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2 HeatWave Usage 3
2.1 System requirements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Configuring licensing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3 Setting up the environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.4 Running HeatWave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.4.1 Text Input Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.4.2 Scripting Primitives Input Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.4.3 Tcl Utility Input Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.5 HeatWave Data Flow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.6 HeatWave Use Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.6.1 Analog floorplanning and prototyping . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.6.2 Detailed electro-thermal analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3 Thermal Technology Definition 9

3.1 Complete Thermal Technology Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.1.1 Materials . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.1.2 substrate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1.3 oxide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1.4 channel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.1.5 thinox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1.6 poly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.1.7 contact . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.1.8 metal1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.1.9 via1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.1.10 metal2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.1.11 passivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 Compact Technology Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.3 Text Technology Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4 Complete Examples 21
4.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.2 Common Inputs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.2.1 OpenAccess Layout Database . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
TABLE OF CONTENTS
4.2.2 Ptab File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4.2.3 Pval File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.2.4 ESolve Control File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.2.5 Package Model file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.2.6 Spectre run directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.3 Using Text Inputs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.3.1 Text Techfile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.4 Using Tcl Primitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.4.1 Complete Tcl Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.5 Using Tcl Utilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.5.1 Transient Tcl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.5.2 Complete Transient Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.5.3 Steady State Tcl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.5.4 Complete Steady State Tcl Script . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5 Using HeatWave’s Virtuoso GUI 34

5.1 HeatWave Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.2 Thermal Analysis Setup Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.3 Power Source Extraction Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.4 Simulation Setup Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.5 Thermal Analysis Invocation Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
ii
HeatWave
1 HeatWave
1.1 Overview
This User Guide to the HeatWave thermal simulator, describes the simulator’s use-models, the types of
inputs in various modes of use, examples of various data preparation tasks, and examples of complete sets
of the input-data needed to run HeatWave. This manual is also provided in html format in your HeatWave
software installation hierarchy.
HeatWave comprises a 3D thermal extraction and simulation engine that computes temperature within a
chip, given a power profile, layout geometries, thermal properties of materials in the chip, and a package-
model for the integrated circuit. HeatWave’s invocation, the types and formats of inputs and outputs, the
command-syntax in various modes of use, and a detailed description of various programming interfaces
are provided in the HeatWave Reference Manual. The Graphical User interface (GUI) and its operation are
described in a separate HeatWave User Interface Guide (UIGuide).
HeatWave’s thermal solver may be used to compute both steady-state and transient temperature profiles,
in an electro-thermal loop. In either case, the power values used as inputs may be obtained from transient
thermal simulations.
The concept of a power-source, as a volume within your chip that dissipates power as heat, is described
in the HeatWave Reference Manual. HeatWave computes temperature at the length scales of your power
sources, which may be as small as transistors or other active devices, or interconnect.
HeatWave may obtain power values from your circuit simulator, returning it instance-specific tempera-
ture values, so voltages, currents and power waveforms from your circuit simulator are more accurate
or "temperature-aware". HeatWave integrates smoothly into standard analog and mixed-signal IC design
flows.
Transient thermal analysis is useful in designs where peak hot-spots and temperature differences (∆T ) may
be missed by steady-state analysis. Examples of the above are high power-density transistors driving trans-
ducers, including actuators such as stepper motors, airbag detonators etc. High-power densities are also
present in switching power regulators and pulsed RF power transistors, for example in avionics, radar, and
other high peak-to-average-ratio applications including CDMA, W-CDMA, TD-SCDMA and OFDM systems.
HeatWave integrates the thermal analysis engine with the simulation environment for analog circuit design.
The benefits of such an integration with the analog design environment are:
• electrical circuit-simulation now uses the temperature profile to assign each instance a distinct tem-
perature, that is consistent with the electrical power dissipated as heat
• simulation of temperature sensitive circuits that could previously only be characterized with bench,
wafer or package tests.
• package and bond-wire thermal effects modify instance temperatures in circuit-simulation
• estimates of power dissipation enable analog chip floorplanning for temperature
HeatWave’s simplified program flow is as shown in the following figure. At branches in the flow, the thermal
solver and an external electrical-solver that computes power at the current instance temperatures may be
re-run, if the temperature-difference between iterations exceeds user-specifiable thresholds. HeatWave
proceeds to the next step in the flow only if the computed temperatures are consistent with the current
mesh and power-values.
1
HeatWave
Figure 1: HeatWave program flow
The inputs in the preceding flow-chart are described generally, by type. The specific form each input is not
shown, because it varies depending on the types and organization of your design-data, as summarized in
the section on input models.
To automate or assist in the preparation of the data-files described below, and in the setup of electrical-
simulators used by HeatWave, an interface from Cadence’s Virtoso and Analog Design Environment to
the HeatWave environment is available. The interface is summarized in the Cadence HeatWave Interface
section of the HeatWave Reference Manual, and further described in that manual’s sections on Using the
Virtuoso GUI and on Customizing the Virtuoso GUI.
2
HeatWave Usage
2 HeatWave Usage
The invocation of HeatWave using various types and organizations of inputs, is detailed in the Usage section
of the HeatWave Reference Manual. HeatWave’s graphical user interface (GUI) displays volume (3D) and
surface (2D) plots of the input-fields, and the computed fields, among numerous other features described
in the HeatWave User Interface Guide.
2.1 System requirements
HeatWave is supported on the following 64 bit platforms:
• Red Hat Enterprise Linux version 5 and above
The minimum tool requirements for running HeatWave on analog designs are:
• Cadence Virtuoso with Skill execution, for traversal of extracted cellview produced by Assura , Calibre,
Diva, etc.
• If an electro-thermal loop is required, a circuit-simulator supported by HeatWave should be used.

Currently supported simulators are Spectre and Eldo. For steady-state mode only, Ultrasim is also
supported. Your simulator netlist must contain the flat subcircuit of the device-extracted view of part
or all of the chip.
• If Calibre is used, a Cadence extracted cellview is required. This may be obtained using Mentor’s
Calibre Connectivity Interface (CCI)
• If Eldo is used, a netlister from the extracted view or database to a flat Eldo netlist
2.2 Configuring licensing
Current information on licensing for HeatWave is available in the README.INSTALL file in the installation
hierarchy that you obtain by unpacking a HeatWave software release.
2.3 Setting up the environment
The $GDA_ROOT shell environment variable should be set to the full path-name of the HeatWave installation
directory. The $GDA_ROOT/README.INSTALL file contains an up-to-date summary of the environment
variables required for use of your HeatWave product. $GDA_ROOT/README.INSTALL describes:
• licensing and license-queuing control variables
• executable search path setting

• $LD_LIBRARY_PATH setting for run-time libraries. If modification of this variable is unacceptable, an
alternative method using a HeatWave-specific variable, and HeatWave’s wrapper scripts, is described.
• Tcl library search path and index-file search path
• other recommended variable-settings
3
HeatWave Usage
2.4 Running HeatWave
HeatWave may be invoked from your shell’s command-line, for batch or interactive invocation, to run steady-
state or transient thermal simulation, using command-line switches or scripting commands. The invocation
syntax is detailed in the HeatWave Reference Manual.
An input model refers to the type and organization of input-data provided to a program. This is a part of the
usage model that includes the functional context of the program, i.e. what the program does, rather than
the inputs it accepts. The following figure summarizes the input models for HeatWave.
Figure 2: HeatWave Input Models
2.4.1 Text Input Model
The text input model is useful for new users, defining simply-specifiable problems, or running a prototype
analysis where not all inputs are systematically obtainable (e.g. from your production CAD environment).
The Using Text Inputs section contains a complete example using this input model. The text input model is
further described in the HeatWave Reference Manual
4
HeatWave Usage
2.4.2 Scripting Primitives Input Model
This input model, usin Scripting primitives described in the HeatWave Reference Manual, is useful for mod-
eling problems that require some level of detail and flexibility, or for running complex prototyping analyses,
outside your production CAD environment. The Using Tcl Primitives section contains a complete example
using this input model. The scripting input model is further described in the HeatWave Reference Manual
2.4.3 Tcl Utility Input Model
This model with Tcl Utilities using a HeatWave Context, is designed for enterprise application in a produc-
tion design environment. Centralized Tcl callbacks to define default controls and design-kit (PDK) specific
controls, as well as Skill callbacks to customize HeatWave’s Virtuoso interface should be provided by your
CAD support group, so that only a few design-specific settings, if any, need to be made by an end-user. The
$TCLLIBPATH and tclIndex constructs, may be used to centralize Tcl definitions and automatically load
them into an end-user’s environment, as summarized in the overview of utilities section. This input model
is further described in the HeatWave Reference Manual The Using Tcl Utilities section contains a complete
transient example and a complete steady-state example using this input model.
2.5 HeatWave Data Flow
The data flow through HeatWave is shown when using the Virtuoso extracted cell-view, that may be pro-
duced by Assura, Calibre, or Diva extraction flows
5
HeatWave Usage
Figure 3: HeatWave data flow using Cadence Virtuoso
2.6 HeatWave Use Models
HeatWave computes 3-D temperature profiles of a chip taking as input:
• design layout information, which may be mixed-level and include a combination of functional blocks,
standard cells, and devices,
6
HeatWave Usage
• initial power estimates from power analysis tools,

• temperature-dependent leakage power tables, if available,
• material properties, such as layer thicknesses and thermal conductivities,
• package models, including bond wires, and ambient data.
HeatWave computes and outputs temperatures on all power sources in the design. If temperature-
dependent power tables are available, HeatWave will use them to report power values consistent with
the computed temperature.
HeatWave may be used for thermal analysis and manual repair in an analog or mixed-signal design, at any
stage of the design flow where positions and extents of the devices with high power density or temperature
sensitivity are known.
There are two primary use models for HeatWave:
• analog floorplanning; prototyping functionality, performance

• simulation of extracted layout with temperature annotated on all devices.
2.6.1 Analog floorplanning and prototyping
HeatWave may be used for analog floorplanning or prototyping when
• the digital logic may be modelled as blocks for power analysis, and
• the analog design is at or past the floorplanning stage, with a netlist and bounding boxes defined for
the key devices or circuit elements. The key devices either have a significant power density or are
sensitive to temperature.
The diagram below shows the information flow for this use model, with optional data/processes indicated
by dotted-line boxes.
Figure 4: Prototyping Use Model
7
HeatWave Usage
2.6.2 Detailed electro-thermal analysis
When design layout and electrical extraction are completed, thermal analysis may include the effects of
layout shapes and simulation of the extracted netlist may be done. The converged temperature distribution,
consistent with power, may be used to more accurately simulate and tune the functionality and performance
of the circuit.
Figure 5: Detailed Use Model
8
Thermal Technology Definition
3 Thermal Technology Definition
This section contains examples of thermal technology definitions using constructs described in the Heat-
Wave Reference Manual. This section is also included in the HeatWave Reference Manual , where many
of its items are linked to their definitions and descriptions in that manual.
3.1 Complete Thermal Technology Example
This section describes the complete definition of a thermal technology, for a simple two-metal CMOS pro-
cess. The thermal technology definition is explained in a step-by-step manner, with illustrations of the
thermal-layer stack as defined up to that point. This should help you understand the distinct effect of each
set of layer-definition commands.
The HeatWave Reference Manual describes the thermal-layer, mask-layer, and material constructs, as
well as the Tech methods Tech::addLayer, and Tech::addMaskToLayer , that are used to define a thermal
technology.
Figure 6: Simple 2-metal CMOS layer-stack
The preceding "Simple 2-metal CMOS layer stack" figure shows the thermal layer stack that we will define,
by first creating a set of Material objects, and repeatedly invoking Tech methods addLayer and addMaskTo-
Layer.
The key above the layer-stack indicates the material (or, as in the case of "Power", the purpose) represented
by a given color in the thermal layer-stack. A colon ":" indicates that names following it are mask-layers (or
their complements) which are associated with the key-color. For example, the field-oxide below the Silicon
surface represents the complement of the DIFF mask-layer. The oxide surrounding metal segments and
vias is also defined by the complements of the respective mask-layers. The passivation Polyimide region
is defined by the complement of the PAD mask-layer. The "Power" regions represent where power-sources
will be defined in this example.
A few observations may help you to understand this example, and to better define your thermal technology.
Think thermally! Begin with a schema, or cross-section diagram of your layer-stack. Then, merge materials
(and the layers that represent them) in the stack if the materials do not have distinctly different thermal
9
properties. For example, wells, diffusion-islands, and bulk silicon materials may be approximated as the
same, and merged in many cases. The resulting thermal layer stack may be significantly less complex than
one that represents every material. It is also useful to note where horizontal lines appear in the cross-section
diagram of your technology’s layer-stack. Those horizontal locations are the boundaries of the thermal
layers in your thermal-technology definition, assuming they represent boundaries between materials with
significantly different thermal properties.
3.1.1 Materials
The materials in the thermal-layer stack are represented by the definitions of Material objects that have
thermal properties.
After defining a Flow object and getting a reference to its Tech object, the materials used in thermal-layer
stack are defined in Tcl as follows.
# Tcl definition of the thermal properties of the Silicon,

# Aluminum, Tungsten, Polysilicon , Oxide and Polyimide
# used in the thermal-layer stack
gda::Flow flow
set tech [flow getTech]
gda::Material Si
Si configure -name Si
Si configure -thermal_conductivity [gdFunction1d {
25 156.143 40 146.251 55 137.406
70 129.456 85 122.278 100 115.768
115 109.842 130 104.427 145 99.4622
160 94.8964 175 90.6852 190 86.7905
205 83.1793 220 79.8231 }]
Si configure -heat_capacity_per_unit_volume [gdFunction1d 1.63e6]
gda::Material Al
Al configure -name Al
Al configure -thermal_conductivity [gdFunction1d 237.0]
Al configure -metal_electron_mean_free_path 4e-08
gda::Material W
W configure -name W
W configure -thermal_conductivity [gdFunction1d 174.0]
W configure -electron_mean_free_path 4e-08
gda::Material PolySi
PolySi configure -name PolySi
PolySi configure -thermal_conductivity [gdFunction1d 100.0]
gda::Material SiO2
SiO2 configure -name SiO2
SiO2 configure -thermal_conductivity [gdFunction1d 1.0]
gda::Material Polyimide
Polyimide configure -name Polyimide
Polyimide configure -thermal_conductivity [gdFunction1d 0.5]
10
# add each material to the flow’s Tech object

# define only the materials you will later use in layer definitions
foreach m { Si Al W PolySi SiO2 Polyimide } {
$tech addMaterial $m
}
3.1.2 substrate
Figure 7: Layer 0: substrate
The Tcl definition of the substrate thermal-layer follows. When defining a thermal-stack, you should con-
sider omitting material distinctions, if their thermal properties are very similar. In this case, the wells and
bulk silicon have very similar thermal conductivities, which may be approximated as the same. You may
later define them as distinct materials, with different conductivities, to verify that the effects of the additional
detail are insignificant.
# Tcl definition of the substrate

# Layer number : 0
$tech addLayer substrate 0.00044 Si
3.1.3 oxide
Figure 8: Layer 1: oxide
11
The Tcl definition of the oxide thermal-layer follows. The Complete Thermal Technology Example section
explained how DIFF mask-layer is the complement or "negative" of the field-oxide pattern. So, geometries
on the DIFF mask-layer define where the Si material is present. All remaining areas of the DIFF mask-layer
are composed of SiO2 material. As explained in the substrate section, the wells, diffusion islands, and bulk
silicon have very similar thermal conductivities, which may be approximated as the same.
# Layer number : 1
$tech addLayer oxide 5e-06 SiO2
# Add masks to layer "oxide"
$tech addMaskToLayer oxide DIFF Si
3.1.4 channel
Figure 9: Layer 2: channel
The Tcl commands below define the channel thermal-layer, where power sources will be located, as shown
in the "Power" regions in the preceding figure . The Tcl may appear identical to that for the preceding oxide
thermal-layer, with the exception of the layer-thickness value. However, this thermal-layer could not be
omitted, or merged with the oxide thermal-layer. It must be defined as shown, because we wish to define
power-sources only within this thin "slice", and not within the rest of the "oxide" thermal-layer.
A thermal-layer does not exist simply to model the layout-data. It also determines the Z extent of power-
sources, i.e. the thickness of the region in which power is dissipated. This point should be clearly under-
stood.
The remaining parts of the "channel" thermal-layer definition have the same meaning as explained in the
preceding oxide section.
# Layer number : 2
$tech addLayer channel 1e-07 SiO2
# Add masks to layer "channel"
$tech addMaskToLayer channel DIFF Si
12
3.1.5 thinox
Figure 10: Layer 3: thinox
The Tcl commands below define the thinox thermal-layer, representing the "slice" of the chip containing the
thin-oxide under the gate. The command containing addMaskToLayer POLY ... requires some explanation.
It is needed to stop poly-contacts from extending down to the silicon surface, while allowing diffusion-
contacts to do so. If we removed this command all contacts (to poly or diffusion) would be present in this
thermal-layer (because of the addMaskToLayer CONT ... command).
By adding the command addMaskToLayer POLY and by defining the related shape-material as SiO2, we
ensure that wherever a shape exists on the POLY mask-layer the thinox thermal-layer is composed of SiO2
material. By defining the command addMaskToLayer POLY first, we ensure that wherever a CONT overlaps
a POLY shape, the shape on the POLY layer has precedence, and the overlap region is composed of SiO2.
The POLY mask-layer shapes are not part of the layer-stack at this point, but are shown in outline just
above the chip, as a reminder that the POLY mask-layer is of primary importance in the definition of this
thermal-layer.
The result is a thermal layer-stack as shown in the preceding "Layer 3: thinox" figure.
# Layer number : 3
$tech addLayer thinox 5e-08 SiO2
# Add masks to layer "thinox"
$tech addMaskToLayer thinox POLY SiO2
$tech addMaskToLayer thinox CONT W
13
3.1.6 poly
Figure 11: Layer 4: poly
The Tcl commands below define the poly thermal-layer, The command addMaskToLayer POLY , placed
first, ensures poly-contacts are not defined in this thermal-layer. Diffusion-contacts , which need to to touch
the silicon surface, are defined in this thermal-layer.
# Layer number : 4
$tech addLayer poly 2e-07 SiO2
# Add masks to layer "poly"
$tech addMaskToLayer poly POLY PolySi
$tech addMaskToLayer poly CONT W
14
3.1.7 contact
Figure 12: Layer 5: contact
The Tcl commands below define the contact thermal-layer, with contacts composed of Tungsten material,
and SiO2 material outside the contacts. Both poly-contacts and diffusion-contacts are defined in this layer.
# Layer number : 5
$tech addLayer contact 4.5e-07 SiO2
# Add masks to layer "contact"
$tech addMaskToLayer contact CONT W
3.1.8 metal1
Figure 13: Layer 6: metal1
15
The Tcl commands below define the metal1 thermal-layer, composed of Aluminum material , with SiO2
material outside the metal wires.
# Layer number : 6
$tech addLayer metal1 5.5e-07 SiO2
# Add masks to layer "metal1"
$tech addMaskToLayer metal1 M1 Al
3.1.9 via1
Figure 14: Layer 7: via1
The Tcl commands below define the via1 thermal-layer, composed of Tungsten material, with SiO2 material
outside the vias.
# Layer number : 7
$tech addLayer via1 5.5e-07 SiO2
# Add masks to layer "via1"
$tech addMaskToLayer via1 VIA1 Al
16
3.1.10 metal2
Figure 15: Layer 8: metal2
The Tcl commands below define the metal2 thermal-layer, composed of Aluminum material, with SiO2
material outside the metal wires.
# Layer number : 8
$tech addLayer metal2 6e-07 SiO2
# Add masks to layer "metal2"
$tech addMaskToLayer metal2 M2 Al
3.1.11 passivation
Figure 16: Layer 9: passivation
The Tcl commands below define the passivation thermal-layer, where shapes on the PAD mask-layer are
composed of Aluminum material. The pads fill openings in the Polyimide passivation material.
17
# Layer number : 9
$tech addLayer passivation 1.7e-06 Polyimide
# Add masks to layer "passivation"
$tech addMaskToLayer passivation PAD Al
3.2 Compact Technology Definition
This section describes a more compact definition of the same technology defined in the Complete Thermal
Technology Example section, using a procedure described in the HeatWave Reference Manual section on
proc gdDefineTech,
gdDefineTech <flow> <material-list> <thermal-layer-list> [<heat-capacity-list>]
The example defines the thermal technology for the same layer-stack described in the Complete Thermal
Technology Example section , and shown in the "Simple 2-metal CMOS layer stack" figure that follows:
Figure 17: Simple 2-metal CMOS layer-stack
In this case, the technology is defined within a Tcl procedure named twoMetalCMOSTech.
# Tcl example of a complete thermal technology description in Tcl.

gda::Flow flow
# invoke the following procedure to define the 2-metal CMOS thermal technology
proc twoMetalCMOSTech {flow} {
# silicon’s thermal_conductivity as a function of temperature
# Temperature dependent conductivity K(T): {T1 K1 T2 K2 ... TN KN}
set Si_K_T {
25 156.1425 40 146.2506 55 137.4056 70 129.4560
85 122.2778 100 115.7683 115 109.8419 130 104.4268
145 99.46221 160 94.89642 175 90.68520 190 86.79047
205 83.17932 220 79.82315
} ;# later automatically converted to a Function1d
#----------------------
# MATERIAL DEFINITIONS
#----------------------
18
# THERMAL CONDUCTIVITY
# { name thermal_conductivity W/(mK) [metal_electron_mean_free_path (m)] }
set K_list "
{Si {$Si_K_T} }
{PolySi 100 }
{SiO2 1 }
{Al 237 4e-8 }
{W 174 4e-8 }
{Polyimide 0.5 }
"
# K_list is enclosed in quotes, so $Si_K_T is evaluated
# VOLUMETRIC HEAT CAPACITY (use material names from K_list)

# {name heat_capacity_per_unit_volume J/(m^3 K)}
set Cv_list {
{Si 1.63e6}
} ;# no $variables used, so braces {} are ok
#----------------------------
# THERMAL LAYER DEFINITIONS
#----------------------------
# {name thickness(m) bkgnd-material {lyr1 mat1}...{lyrN matN}}
set layer_list {
{ substrate 440e-6 Si }
{ oxide 5e-6 SiO2 {DIFF Si} }
{ channel 0.1e-6 SiO2 {DIFF Si} }
{ thinox 0.05e-6 SiO2 {POLY SiO2} {CONT W} }
{ poly 0.2e-6 SiO2 {POLY PolySi} {CONT W} }
{ contact 0.45e-6 SiO2 {CONT W} }
{ metal1 0.55e-6 SiO2 {M1 Al} }
{ via1 0.55e-6 SiO2 {VIA1 Al} }
{ metal2 0.60e-6 SiO2 {M2 Al} }
{ passivation 1.7e-6 Polyimide {PAD Al} }
}
# the last parameter is optional, so $Cv_list may be omitted
gdDefineTech flow $K_list $layer_list $Cv_list
}
A thermal layer may effectively be ignored by making its first element the word HW_IGNORE, as described
in gdDefineTech.
Example: To ignore the poly thermal-layer, specify
{ HW_IGNORE poly 0.2e-6 SiO2 {POLY PolySi} {CONT W} }
3.3 Text Technology Definition
This section describes the same technology as do the Complete Thermal Technology Example and Com-
pact Technology Definition sections, but uses a plain-text format described in the Technology File section,
for comparison.
You should note the following limitations of the plain-text Technology File format:
• at most one mask-layer may be associated with a thermal layer
• all the Material object’s parameters are not available, since there is no explicit concept of a material
19
• scripting constructs such as loops and branches are not available
The preceding limitations make the thinox and poly thermal layers (defined in the Complete Thermal Tech-
nology Example and Compact Technology Definition sections) undefinable using this text syntax, since they
require multiple mask-layers per thermal layer. So, the thinox and poly thermal layers are omitted below,
resulting in a less accurate thermal model.
# plain text technology definition

#
# name thickness k kbar [mask]
#-------------------------------------------
0: substrate 440e-6 120 120
1: oxide 5e-6 120 1 DIFF
2: channel 0.1e-6 120 1 DIFF
3: contact 0.70e-6 174 1 CONT
4: metal1 0.55e-6 237 1 M1
5: via1 0.55e-6 174 1 VIA1
6: metal2 0.60e-6 237 1 M2
7: passivation 1.70e-6 237 0.5 PAD
In the previous sections temperature dependent conductivity was specified using Tcl. In this case, it is
specified in a file of the following format, which was described in the section on Temperature Dependent
Conductivity.
siliconTable 25 156.1425
use k siliconTable oxide channel
use kbar siliconTable substrate
20
Complete Examples
4 Complete Examples
This section describes several ways in which HeatWave may be invoked, with the different usages described
earlier in this guide. This section is also included in the HeatWave Reference Manual, where many of its
items are linked to their detailed descriptions in that manual. So, you may see references to sections that
do not exist in this manual. You will find those sections defined in the HeatWave Reference Manual.
4.1 Overview
This section provides examples of the ways in which HeatWave may be invoked, as described in the input
models section. Some input-files are common to all invocations, and are listed first.
Examples of each input model are shown:
• Text inputs are exemplified in the section Using Text Inputs.

• Scripting primitives are exemplified in the section Using Tcl Primitives.
• Tcl Utililties that use a HeatWave Context are exemplified in the section Using Tcl Utilities.
The listings of data and Tcl-scripts below are based on the OPAMP example available from Keysight, that
implements a simple single-stage opamp. The example provides all the simulation input-data and scripts
of the form described below, including an OpenAccess database, described further below. Some of these
inputs, may be built using the HeatWave interface to Virtuoso, as described below.
4.2 Common Inputs
This section describes the files common to all the input models mentioned in the Overview section.
4.2.1 OpenAccess Layout Database
The layout data is translated from GDSII into an OpenAccess database as described in the section on
OpenAccess in the HeatWave User Guide. The OpenAccess library is named OPAMP, within which the
cell opamp contains the layout of the design. The OpenAcess data is in a directory named OPAMP. This
may be built by the HeatWave interface to Virtuoso, if your CAD software department has defined the
appropriate SKILL callbacks.
4.2.2 Ptab File
The <libname>.ptab file (OPAMP.ptab in this example), has the syntax described in the Power Source
Extent Table section.
# OPAMP.ptab file (... indicates lines deleted for brevity)

# Power source extents in .ptab format:
#<cell-name> <power-source-name> <thermal-layer> <xmin ymin xmax ymax (in OA user-units)>
opamp M3__1 channel 12.080 23.480 16.080 38.480
opamp M3__2 channel 16.880 23.480 20.880 38.480
opamp M4__1 channel 2.480 3.750 6.480 18.750
opamp M4__2 channel 7.280 3.750 11.280 18.750
...
opamp M9__9 channel 125.600 3.750 128.500 18.750
21
Complete Examples
opamp R0__1 poly 54.490 3.750 89.590 5.750

opamp R0__2 poly 54.490 12.750 89.590 14.750
opamp R0__3 poly 54.490 9.750 89.590 11.750
opamp R0__4 poly 54.490 6.750 89.590 8.750
One method for preparing this data is by using the HeatWave Virtuoso Interface, which is the method used
in this example.
4.2.3 Pval File
The <cellname>.pval file (opamp.pval in this example), has the syntax described in the Power Value file
section. It is optional, and need not be specified, particularly if power is obtained from circuit-simulation, e.g.
Spectre. All power-sources have a default power dissipation of 0 W. In this example, having initial power
values (from circuit-simulation at a constant temperature) speeds up convergence of the electro-thermal
loop.
# opamp.pval file (... indicates lines deleted for brevity)

# Power-source power values in .pval format:
#<power-source-name> <power (W)>
M3__1 0.0024627
M3__2 0.00245907
M4__1 6.58163e-05
M4__2 6.60254e-05
...
M9__9 0.00359547
R0__1 7.36104e-08
R0__2 7.36104e-08
R0__3 7.36104e-08
R0__4 7.36104e-08
4.2.4 ESolve Control File
Circuit-simulator invocation within the electro-thermal loop is managed by HeatWave as described in the
section on the Electrical Solver Initialization file. An example for the Spectre circuit simulator follows. Heat-
Wave’s Spectre interface supports invocation of APS , as shown below. The default value of most variables
is usually correct, and they need not be specified. However, for clarity, the default values are shown com-
mented (# prefix) below:
# gda_sim.ini file
solver_type spectre
spectre_command "aps -f psfascii =l spectre.out -r ./psf "
spectre_psf psf/tran.tran
#spectre_netlist spectre/input.scs
#spectre_subckt opamp
#spectre_script hw_spectre
#spectre_log spectre_flow.out
This file may be prepared by the HeatWave interface to Virtuoso, if your CAD software department has
defined the appropriate SKILL callbacks.
4.2.5 Package Model file
Conditions at the die-boundaries may be defined as described in the Package Model section. An example
of this follows:
22
Complete Examples
# Basic package model: pkg.ini file

# kamb = ambient conductivity W/(K*m)
# lamb = length of thermal resistor m
#
# name x- x+ y- y+ z- z+
#------------------------------------------------
kamb: 1 1 1 1 8 3
lamb: 1e-3 1e-3 1e-3 1e-3 1e-4 1e-4
tamb: 27 27 27 27 27 27
4.2.6 Spectre run directory
A Spectre run-directory, ready for use in HeatWave’s electro-thermal loop, is prepared in a directory named
spectre, as described in the section on the HeatWave interface to Spectre. One method for preparing this
data is by using the HeatWave Virtuoso Interface, which is the method used in this example.
4.3 Using Text Inputs
This section describes the invocation of HeatWave using plain-text input files, so no script inputs are used.
The previously described common inputs are used, as summarized below for the opamp example:
• OPAMP.ptab defines power-source extents
• opamp.pval defines the power dissipated by power-sources

• gda_sim.ini configures the electro-thermal loop
• pkg.ini is included in gdatech.ini, in this input model
• OPAMP/ contains the OpenAccess database of the opamp layout
• spectre/ run-directory ready for HeatWave electro-thermal simulation
23
Complete Examples
Figure 18: Using Text Inputs
The file-names above are, wherever possible, the default values to HeatWave’s command-line switches, to
reduce the number of switches used on the heatwave command-line.
The additional file specific to this input model is described in the Text Techfile section.
• gdatech.ini defines a technology in plain-text (i.e. not a Tcl script) If needed, meshing controls are
specifiable in an optional text mesh control file gdamesh.ini.
Given the preceding input files, you may run HeatWave as follows, as described in the section on HeatWave
Usage:
• heatwave -L OPAMP -C opamp
4.3.1 Text Techfile
The section on the text Technology File explains its syntax, and the section on Text Technology Definition
provides a representative example. The text techfile for the opamp example follows:
# gdatech.ini file for OPAMP test-case

# thermal layer stack
# name height k kbar

0: bsubstrate 0.000440 100 100
1: tsubstrate 0.000005 120 100 NW
2: channel 0.00000030 100 100
3: poly 0.00000050 100 100 P01
4: contact 0.00000055 174.0 1.00 CO1
5: metal1 0.00000055 397.0 1.00 MT1
6: via1 0.00000060 174.0 1.00 V12
24
Complete Examples
7: metal2 0.000000595 397.0 1.00 MT2

8: passivation 0.000001725 400.0 1.00
# optional mask layer declaration

mask_layers NW P01 CO1 MT1 V12 MT2
# as in "pkg.ini"-- see Package Model section

kamb: 1 1 1 1 8 3
lamb: 1e-3 1e-3 1e-3 1e-3 1e-4 1e-4
tamb: 27 27 27 27 27 27
4.4 Using Tcl Primitives
This section describes the invocation of HeatWave using the Tcl primitives. The benefits of this input model
are explained in the overview of scripting primitives. This simulation-flow is simpler than the context based
flow though it is less suited to integration and standardization in the CAD tool suite of a large chip-design
group.
The previously described common inputs are still used in this mode, and are summarized below for the
opamp example:

• pkg.ini defines a basic package model
Figure 19: Using Tcl Primitives
25
Complete Examples
The Tcl file specific to this input model is described in the Complete Tcl Script section.
• basic.tcl defines a technology and a basic thermal simulation flow in Tcl.As with any Tcl script, it may
be split across multiple files.
Given the preceding input files, you may run a thermal simulation as follows, as explained in the section on
scripts in HeatWave:
• heatwave basic.tcl
Alternatively to save outputs printed to the console, that sometimes contain system warnings or errors not
written to logfiles, you may invoke HeatWave using the UNIX tee command, as follows:
• heatwave basic.tcl |& tee heatwave_console.log
4.4.1 Complete Tcl Script
This section shows a complete Tcl script to reload an existing transient thermal simulation, or run a steady-
state thermal simulation, using power computed within a Spectre transient circuit-simulation. The script
performs the following steps:
• defines a gda::Flow object

• defines a thermal technology using scripting primitives in Tcl, as exemplified by the section on Com-
pact Tcl Technology Definition.
• loads the OpenAccess database and package model.
• sets transient controls if in transient mode
• runs a steady-state or transient thermal simulation
A complete Tcl script using HeatWave’s scripting primitives follows.
# basic.tcl HeatWave script:

# This script is an example of the basic Tcl-based flow described in the
# HeatWave User Guide. This flow is simpler than the context based flow
# though it is less suited to integration and standardization in
# the CAD tool flow of a large chip-design group.
# This flow may be invoked from the commandline as follows:
# heatwave basic.tcl
# To save the console output (which sometimes contains more than logfiles)
# consider this invocation:
# heatwave basic.tcl |& tee heatwave_console.log
# which writes the output to the screen as well as to a logfile
# We can combine scripts for transient and steady state simulation

# in the same file by creating a control variable (e.g. IS_TRANSIENT)
# that sets up a transient run if 1, or a steady-state thermal simulation,
# if 0. Both cases use a transient electrical (Spectre) simulation to
# compute power. For the steady-state thermal simulation, the power
# is averaged over the simulation time.
set IS_TRANSIENT 0 ;# run steady state thermal simulation

gda::Flow flow
26
Complete Examples
# THERMAL TECHNOLOGY DEFINITION

# invoke the following procedure to define a 2-metal CMOS thermal-technology
# for the OPAMP design. This procedure may be defined in a separate file
proc opampTech {flow} {
# Example of a complete thermal technology description in Tcl.
# Temperature dependent conductivity K(T): {T1 K1 T2 K2 ... TN KN}
# silicon’s thermal_conductivity as a function of temperature

set Si_K_T {
25 156.1425 40 146.2506 55 137.4056 70 129.4560
85 122.2778 100 115.7683 115 109.8419 130 104.4268
145 99.46221 160 94.89642 175 90.68520 190 86.79047
205 83.17932 220 79.82315
} ;# later automatically converted to a Function1d
#----------------------
# MATERIAL DEFINITIONS
#----------------------
# THERMAL CONDUCTIVITY
# { name thermal_conductivity W/(mK) [metal_electron_mean_free_path (m)] }
set K_list "
{Si {$Si_K_T} }
{PolySi 100 }
{SiO2 1 }
{Al 237 4e-8 }
{W 174 4e-8 }
{Polyimide 0.5 }
"
# K_list is enclosed in quotes, so $Si_K_T is evaluated
# VOLUMETRIC HEAT CAPACITY (use material names from K_list)

# {name heat_capacity_per_unit_volume J/(m^3 K)}
set Cv_list {
{Si 1.63e6}
} ;# no $variables used, so braces {} are ok
#----------------------------
# THERMAL LAYER DEFINITIONS
#----------------------------
# {name thickness(m) bkgnd-material {lyr1 mat1}...{lyrN matN}}
set layer_list {
{ bsubstrate 440e-6 Si }
{ oxide 5e-6 Si {OX1 Si}}
{ channel 0.1e-6 SiO2 {OX1 Si}}
{ thinox 0.05e-6 SiO2 {PO1 SiO2} {CO1 W}}
{ poly 0.18e-6 SiO2 {PO1 PolySi} {CO1 W}}
{ poly_ild 0.13e-6 SiO2 {PO2 SiO2} {CO1 W}}
{ poly2 0.18e-6 SiO2 {PO2 PolySi} {CO1 W}}
{ contact 0.45e-6 SiO2 {CO1 W} }
{ metal1 0.55e-6 SiO2 {MT1 Al}}
{ via1 0.60e-6 SiO2 {V12 W} }
{ metal2 0.595e-6 SiO2 {MT2 Al}}
{ passivation 1.725e-6 Polyimide {PAD Au}}
}
gdInfo "defined K and Cv of materials in OPAMP example stack" ;# context info
27
Complete Examples
gdDefineTech flow $K_list $layer_list $Cv_list

}
opampTech flow ;# call the procedure above to define a thermal technology
# load design and package <library> <cell> <package>

flow loadDesign "OPAMP" "opamp" "pkg.ini"
# set moderate-resolution meshing parameters

# see gdSetModerateResolution definition in gdacontext.tcl
gdSetModerateResolution flow
if {$IS_TRANSIENT} { ;# setup for transient thermal, if needed
gdInfo "setting up TRANSIENT thermal simulation"

# Transient solver: moderate capacity solver (0) is default.
# Need license gda_transient_hc for high capacity solver (1)
[flow tsolveVars] configure -transient_solver 0 ;# 1 is high-capacity
# measurement:
# gdTranMeasureTemp flow <inst> -avg -min -max {<tstart> <tend>}
# report min/max/avg temp on <inst> from <tstart> to <tend>
# report min/max/avg temperature on instance M8__1 from 0ms to 1ms
gdTranMeasureTemp flow M8__1 -max [gdFloats {0 1.0e-3}] ;#-avg -min
# limits:
# gdTranDTemp flow <inst1> <inst2> -max <temp>
# report when the temp of <inst2> exceeds that of <inst1> by <temp> degC
# report when the temp of M9__10 exceeds that of M9__1 by 3 degC
gdTranDTemp flow M9__1 M9__10 -max 3.0
# similar commands to the above exist for power
# define smaller steps early on, or when power changes fast

set variableSteps [gdFunction1d {
0.0 1e-5 1e-5 1e-5
1e-5 5e-5 1e-4 5e-5
1e-4 1e-4 1e-2 1e-4 } ]
# Define parameters controlling the transient thermal solver

# Note we set the start/stop/step times here, but the
# more general settings are in cxtPreRun (in ../data/examples.tcl)
# The local settings are for the design specific details
[flow transientVars] configure
-start_time 0
-stop_time 1e-4
-time_step 1e-5
-time_steps $variableSteps
-snapshot_temperature_change 0.8
-snapshot_time_interval 1e-4
-verbosity 3
[flow getTransient] criticalTemperatureChange 5 ;# for all power-sources
} ;# end transient thermal definitions
28
Complete Examples
flow continueOnError true
# run thermal simulation, using powers from transient Spectre simulation

if {$IS_TRANSIENT} { ;# in this script, we load previously-saved results
gdInfo "re-loading TRANSIENT thermal simulation ..."

[flow] configure -run_name "transient/testResults.au"
flow transientStatisticsReport
} else {
gdInfo "running STEADY STATE thermal simulation ..."
flow runSteadyState
}
# launch a Graphical User Interface window.

[flow getGUI] show
4.5 Using Tcl Utilities
This section describes the invocation of HeatWave to run utilities, that use the HeatWave Context object.
The benefits of this input model are explained in the overview of Context base Tcl utilities. This simulation-
flow is best suited to integration and standardization in the CAD tool suite of a large chip-design group.
The previously described common inputs are still used in this mode, and are summarized below for the
opamp example:


• pkg.ini defines a basic package model
29
Complete Examples
Figure 20: Using Tcl Context and Utilities
To make this example resemble deployment in an enterprise production design environment, assume
that the opampTech procedure from basic.tcl above, is now in a Tcl file within some PDK hierarchy.
From some other directory, e.g.<some-path>/CENTRAL_CAD_TCL/, we may then run a Tcl auto_-
mkindex command that traverses the PDK hierarchy mentioned above. This produces a tclIndex file in
<some-path>/CENTRAL_CAD_TCL/, that has recorded (indexed) the location of the opampTech proce-
dure. Finally, prepend this path to your TCLLIBPATH shell environment variable, i.e.
set $TCLLIBPATH to "<some-path>/CENTRAL_CAD_TCL $TCLLIBPATH". This allows HeatWave, or
any Tcl shell, to automatically find procedure opampTech, when needed. Individual users would not need
to know where opampTech is defined, nor would they need to explicitly source a Tcl file.
Complete Tcl scripts are provided below for the setup and invocation of transient and steady-state thermal
simulation.
4.5.1 Transient Tcl
The Tcl files specific to this input model are described in the subsequent Complete Transient Script section.
• run_transient.tcl is typically created by HeatWave’s Virtuoso interface, thought you may also eas-
ily create it manually. run_transient.tcl defines a Context to customize the thermal simulation flow
launched by gdRun.
• run_transient.tcl loads a gda_local.tcl which is also shown, in full.
• heatwave run_transient.tcl
30
Complete Examples
This is essentially the command issued by the Thermal Analysis Invocation Form in HeatWave’s Virtuoso
GUI.
• heatwave run_transient.tcl |& tee heatwave_console.log
4.5.2 Complete Transient Script
This section shows the complete Tcl scripts to reload an existing transient thermal simulation using power
computed within a Spectre transient circuit-simulation.
The main script, "run_transient.tcl" listed below, loads an optional local script "gda_local.tcl", that is used to
add a few commands, so we may match the settings in basic.tcl.
The gdRun command in "run_transient.tcl" launches a customizable thermal simulation flow, controlled by
the values in the Context named runVars. The section on the util_flow provides a detailed description of
the flow.
"run_transient.tcl" loads the specified input-data, and restores the temperature-solution from the directory
specified by the util_cxt_trans variable’s value, i.e. "transient/testResults.au". The tech variable
is set to opampTech. Therefore, HeatWave will invoke opampTech to define a thermal technology. Since
we defined $TCLLIBPATH and tclIndex as previously described, HeatWave can automatically locate the
procedure opampTech.
You may easily modify this script’s functionality. For example, to (re)-run the simulation, you would set the
util_cxt_run variable to 1:
set runVars(util_cxt_run) 1 ;# run simulation
The complete Tcl transient simulation script from HeatWave’s Virtuoso GUI, that you can easily create
manually or procedurally, is shown below. It performs a super-set of the actions defined in basic.tcl.
# run_transient.tcl:
# HeatWave Thermal Analysis Tcl script
# ====================================
# Define a Context named runVars [see tcl_util]

global runVars() ;# global array of run-control vars
gdNewVars runVars ;# runVars=Context with default settings
set runVars(batch) 0 ;# run in GUI
set runVars(summary) 0 ;# summarize layer temps in logfile
set runVars(run) 0 ;# don’t run sim -- load existing data
set runVars(restore) "" ;# archive name to read in
set runVars(archive) "" ;# archive name to write to
set runVars(tech) {opampTech} ;# Tcl technology definition proc
set runVars(package) {pkg.ini} ;# package-model file
set runVars(trans) "transient/testResults.au"
set runVars(libname) "OPAMP"
set runVars(cellname) "opamp"
set runVars(trtimes) "0 1e-4 1e-5" ;# [start [stop [step [min-step]]] times
set runVars(reloads) "" ;# times at which to reload/save
set runVars(trsteps) "0.0 1e-5 1e-5 1e-5 1e-5 5e-5 1e-4 5e-5 1e-4 1e-4 1e-2 1e-4";
# gda_local.tcl may contain Tcl commands, including user-defined callbacks

if {[file exists gda_local.tcl]} {source gda_local.tcl}
31
Complete Examples
# Load results, or run a simulation, using runVars values

# gdRun is defined in $GDA_ROOT/tcl/gdacontext.tcl
gdRun runVars
The complete Tcl file local to the HeatWave simulation run-directory, gda_local.tcl, is shown below. This file
is loaded by the main script, run_transient.tcl, listed above.
#gda_local.tcl:
# define Context callback cxtLocalPreRun
# to issue design-specific commands before running thermal simulation
proc cxtLocalPreRun {flow} {
gdInfo "local customizations before simulation"
# report min/max/avg temperature on instance M8__1 from 0ms to 1ms

gdTranMeasureTemp flow M8__1 -max [gdFloats {0 1.0e-3}] ;#-avg -min
# report when the temp of M9__10 exceeds that of M9__1 by 3 degC
gdTranDTemp flow M9__1 M9__10 -max 3.0
# Define parameters controlling the transient thermal solver

[flow transientVars] configure
-snapshot_temperature_change 0.8
-snapshot_time_interval 1e-4
-verbosity 3
[flow getTransient] criticalTemperatureChange 5 ;# for all power-sources
}
4.5.3 Steady State Tcl
The Tcl files specific to this input model are described in the subsequent Complete Steady State Tcl Script
section.
• run.tcl is typically created by HeatWave’s Virtuoso interface, thought you may also easily create it
manually. run.tcl defines a Context to customize the thermal simulation flow launched by gdRun.
• run.tcl loads a gda_local.tcl which is also shown, in full.
• heatwave run.tcl
This is essentially the command issued by the Thermal Analysis Invocation Form in HeatWave’s Virtuoso
GUI.
• heatwave run.tcl |& tee heatwave_console.log
4.5.4 Complete Steady State Tcl Script
This section shows the complete Tcl scripts to run a steady-state thermal simulation using power computed
within a Spectre transient circuit-simulation.
32
Complete Examples
The main script, "run.tcl" listed below, loads an optional local script "gda_local.tcl", to illustrate how few
commands may be added.
The gdRun command in "run.tcl" launches a customizable thermal simulation flow, controlled by the values
in the Context named runVars. The section on the util_flow provides a detailed description of the flow.
"run.tcl" loads the specified input-data, and launches a steady state thermal simulation, since the Context
variable trans is an empty string. The tech variable is set to opampTech. Therefore, HeatWave will invoke
opampTech to define a thermal technology. Since we defined $TCLLIBPATH and tclIndex as previously
described, HeatWave can automatically locate the procedure opampTech.
You may easily modify this script’s functionality. For example, to re-run the simulation in batch mode, you
would set the util_cxt_batch variable to 1:
set runVars(util_cxt_batch) 1 ;# batch simulation
The complete Tcl steady-state simulation script from HeatWave’s Virtuoso GUI, that you can easily create
manually or procedurally, is shown below. It performs a super-set of the actions defined in basic.tcl.
# run.tcl:
# HeatWave Thermal Analysis Tcl script
# ====================================
# Define a Context named runVars [see tcl_util]

global runVars() ;# global array of run-control vars
gdNewVars runVars ;# runVars=Context with default settings
set runVars(batch) 0 ;# run in GUI
set runVars(summary) 0 ;# summarize layer temps in logfile
set runVars(run) 1 ;# run a simulation
set runVars(restore) "" ;# archive name to read in
set runVars(archive) "" ;# archive name to write to
set runVars(tech) {opampTech} ;# Tcl technology definition proc
set runVars(package) {pkg.ini} ;# package-model file
set runVars(trans) "" ;# empty, so run steady state
set runVars(libname) "OPAMP"
set runVars(cellname) "opamp"
# gda_local.tcl may contain Tcl commands, including user-defined callbacks

if {[file exists gda_local.tcl]} {source gda_local.tcl}
# Load results, or run a simulation, using runVars values

# gdRun is defined in $GDA_ROOT/tcl/gdacontext.tcl
gdRun runVars
The complete Tcl file local to the HeatWave simulation run-directory, gda_local.tcl, is shown below. This file
is loaded by the main script, run.tcl, listed above.
#gda_local.tcl:
# define Context callback cxtLocalPreRun
# to issue design-specific commands before running thermal simulation
proc cxtLocalPreRun {flow} {
gdInfo "local customizations before simulation"
[flow meshVars] configure
-refine_temp_value 0.5 # resolve to 0.5 degC
}
33
Using HeatWave’s Virtuoso GUI
5 Using HeatWave’s Virtuoso GUI
This section describes how you may use the Virtuoso graphical interface to HeatWave, to set-up and run a
thermal simulation. The HeatWave User Guide , and the HeatWave Tutorial , or OPAMP example, further
illustrate the capabilities described in this section
A section on Customizing HeatWave’s Interface to Virtuoso is provided in the HeatWave Reference Manual.
5.1 HeatWave Menu
The HeatWave interface to Virtuoso is installed when you load the SKILL file $GDA_ROOT/il/gda_-
heatwave.ile, as described in $GDA_ROOT/README.INSTALL After installation of the HeatWave inter-
face to Virtuoso, a pulldown-menu titled "HeatWave" is added to the banner menus in your test-bench’s
schematic window. You should run HeatWave from the "HeatWave" pulldown menu in a valid test-bench,
and not from some lower-level cell in the test-bench hierarchy, so the test-bench is reliably identified.
The entries in the "HeatWave" pulldown menu of a Virtuoso window are shown in the following figure.
Figure 21: HeatWave Menu in Virtuoso
Any entry selected from the HeatWave Menu launches a form that prepares data for, or runs, a steady-state
or transient electro-thermal simulation.
• "Setup Thermal Analysis..." launches the Thermal Analysis Setup Form

• "Extract Power Sources..." launches the Power Source Extraction Form
• "Setup Simulator..." launches the Simulation Setup Form
• "Run Thermal Analysis..." launches the Thermal Analysis Invocation Form
Your CAD support department will automatically load appropriate initial values for the entries in the forms
(whose description follows), so you should not generally need to modify most entries. Your CAD support
department will also define actions specific to your design environment, as each form is created, or after
each form has completed its actions, to ensure that data is properly set up for your design environment.
The forms launched from the HeatWave Menu are described in the following sections.
5.2 Thermal Analysis Setup Form
The "Setup Thermal Analysis..." menu launches the form shown in the following figure.
34
Figure 22: Thermal Analysis Setup Form
You may specify a transient or steady_state simulation Thermal simulation mode, and "HeatWave
run-directory", in which thermal simulation is performed. The name of the "Testbench" schematic is deduced
from the Virtoso cell-view within the current window. The schematic contains an instance of the "Cell name"
whose extracted-view provides the physical netlist for circuit-simulation. These are also deduced, if the
testbench is correctly prepared. You may also modify any of the above settings, if needed.
If you launch HeatWave from "HeatWave" pulldown menus in a cell below the top-level of the test-bench, the
test-bench’s cell-view cannot be reliably deduced by HeatWave. In that case, you must enter the test-bench
library and cell names manually. Depending on how your environment is configured, your CAD department
may be able to to deduce the test-bench in the appropriate callback.
You may specify the name of HeatWave’s OpenAccess database. HeatWave inputs are built by traversing
your design data.
5.3 Power Source Extraction Form
The "Extract Power Sources..." menu launches the form shown in the following figure.
35
Figure 23: Power Source Extraction Form
This form obtains the extents of power sources from your design data, to build HeatWave’s
<lib-name>.ptab input-file definining power-sources. This is done by traversing the "Extracted view"
that you specify. For each instance in the extracted view,
• HeatWave obtains the point at which the instance is placed (its location)
• If "recognition-layer" is selected HeatWave reads the SKILL recognitionShape() property, that your
device-extraction flow can attach to the instance it generates in the extracted-view. The recognition-
Shape() property is a standard Virtuoso construct, that defines a shape indicating where the device
was recognized by your device-extractor. This shape is used as the physical (x,y) extent of the power
source. It defines where power will be dissipated, for the given instance. If this method fails and "Try
alternate methods?" is selected, the "power-layer" method described below will be applied.
• If "power-layer" is selected HeatWave probes the layout cell-view you provide, on the "Power layer
name" (e.g. y0) you provide, at the location point identified for each instance in the extracted view. If
a geometry on the "power-layer" exists at that point, it is used as the physical (x,y) extent of the power
source. It defines where power will be dissipated, for the given instance. If "User-units around device
center" is specified, the region searched for overlap with a shape on "Power layer name", is a square
box with width 2∗p user units (usually microns) centered on the point. If this method fails and "Try
alternate methods?" is selected, the "recognition-layer" method described above will be applied.
• If neither method above can identify the extent of the power-source (instance), the bounding box of
the instance is used. Since this is probably inaccurate the definition written to the <lib-name>.ptab file
is commented. You may review and un-comment it, if acceptable.
• The thermal layer of a power-source determines its vertical location in the thermal stack. The power-
source’s thermal layer should be set by the appropriate SKILL callback procedure, defined by your
CAD department, typically within a physical design kit (PDK).
36
• Another method for specifying the thermal layer of the power source is applicable if the "power-layer"
is used. In this case you may associate a thermal layer with any shape on the "power-layer". You do
this by adding an optional SKILL property, whose value is a list, to any shape on the "power-layer"
you are using. The name of the property is the value of the "Power prop name" field of this form,
which is "power" by default. The value of the property is list( <thermal-layer-number> )
where thermal-layer-number is the integer identifying the thermal-layer for the power-source.
• By default, all power sources are placed on the layer-number specified in the "Power thermal-layer
number" field.
• The"Valid prop name", "Valid prop value" and "Valid layer name" fields are not generally required,
though they may be useful. The work as follows. If an instance within the extracted view has a
property defined, whose name matches the "Valid prop name" and whose value matches the "Valid
prop value", that instance is forced to be marked as valid. So, even possibly inaccurate bounding
box information that would have been written commented in <lib-name>.ptab file (see above) will now
be written uncommented to the <lib-name>.ptab file. Also, if you specified a "Valid layer name" and
a valid instance as described above contains layout on the "Valid layer name" in the master of the
instance, then that layout is used as the extent of the power source (i.e. instance).
The result of this form’s actions is to create HeatWave’s <lib-name>.ptab input-file defining power-
source extents for your design.
5.4 Simulation Setup Form
The "Setup Simulator..." menu launches the form shown in the following figure.
Figure 24: Simulation Setup Form
This form allows you to specify a circuit-simulator and an existing post-layout circuit-simulation run directory
37
in Virtuoso. The interface will invokes the specified Script to run simulation... that is typically provided by
HeatWave (though you may write your own), to modify the simulation-netlist, by associating parametrized
temperature values with each instance found in the power source extraction step. HeatWave later invokes
the same script during the electro-thermal loop to run circuit-simulation that computes the power dissipated
by each power-source.
The result of this form’s actions is to prepare a HeatWave circuit-simulation run directory for the simulator
you specify in the form. In particular, the simulation netlist is modified, so temperature-parameters are
associated with each instance. HeatWave computes and sets these temperature parameters before circuit-
simulation, within the electro-thermal loop.
5.5 Thermal Analysis Invocation Form
The "Run Thermal Analysis..." menu launches the form shown in the following figure.
Figure 25: Thermal Analysis Invocation Form
This form allows you to run or load a steady-state or transient HeatWave electro-thermal simulation, in
batch or GUI mode. When preparing to run a simulation, you may specify transient times, namely start,
38
stop, time-step and minimum step values in the "Start Stop Step Min-Step" list, or you may specify varying
time-steps in a "Time-steps(time) table" that defines transient time-steps as a function of time.
You may load (restore) existing results from a previously saved archive, instead of running a simulation.
In this case, you may specify reload times at each of which a temperature profile will be read from your
transient archive ("Load temperature-waveform from" field), and saved as valid initial-values for later use.
You may specify the name of the Tcl procedure that defines your current current thermal technology, This
sets the value of the Context variable tech, that determines the name of the Tcl technology-definition pro-
cedure in HeatWave. Examples of such settings are seen here.
This form’s action is to run HeatWave as specified, using settings in this form and the preceding forms. The
Tcl Utilities input model is used. HeatWave’s Virtuoso interface writes the data in the form’s fields into scripts
named run_transient.tcl (see example transient script) or run.tcl (see example steady-state script)
depending on the thermal simulation mode.
Each of these scripts eventually invokes the gdRun procedure (as in these transient or steady-state ex-
amples). HeatWave uses the inputs described in the Tcl Utility Input Model section, within the thermal
simulation flow of gdRun. Further context is provided by the sections on how data from Virtuoso is used in
HeatWave and on the HeatWave program flow.
HeatWave’s log-file (also saved as .gda_log in the HeatWave run-directory) is presented in a Virtuoso text-
file window. If "Invoke in batch mode?" was not selected, the HeatWave GUI is started after simulation, or
after loading previous results. The HeatWave GUI is described in the HeatWave User Interface Guide.
Possible outputs include text files, binary archives or transient outputs depend on the thermal simulation
mode and other settings.
39

User Guide: Heatwave 2019.02

Uploaded by

Copyright:

Available Formats

You might also like

User Guide: Heatwave 2019.02

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

User Guide: Heatwave 2019.02

Uploaded by

Copyright:

Available Formats

HeatWave

© Keysight Technologies, Inc. 1983-2019

1400 Fountaingrove Pkwy., Santa Rosa, CA 95403-1738, United States

All rights reserved.

Restricted Rights Legend

Publication Date: February 13, 2019

3 Thermal Technology Definition 9

4.2.2 Ptab File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

5 Using HeatWave’s Virtuoso GUI 34

Figure 1: HeatWave program flow

2.1 System requirements

HeatWave is supported on the following 64 bit platforms:

• Red Hat Enterprise Linux version 5 and above

• If an electro-thermal loop is required, a circuit-simulator supported by HeatWave should be used.

2.2 Configuring licensing

2.3 Setting up the environment

• licensing and license-queuing control variables

• executable search path setting

• other recommended variable-settings

2.4 Running HeatWave

Figure 2: HeatWave Input Models

2.4.1 Text Input Model

2.4.2 Scripting Primitives Input Model

2.4.3 Tcl Utility Input Model

2.5 HeatWave Data Flow

Figure 3: HeatWave data flow using Cadence Virtuoso

2.6 HeatWave Use Models

HeatWave computes 3-D temperature profiles of a chip taking as input:

• initial power estimates from power analysis tools,

• analog floorplanning; prototyping functionality, performance

2.6.1 Analog floorplanning and prototyping

HeatWave may be used for analog floorplanning or prototyping when

Figure 4: Prototyping Use Model

2.6.2 Detailed electro-thermal analysis

Figure 5: Detailed Use Model

3 Thermal Technology Definition

3.1 Complete Thermal Technology Example

Figure 6: Simple 2-metal CMOS layer-stack

# Tcl definition of the thermal properties of the Silicon,

# add each material to the flow’s Tech object

Figure 7: Layer 0: substrate

# Tcl definition of the substrate

Figure 8: Layer 1: oxide

Figure 9: Layer 2: channel

Figure 10: Layer 3: thinox

Figure 11: Layer 4: poly

Figure 12: Layer 5: contact

Figure 13: Layer 6: metal1

Figure 14: Layer 7: via1

Figure 15: Layer 8: metal2

Figure 16: Layer 9: passivation

3.2 Compact Technology Definition

gdDefineTech <flow> <material-list> <thermal-layer-list> [<heat-capacity-list>]

Figure 17: Simple 2-metal CMOS layer-stack

# Tcl example of a complete thermal technology description in Tcl.

# VOLUMETRIC HEAT CAPACITY (use material names from K_list)

{ HW_IGNORE poly 0.2e-6 SiO2 {POLY PolySi} {CONT W} }

3.3 Text Technology Definition