Interactive PCB- or Chip-Scale Thermal Visualization Tool
Print
Author(s):
Roger Paul Stout -
ON Semiconductor
Industry:
Semiconductor, Research
Products:
LabVIEW
The Challenge:
Developing an interactive graphical simulation in a printed circuit board (PCB) or semiconductor die that instantaneously computes a physics-based solution to the temperature/heat-flow equations in real time, permitting the user to dynamically reposition heat sources with a mouse and easily change simple boundary conditions.
The Solution:
Partitioning the problem into two parallel processes – one that interactively takes user input and
recomputes the temperature field based on current heat source locations and theta matrix on demand, and a second that builds and solves (inverts) the theta matrix for the most recently available set of conditions.
"The excellent built-in XY graphing features in LabVIEW make the implementation of a 2D temperature map very easy. "
A common thermal misunderstanding in the semiconductor packaging industry is that every device has an intrinsic thermal resistance, theta-JA. In truth, many external factors affect the theta-JA of each device in a complete system. The interactions between nearby devices are often the largest source of the inconstancy of these imagined constants. Careful examination of the equations can help us understand these effects.
Indeed, sophisticated modeling tools are available to solve the most complex and challenging of thermal problems. Yet for problems, whether simple or complex, state-of-the-art simulation tools generally require deeply committed, if not expert, users at the controls. Furthermore, even for relatively simple problems, the feedback necessary to develop any intuition requires multiple iterations of model building and analysis and is far from instantaneous.
For the first time, a fortunate convergence provides the ability to construct a tool that addresses the need to develop thermal intuition. First, desktop computing power has finally reached the level at which modest detail can be simulated using real thermal physics in an acceptably short period of time. Second, the intrinsic parallelism of the NI LabVIEW graphical programming environment, combined with its powerful math library, makes it possible to partition a particular mathematical solution methodology (namely, for linear thermal systems) into two essentially uncoupled paths. One thread handles the extremely compute-intensive matrix inversion, which, in a properly formulated problem, need not be done very often. The other thread (or threads) manages all aspects of user interaction with the problem, including redistributing heat sources within the solution domain (in such a way that the primary theta matrix need not be recomputed) and adjusting to simple boundary conditions, all the while continuously recomputing the resulting temperature field based on the most recently available theta matrix.
Mathematical Problem
In the case of a linear thermal system, a single, large conduction matrix (consisting of nxn elements, where n is the number of discrete temperature locations, or nodes, within the solution domain) represents all possible heat flow paths between temperature nodes. In typical finite-element modeling tools, we may not explicitly or directly invert this matrix but rather iteratively solve it to achieve an energy balance between nodes subject to and in the context of various specific constraints, including the sizes and locations of heat sources in the domain. Generally, changing the boundary conditions (including location of explicit heat sources) requires the entire problem to be resolved.
However, if this matrix is explicitly inverted, every variable-temperature node represents an arbitrary possible heat source, and we can simply multiply the resulting inverse of the conduction matrix, herein called the theta matrix, by a heat source vector (that is, the actual instantaneous heat input at every node) to obtain the temperatures of all nodes. This means that once we compute the theta matrix for a particular problem layout – if we can relocate a heat source without otherwise changing the conduction matrix – we do not need to recompute the theta matrix at all, saving enormous amounts of CPU effort.
It also turns out that for a linear system, we can easily approach any small, arbitrary subset of variable temperature nodes as if they are fixed temperature boundaries, thus making it possible for us to quickly recompute the temperature solution for moving heat sources as well as moving boundaries. The key here is that, as the number of nodes in the problem increases, matrix inversion rapidly becomes extremely CPU- and memory-intensive, whereas matrix partitioning and matrix multiplication become increasingly instantaneous by comparison. Readily available and reasonably priced commercial desktop systems with dual- or quad-core CPU architectures can easily manage the direct inversion of 2000-node matrices.
This problem description is extremely general, but in the specific regime of PCB analysis with multiple devices composing heat inputs to the board, it may be possible to represent the entire system model as a 2D sheet of nodes. In the case of a die-level simulation, where multiple heat sources represent different functional blocks of power dissipation on the surface of the silicon chip, we may need to use several layers of nodes to adequately represent the 3D nature of the heat flow within the structure, but the same principles apply and we can reuse much of the code. Indeed, one may view a single-layer PCB as simply a special case of the multilayer die problem.
The Role of LabVIEW
The first crucial contribution by the LabVIEW graphical programming environment to the instant-feedback thermal simulator is the ease with which we can separate the mathematical problem described above into parallel threads of data manipulation. The most CPU-intensive thread handles the matrix inversion process, and users only occasionally need to invoke it when they make changes to portions of the problem setup directly affecting the conduction matrix. (These would include changing the size of the domain, number of nodes, or material properties and describing the conduction paths within the system.)
The second main thread interrogates the current positions of all the user-defined heat sources and potentially movable fixed-temperature constraints (based on mouse movements). In terms of the PCB layout, once users have created a set of devices and constraints, they may view these items as objects that can be dragged around.
The matrix multiplication operations are so fast that they yield temperature maps from the previously determined theta matrix. We can also determine the current locations of the constrained nodes (whether heat or temperature) almost as quickly as we can move the mouse. Moving temperature constraints requires concurrent use of the matrix inversion library. But because this library is reentrant, the parallel program architecture makes this very clean.
Finally, the excellent built-in XY graphing features in LabVIEW make the implementation of a 2D temperature map very easy. With mouse event information, we can superimpose a user-controlled physical map of a PCB on top of the temperature map, where we may create objects and freely drag them around while LabVIEW continuously updates the temperature map based on the current locations.
|
|