# home : articles : How to Find Input Capacitance Using Spice

Spice is the circuit designer's Swiss Army knife. We use it whenever we need to precisely determine the properties of our circuits. This page shows how to find the input capacitance of a node (usually the input of a digital circuit, like an inverter) using Spice.

## The First Rule of Using Spice is Don't Use Spice

You build a CMOS inverter for your boss and she asks you what the input capacitance is. You answer: “I'm not sure, but I will find out right away!” What you should have been able to say to her is: “Well, boss, the first thing I did was to familiarize myself with the 12nm CMOS process and I found that the input capacitance is 0.8 fF/μm, so of course my 7μm PMOS, 3μm NMOS inverter has about 8 fF of input capacitance. ” But you didn't say that, because you didn't know. You are a spice monkey.

Don't be so dependent on Spice. You should always be able to predict an approximate answer to simple questions like this without resorting to a Spice simulation. The typical things you should know about the transistor process you are designing in: gate capacitance per unit width of transistor gate (for minimum length), diffusion capacitance per unit area, effective resistance (when used in a digital gate) in Ωμm, and fanout-of-4 (FO-4) delay. Of course, you need a way to find all these parameters and even though approximations these parameters are very useful for choosing topologies and calculating results to a first order, eventually you need more precise quantities. For those cases, Spice is the right tool.

To paraphrase Sun Tzu in The Art of War:

If you know Spice and yourself, you need not fear the result of a hundred simulations. If you know yourself but not Spice, for every successful simulation you will also suffer a defeat. If you know neither Spice nor yourself, you will succumb in every simulation.

## The Spice Deck Using a Data Sweep

One way to find capacitance using Spice is to build two copies of your circuit. One copy is loaded by the capacitive device that you are trying to characterize and the other copy is loaded by a simple capacitance (a C element in Spice) with the amount of capacitance set as a parameter. You then sweep through a series of values for the C, finding the value that causes the circuits to match. The way they match is up to you. Common methods of matching circuits is in terms of rise delay, fall delay, rise time (10% to 90%) or fall time (90% to 10%).

The Spice deck below shows an example of sweeping the capacitance CLOAD to find the input capacitance of the inverter Xinv0_load. We find its capacitance by finding the value of CLOAD that causes the two circuits to have the same average delay—measured from the 50% crossing point of the input waveform to the 50% crossing point of the output waveform and averaged for a rising and falling edge. Once we know this value of CLOAD, we know it is equivalent to the input capacitance of Xinv0_load for the purpose of finding rise/fall time.

The basic structure of the Spice deck below is to instantiate the appropriate power supplies, input signal waveform, the first circuit consisting of inverters Xinv0_driver and Xinv0_load , and the second circuit consisting of Xinv1_drive (the same as Xinv0_driver) and the capacitance parameterized with CLOAD.

The sweep notation in the .tran analysis statement runs multiple simulations with a range of values for the parameter CLOAD.

```
* Find the input capacitance using sweep method

.lib 'my-transistor.lib' TT
.temp 25

.param vd=1V

* Power supplies
Vvdd vdd 0 dc vd
Vvss vss 0 dc 0

* Input waveform
Vin in 0 PULSE 0 vd 100ps 80ps 80ps 500ps 1u

* First circuit, uses the load we are trying to characterize
Xinv0_driver mid0    in  vdd vss inv WP=2  WN=1
Xinv0_load   out0  mid0  vdd vss inv WP=10 WN=5

* Second circuit, uses a parameterized load capacitor
Xinv1_driver mid1    in  vdd vss inv WP=2  WN=1

* Measure rising and falling edge (with respect to the output edge) time delays for
* the real copy of the circuit.
.measure TRAN tdr   TRIG v(in) VAL='0.5*vd' FALL=1 TARG v(mid0) VAL='0.5*vd' RISE=1
.measure TRAN tdf   TRIG v(in) VAL='0.5*vd' RISE=1 TARG v(mid0) VAL='0.5*vd' FALL=1
.measure TRAN tdavg PARAM='(tdr+tdf)/2'

* Measure the same parameters for the model circuit loaded by CLOAD
.measure TRAN tdrc   TRIG v(in) VAL='0.5*vd' FALL=1 TARG v(mid1) VAL='0.5*vd' RISE=1
.measure TRAN tdfc   TRIG v(in) VAL='0.5*vd' RISE=1 TARG v(mid1) VAL='0.5*vd' FALL=1
.measure TRAN tdavgc PARAM='(tdrc+tdfc)/2'

.tran 1ps 1ns SWEEP data = info
10fF
11fF
12fF
13fF
14fF
15fF
16fF
17fF
18fF
19fF
20fF
.enddata

.subckt inv out in pow gnd  WP=2u WN=1u
mn out in gnd gnd W=WN L=LMIN * assume LMIN is defined in library
mp out in pow pow W=WP L=LMIN * assume LMIN is defined in library
.ends

.probe v(*)

.end

```

Notice that the sweep in this deck steps in increments of 1fF. So if you need a more precise value, either run more steps in the sweep, or do a second sweep, once the first sweep has bracketed the capacitance with within one fF.

Since the real input capacitance of Xinv0_load is nonlinear, even a highly precise sweep of CLOAD is an approximation, albeit one that is quite accurate. You can find the equivalent CLOAD to match some other parameter between the circuits, such as average 10%-to-90% rise/fall time. You will find that the resulting CLOAD will be somewhat different from the one that matches the circuits based on the average %50-to-%50 delay. It's best to match the circuits using the parameter(s) that you will later use CLOAD to find. So if you will be using CLOAD to predict dynamic power consumption, then it's a good idea to match the two circuits based on power consumption.

## The Hspice Deck Using Built-in Optimization

There is another, more elegant way to find CLOAD using the built-in optimizer of Hspice, one of the commercial versions of Spice. If you use another flavor of Spice, or a variant like Spectre, there is probably an equivalent way of performing optimization, although the syntax may be slightly different.

The Hspice deck for find the matching CLOAD is presented below. The deck is largely the same as the sweep method above, with a few important changes. One change is the way the parameter CLOAD is initialized. We use the syntax OPTC(15FF, 1fF, 30fF), telling the iterative optimizer to start with 15fF as the initial CLOAD value and to freely range between 1fF and 30fF to find the solution. The second change is the addition of the GOAL=tdavg parameter to the .measure statement that defines tdavgc. This tells tells the optimizer that the it should strive to choose CLOAD such that tdavgc is equal to tdavg. The .tran statement is updated to indicate that this is an optimization analysis and it describes which measure statement to optimize (tdavgc in this case). Finally, we also add the line .model OPT1 opt to signal to Hspice that this is an optimization deck.

```
* Find the input capacitance using Hspice optimizer

.lib 'my-transistor.lib' TT
.temp 25

.param vd=1V

* Power supplies
Vvdd vdd 0 dc vd
Vvss vss 0 dc 0

* Input waveform
Vin in 0 PULSE 0 vd 100ps 80ps 80ps 500ps 1u

* First circuit, uses the load we are trying to characterize
Xinv0_driver mid0    in  vdd vss inv WP=2  WN=1
Xinv0_load   out0  mid0  vdd vss inv WP=10 WN=5

* Second circuit, uses a parameterized load capacitor
Xinv1_driver mid1    in  vdd vss inv WP=2  WN=1

* Measure rising and falling edge (with respect to the output edge) time delays for
* the real copy of the circuit.
.measure TRAN tdr   TRIG v(in) VAL='0.5*vd' FALL=1 TARG v(mid0) VAL='0.5*vd' RISE=1
.measure TRAN tdf   TRIG v(in) VAL='0.5*vd' RISE=1 TARG v(mid0) VAL='0.5*vd' FALL=1
.measure TRAN tdavg PARAM='(tdr+tdf)/2'

* Measure the same parameters for the model circuit loaded by CLOAD
.measure TRAN tdrc   TRIG v(in) VAL='0.5*vd' FALL=1 TARG v(mid1) VAL='0.5*vd' RISE=1
.measure TRAN tdfc   TRIG v(in) VAL='0.5*vd' RISE=1 TARG v(mid1) VAL='0.5*vd' FALL=1
.measure TRAN tdavgc PARAM='(tdrc+tdfc)/2' GOAL=tdavg

* We set the GOAL to tdavg which will cause the optimizer to try
* select a CLOAD that cause tdavgc to match tdavg

.model OPT1 opt

.tran 1ps 1ns SWEEP OPTIMIZE=optc RESULTS=tdavgc MODEL=OPT1

.subckt inv out in pow gnd  WP=2u WN=1u
mn out in gnd gnd W=WN L=LMIN * assume LMIN is defined in library
mp out in pow pow W=WP L=LMIN * assume LMIN is defined in library
.ends

.probe v(*)

.end
```

This deck is elegant in that there no need to do multiple sweeps. Hspice will find the result to a useful precision. One caveat is that the general view amongst most circuit designers I know is that the Hspice optimizer is a piece of crap. It works just fine for simple optimizations like the one above, but can fail to converge or, even worse, give the wrong answer for optimizations of many variables. This deck is simple enough that I have never encountered a problem using it with the Hspice optimizer. To help Hspice converge to a solution as quickly as possible, it is a good idea to give a reasonable starting point and range for all optimization parameters.

## Building A Library

The first time you have to perform a task like finding input capacitance it's worth taking the time to build a good Spice deck, whether you use the sweep method or optimization method or find your own more clever method. You will find that as you have to repeat these tasks, all you will have to do is brush off an old Spice deck, make some minor modifications and you'll be quickly done. Then you can spend your time doing real thinking and less simulating.