Now that the Keithley 2450 SMU has passed its initiation and been “accepted” by my family of instruments, it’s time to look at various applications of the SMU. During my original RoadTest review, I had already looked at some basic I-V testing (with KickStart 2, I-V Tracer and TSP-Scripting) including diodes, LEDs, MOVs, neons and MOSFETs. After the RoadTest was delivered, I used the SMU for some I-V characterisation of an Epishine Light Energy Harvesting organic PV module and some battery capacity measurements. Recently, on my own personal blog, I took a look at performing battery simulation using TSP scripting.


In this blog, I will look at capacitor testing with an SMU, focusing mainly on electrolytic capacitors. As the SMU is capable of precision current sourcing with high-precision voltage measurement at high speeds, it should be possible to measure the value of a capacitor as well as its leakage current with the 2450 SMU. The latter is especially important for “wet” electrolytic capacitors as it provides an indication as to the health of the oxide layers within the capacitor.


Electrolytic Capacitor Value and Leakage Current

The humble electrolytic capacitor is a mainstay when large capacitances are required as a local reservoir of power. These capacitors are most commonly found in a metal can form factor, sealed with a rubber bung and consist of a roll of multi-layer construction including an oxide layer and liquid electrolyte.


The behaviour of a capacitor is to “integrate” the current over time. In order to measure the value of a capacitor, it can be as simple as providing a constant current and measuring the voltage and time. The capacitance can be found based on the equation C = I * T / V.


However, electrolytic capacitors also have a downside – they often have higher leakage currents than other types of capacitors. The leakage arises because of imperfections and weaknesses in the oxide layers, charge tunnelling and cross-currents within the package (e.g. via the rubber bung) and can be affected by temperature, voltage, time exposure to voltage (as it builds up oxide layers) and dielectric absorption effects. It provides a hint as to the state of the internal oxide layers within the capacitor and its overall health. As a result, a “real” electrolytic capacitor that is charged will “lose” charge over time and actually be “leaking” while it is being charged. This means that simply looking at the voltage and time during charging may overestimate the size of the capacitor.


The leakage current can be directly measured, assuming you can hold the capacitor at a steady voltage. The leakage current would, therefore, be the current required to maintain the capacitor at this steady voltage. Common datasheet specifications for leakage current have the capacitor charged to the working voltage and held for a period of 60s or 120s at a temperature of 20°C. Commonly used thresholds for acceptable leakage current is <=0.03*C*V at 60s or <=0.01*C*V at 120s, with some datasheets also stating 4µA and 3µA respectively as a minimum value with the acceptable value being whichever is greater. For a 1000µF 16V capacitor, this appears to permit 480µA at 60s or 160µA at 120s.


I decided to try testing this using KickStart 2’s I-V Characterizer module. While the module is suited mainly for I-V curve analysis, this doesn’t mean it can’t be repurposed for other investigations. Testing was performed using the front-panel banana jacks on the 2450 with the included test leads, which is not ideal for precision low-current measurements. The capacitor was placed inside a glass jar for safety and to reduce the influence of sudden ambient air temperature changes on the capacitor temperature.

The test was configured using the “Current Bias” mode of operation, which configures the SMU to source a fixed current. Measurements were configured for higher accuracy with auto-zero turned on and high-capacitance mode turned on (although it doesn’t really matter as the levels are fixed).


By default, while the test is running, the graph isn’t configured in a useful way as it defaults to an I-V curve – in our case, the V rises as the capacitor charges while I remains constant and once charged, then the I decreases while V remains constant. The graph is very dull otherwise. But then, I discovered through some judicious “mouse hovering” that the axes can be configured and instead, we can make a plot versus time with voltage and current on two separate axes. With this setting, we are in business to see what is happening … but even without it, I decided that the best way to perform the analysis was to export the data from KickStart 2 and check it out in Excel.

A test result looks something like this – as I described, the current is constant until the capacitor is charged, then the voltage is constant while the current decreases to the leakage value. We can see a bit of overshoot – it seems the SMU may have subtly “overshot” the target voltage and thus “sunk” a little current from the capacitor to maintain the requested 16V. Looking at each component of the test, we can derive the necessary parameters.

The value is taken by looking at the initial part of the curve while it is charging. It charges about 16V in 20s, thus the computed value is 1250µF. The capacitor itself is a 1000µF capacitor, but as it is fresh, it may be a little bit above, but more likely is that the leakage current during the charging period was also integrated thus inflating the measured capacitor value. This could be potentially compensated for by measuring the value in discharge as well and averaging it – I do this later in the section where I automate this using a TSP script.


The measured leakage at 60s is about 6µA which falls to just 3µA at 120s. This seems to be quite a healthy capacitor, although there is some noise in the readings. This is potentially partly due to the capacitor’s internal state as a fresh capacitor, but also potentially because of the voltage ripple noise that the SMU may generate. But it does give us a good value to indicate this capacitor is very healthy.

Testing another 1000µF 16V capacitor from my box from a different manufacturer, this time I chose a slower charging current which lengthens the test but should provide better accuracy/resolution for the leakage current check. The result is a computed value of 1231µF, again, an overestimate but perhaps even more affected by leakage because of the long charging time. Leakage for this capacitor was even better, measuring 2.7µA at 60s and 1.6µA at 120s.


Electrolytic Capacitor Forming Voltage

One parameter of an electrolytic capacitor is the forming voltage. This is not a parameter that is usually measured, but its significance is noted in the rated working voltage of the capacitor. I’m sure people are aware, either by accident or by employing the phenomenon in a potentially dangerous prank, of what happens when the forming voltage is exceeded (N.B. the below animation involving an un-vented vintage Cornell Dubilier axial capacitor recorded under controlled conditions several years back involving 36V and 7A of current) -

Exceeding the forming voltage causes the oxide layer within the electrolytic capacitor to continue its formation process which consumes high levels of current, produces a lot of heat which in turn increases the pressure within the capacitor’s can and eventually leads to explosive rupturing of the capacitor (or its vent) and the discharge of hot, vaporised electrolyte and (in this case) some cardboard fibres.


For electrolytic capacitors to work safely and reliably, the oxide is pre-formed at a thickness such that its forming voltage is above the maximum safe working voltage by a margin. This allows for reliability as well as providing the ability to ride-out short-term “surge” voltages.


This got me thinking – how much safety margin is there? I’ve noted coming across articles (although I can’t verify the veracity of them) where some counterfeit component suppliers had re-sleeved genuine capacitors with higher voltage ratings than they were initially rated for to make a bit more money, or created a fake capacitor by placing a smaller voltage rated capacitor inside a can for a larger capacitor (not for aesthetic reasons). In other cases, perhaps some capacitors were just bad from the factory. How can we know the actual safe voltage for an electrolytic capacitor?


Disclaimer: The information provided here is for informative purposes only and use is at the reader’s own risk. Do not try this at home as significant danger may occur in case of the over-pressure rupturing of an electrolytic capacitor. I will not be held responsible in case of any harm or damage that may arise.


Putting on my thinking cap, I realised that the leakage current limits identified earlier are “safe” levels of current flow through an electrolytic capacitor – they won’t cause enough heating to cause destruction. As a result, it should be “safe” to source up to 100µA or possibly even 1mA into a capacitor for a time and see where the voltage ends up to find the (approximate) forming voltage. In this case, I decided to try it for about 30-minutes.


Scouring the house for fresh unused capacitors of a variety of voltage ratings, I ran the tests using KickStart 2 to log the data and analysed the results in Excel. The results are shown in the following graph:

In all cases, the forming voltage identified at 100µA constant current was above the working voltage (which is expected), but the margin varied. The U-brand “generic” 63V capacitor had a 33% margin, while the lower-tier (and much older) Samhwa 35V had 23% margin. The trusted Japanese capacitors had margins ranging from 48% to 63%. It is interesting to see that usually this margin takes you close to but not quite at the next voltage tier. There were some “dips” in the voltage curves, which may indicate some chemical activity (formation) is occurring despite the low current employed in the test. I suppose I’m perhaps less apprehensive about getting away with shoving in a high-quality 10V-rated capacitor on a 12V circuit, at least temporarily until the right value capacitor arrives.


At this point, you might be wondering whether you could just take an I-V curve of a capacitor by sourcing voltage. While this sounds like a possibility, it’s actually quite hard to define any sensible (timely) measurement as “sweeping” the voltage causes charging currents to flow into the capacitor which take time to equalise (ideally, in infinite time). Adding a delay may help, but slows down the process significantly. I tried it myself using KickStart 2 using a 10s delay on each point, but the “noise” from getting a point sample at each step meant that the I-V results were difficult to interpret.


Polyester Film Capacitor Leakage Current?

Being ever-so-curious, I wondered what might happen if I attempted to measure the leakage current of other types of capacitors. The only other sort of capacitors I could find in my stash were polyester film types, one of which is a 20 to 30 year old greencap (i.e. dipped) capacitor recovered from surplus and the other an MKT (i.e. boxed) capacitor from five years ago. Both capacitors were rated at 100V, but polyester film capacitors are reputed for being “low-leakage” and to some extent, over-voltage tolerant up to 2.5-times their rating.


To maximise the chance of measuring something given the use of front-panel banana jacks (i.e. no triax connections here), I decided to bump the test voltage up to 200V and chart the results over an extended period (~24h) using KickStart 2.

As the capacitors were small, the test current was set to 10nA and the full current was flowing until the capacitor reached 200V. The greencap measurement shows something similar to a leakage current trend – falling to about 1nA but then rising slightly. The MKT on the other hand saw its current plummet dramatically when fully charged, reaching about 350pA but then the curve goes and “wanders about”.


This illustrates the perils of making precision low-current measurements using standard test leads connected to the banana jacks. Almost certainly, we are not able to resolve the leakage current (especially for the MKT case) as we are measuring the insulation resistance of the test leads themselves. Likewise, other influences need to be taken into account – while the capacitor was inside a glass jar with lots of air around it, changes in temperature and humidity are likely to have caused the “wandering” readings as that evening as the day was relatively warm and humidity was increased due to rain. Finally, the geometry of the test leads also played a role – I deliberately set it up in a quiet corner of the room, as any movement of the leads caused spikes in the graph. This is because the leads themselves form a capacitor and the dielectric gets “charged”. Changes in the geometry of the test setup cause currents greater than the steady state to flow, obscuring the actual data.


This is why the Keithley 2450 SMU features triax connections on the rear with guarding to remove the influence of insulation resistance and ensure high precision. The use of the triax connections is required to meet the stated accuracy claims in the datasheet when using the 10nA/100nA ranges. Unfortunately, such connectors, cables and test fixtures are quite expensive and as this is not my primary line of work, I can’t justify the expense. But it’s good to know that such an option is available, as some of their competitors don’t offer this on the unit itself (e.g. the Keysight B2900A series which relies on an adapter).


Capacitor Value, Leakage Current Test using TSP-Scripting

While it is possible to use KickStart 2 and its I-V Characteriser in Current Bias mode to gather some information about a capacitor’s value and leakage current, it is not ideal as it requires manual post-processing of the data and doesn’t do some housekeeping tasks such as discharging the capacitor prior to beginning the test and after the completion of the test.


While that may sound unfortunate, Keithley provides tools for users to develop their own solutions to problems using TSP Scripting which runs directly on the SMU, simplifying operation, providing improved test speeds and accurate timestamps which is critical for this application. Using the TestScriptBuilder environment, I developed a script called ElectroCapCheck and the code is shown below. Note that no warranties are expressed or implied – use is at the user’s own risk. Alternatively, it can be downloaded in the attached .zip file at the end of this post.

-- Electrolytic Capacitor Value & Leakage Test with Keithley 2450 SMU
-- Proof-of-Concept - V0.3 by Gough Lui ( - Dec 2020
-- No warranties expressed or implied. Use at your own risk.

-- Script Begins
beginprompt = display.prompt(display.BUTTONS_NONE, "Electrolytic Capacitor Value & Leakage Test by Gough Lui (Dec 2020)\nWARNING: Use at your own risk!")

-- Configure SMU
smu.source.offmode = smu.OFFMODE_HIGHZ
smu.measure.nplc = 1
smu.measure.displaydigits = smu.DIGITS_6_5

-- Option Inputs for User - Note: Limited Error Checking - if the user presses Cancel, script will fail (comparison with 'nil' exception)!
-- Configure Capacitor Working Voltage - Note, ^ values need interlock signal
capvolts = 0.0
senseoption = display.input.option("Capacitor Voltage Rating", "6.3V(*)", "10V", "16V", "25V", "35V", "50V^", "63V^", "100V^", "160V^", ">=200V^")
if senseoption == display.BUTTON_OPTION1 then 
  capvolts = 6.3
elseif senseoption == display.BUTTON_OPTION2 then
  capvolts = 10
elseif senseoption == display.BUTTON_OPTION3 then
  capvolts = 16
elseif senseoption == display.BUTTON_OPTION4 then
  capvolts = 25
elseif senseoption == display.BUTTON_OPTION5 then
  capvolts = 35
elseif senseoption == display.BUTTON_OPTION6 then
  capvolts = 50
elseif senseoption == display.BUTTON_OPTION7 then
  capvolts = 63
elseif senseoption == display.BUTTON_OPTION8 then
  capvolts = 100
elseif senseoption == display.BUTTON_OPTION9 then
  capvolts = 160
elseif senseoption == display.BUTTON_OPTION10 then
  capvolts = 200

-- Configure Test Current
-- NOTE - same range is used to measure leakage current, so choosing a higher test current results in lower accuracy for leakage
-- and potentially less accurate capacitor size values if charging is too rapid. Likewise, choosing lower ranges may result in
-- overestimation of capacitor size due to integration of leakage over time.
senseoption = display.input.option("Capacitor Test Current", "10nA", "100nA", "1uA", "10uA", "100uA(*)", "1mA", "10mA", "100mA", "1A")
if senseoption == display.BUTTON_OPTION1 then 
  testcurrent = 10*10^-9
elseif senseoption == display.BUTTON_OPTION2 then
  testcurrent = 100*10^-9
elseif senseoption == display.BUTTON_OPTION3 then
  testcurrent = 1*10^-6
elseif senseoption == display.BUTTON_OPTION4 then
  testcurrent = 10*10^-6
elseif senseoption == display.BUTTON_OPTION5 then
  testcurrent = 100*10^-6
elseif senseoption == display.BUTTON_OPTION6 then
  testcurrent = 1*10^-3
elseif senseoption == display.BUTTON_OPTION7 then
  testcurrent = 10*10^-3
elseif senseoption == display.BUTTON_OPTION8 then
  testcurrent = 100*10^-3
elseif senseoption == display.BUTTON_OPTION8 then
  testcurrent = 1

-- USB Logging Configuration
usboption = display.BUTTON_NO
if (file.usbdriveexists() == 1) then
  usboption = display.input.prompt(display.BUTTONS_YESNO,"Log data to USB?")
  if usboption == display.BUTTON_YES then
    filenameoption = display.input.string("Enter File Name", display.SFORMAT_BUFFER_NAME)

-- Set up user display

-- Step 1 - Discharge Capacitor
display.settext(display.TEXT1,"Step 1: Discharging Capacitor")
smu.source.func = smu.FUNC_DC_VOLTAGE
smu.measure.func = smu.FUNC_DC_VOLTAGE
smu.source.level = 0
smu.source.ilimit.level = 0.1
smu.source.output = smu.ON
currentvolts = 1.0
while currentvolts > 0.005 do
  currentvolts =
  display.settext(display.TEXT2,"V: "..currentvolts.."V")
display.settext(display.TEXT2,"Holding 0V for 15s")
delay(15) -- 15s delay at 0V added to try and mitigate dielectric absorption effects, in case of sequential tests
smu.source.output = smu.OFF

-- Step 2 - Test Capacitor
display.settext(display.TEXT1,"Step 2: Testing Cap")
smu.source.func = smu.FUNC_DC_CURRENT
smu.source.range = testcurrent
smu.source.level = testcurrent
smu.measure.func = smu.FUNC_DC_VOLTAGE
smu.measure.range = capvolts
smu.source.vlimit.level = capvolts
smu.source.output = smu.ON
testcomplete = 0
initialt = 0
finalt = 0
leakaget = 0
leakcur60 = 0
while testcomplete == 0 do
  readv,readt,readf = smu.measure.readwithtime(defbuffer1)
  if (initialt == 0 and readv >= 0.1*capvolts) then
    initialt = readt + readf
    initialv = readv
    display.settext(display.TEXT2,"10% Voltage Reached")
  if (finalt == 0 and readv >= 0.9*capvolts) then
    finalt = readt+readf
    finalv = readv
    display.settext(display.TEXT2,"90% Voltage Reached")
  if (leakaget == 0 and defbuffer1.sourcevalues[defbuffer1.endindex] <= 0.9*testcurrent) then
    leakaget = readt+readf
    display.settext(display.TEXT2,"Leakage Test Begin")
  if (leakaget != 0) then
    display.settext(display.TEXT2,"Leakage Test "..math.floor((leakaget+120-(readt+readf))).."s Remain")
  if (readt+readf >= leakaget+60 and leakaget != 0 and leakcur60 == 0) then
    leakcur60 = defbuffer1.sourcevalues[defbuffer1.endindex]
  if (readt+readf >= leakaget+120 and leakaget != 0) then
    testcomplete = 1
    leakcur120 = defbuffer1.sourcevalues[defbuffer1.endindex]
    display.settext(display.TEXT2,"Leakage Test Completed")
capcvalue = (testcurrent*(finalt-initialt))/(finalv-initialv)
smu.source.output = smu.OFF
smu.source.func = smu.FUNC_DC_VOLTAGE
smu.source.range = capvolts
smu.source.level = 0
smu.measure.func = smu.FUNC_DC_CURRENT
smu.measure.range = testcurrent
smu.source.ilimit.level = testcurrent
smu.source.output = smu.ON
testcomplete = 0
dinitialt = 0
dfinalt = 0
while testcomplete == 0 do
  readv,readt,readf = smu.measure.readwithtime(defbuffer1)
  if (dinitialt == 0 and defbuffer1.sourcevalues[defbuffer1.endindex] <= 0.9*capvolts) then
    dinitialt = readt + readf
    dinitialv = defbuffer1.sourcevalues[defbuffer1.endindex]
    display.settext(display.TEXT2,"90% Voltage Reached")
  if (dfinalt == 0 and defbuffer1.sourcevalues[defbuffer1.endindex] <= 0.1*capvolts) then
    dfinalt = readt+readf
    dfinalv = defbuffer1.sourcevalues[defbuffer1.endindex]
    display.settext(display.TEXT2,"10% Voltage Reached")
  if (defbuffer1.sourcevalues[defbuffer1.endindex] <= 0.005) then
    testcomplete = 1 -- discharged when capacitor <=5mV
smu.source.output = smu.OFF
capdvalue = (testcurrent*(dfinalt-dinitialt)/(dinitialv-dfinalv))
capvalue = (capcvalue+capdvalue) / 2 -- average charge and discharge result
if usboption == display.BUTTON_YES then,"/usb1/"..filenameoption..".csv")

-- Done
display.settext(display.TEXT1,"Done! C: "..(math.floor((capvalue*10^9)+0.5)/1000).."uF")
display.settext(display.TEXT2,"L60: "..(math.floor((leakcur60*10^9)+0.5)/1000).."uA L120: "..(math.floor((leakcur120*10^9)+0.5)/1000).."uA")

This is what the script looks like when it’s operating on the 2450 SMU (animated selected still frames):

The code implements the following test logic which also involves logging data to a .csv file if a USB flash drive is attached to the SMU. The graph is based on the data from such a .csv log.

The test begins with first requesting user input the voltage rating of the capacitor (setting the maximum test voltage) and the desired charge/discharge test current. The unit will then run in a constant-voltage mode to draw the capacitor to zero and hold it there for 15 seconds (to try and overcome some dielectric absorption effects which may cause the voltage to “fly up” once the load is removed). The code then proceeds to source a constant current while monitoring the voltage over time – the time between 10% maximum voltage and 90% maximum voltage is used to compute the charging capacitor value. Once the voltage reaches the maximum voltage, the current will fall below 90% of the test current which will begin the 120s leakage test. In this phase, the SMU holds the capacitor at the limit voltage while directly measuring current into the capacitor. The single-point reading at 60s and 120s are used for reporting L60/L120 respectively. Once the leakage test has run for 120s, the capacitor is then discharged at a constant current and the 10-90% voltage timings are used to derive the discharge capacitor value. The average of the charge and discharge capacitor values are used to report the final capacitor value to try and eliminate the effects of leakage on the capacitor value determination.


I’ve tried to make things easier to use by using * to denote a “safe” value to choose and ^ to denote values that require the interlock to be activated on the 2450 SMU. The inputs are not checked for errors though, so hitting cancel will likely result in an error that terminates the script.


Such a logic is not perfect as the current measurement range is tied to the test current selected which impacts on the reported leakage current accuracy. A better way may be to change to SVMI for the leakage test and leave the current range to auto. Point samples also are vulnerable to noise – this is especially true during leakage as the voltage “noise” developed by the SMU can cause the measured current to deviate, sometimes even negatively (e.g. in the initial overshoot). The changing of the SMU from SVMI to SIMV then back to SVMI and use of high-impedance output off modes could cause some relay wear and means the output .csv file is a bit “mixed” (reporting currents/voltages in the same column) and requires some manual intervention. Finally, while the derived values are displayed on the screen, it is not stored to file.


Despite these shortcomings, this little project was mainly to show how an SMU could be used to characterise something as “mundane” as an electrolytic capacitor and also offer a “simpler” and potentially more accurate way to measure capacitor leakage as compared to charging it up on a supply and measuring the voltage periodically by DMM as the loss of charge in the measurement process could introduce significant errors for smaller values of capacitance. It also shows how TSP scripting can be used to automate such processes and calculations.

Testing the same 1000µF 16V capacitor four times at a current of 1mA, the results were 1182, 1182, 1181 and 1182µF and leakage current at 120s was 2.4, 1.8, 1.8, 2.1µA respectively. The results did show some variation which is expected as electrolytic capacitors may be internally affected by previous tests and there will be noise especially for leakage current measurements as the voltage noise effects combine with taking just a single-point sample. Perhaps averaging a few samples for leakage current would provide a more stable result.

The same capacitor was tested at a current of 100µA and reported 1214 and 1205µF with a 120s leakage of 2.6 and 2.3µA. The capacitance values seemed a little higher under this condition despite cancelling the leakage current by averaging charge and discharge capacities, but not significantly so. The leakage current values are broadly in line with the previous tests which is a good result. The 60s leakage however, varies quite significantly being in the 4-5µA range previously and being in the 3-4µA range in this test. Perhaps multiple tests are actually improving the capacitor leakage by providing it an opportunity to fully form its oxide layers.

Running the same capacitor at 100µA again, but this time limiting the test voltage to 6.3V, shows the effect reducing voltage has on reducing capacitor leakage. The 120s leakage values for the three runs were 0.173, 0.171 and 0.279µA respectively, or about 10% of the leakage at 16V.

Of course, I recommend you use the script at your own risk and don’t just blindly trust whatever comes out of it – I managed to receive a negative leakage current reading when testing at 10mA, likely because of reading a single point sample of noise especially with the more limited accuracy operating in the 10mA range compared to 100µA.



The Keithley 2450 SMU can be used to measure certain parameters of electrolytic capacitors, including the capacitor value, leakage current and forming voltage. KickStart 2’s I-V Characterizer module can be used in the “Current Bias” mode to do simple data collection for determining capacitor value (roughly), leakage current and forming voltage without requiring any specific coding. The graph axes can be rearranged from the default I-V view to a V/I-vs-Time view for a more sensible view. Unfortunately, this solution doesn’t have the best convenience as it doesn’t discharge a capacitor prior to test and after testing.


Luckily, Keithley provides powerful TSP scripting capabilities which allows users to create their own test programs which run on the SMU directly. Using the TestScriptBuilder environment, I developed the ElectroCapCheck script which automates the pre-discharge, testing for capacitor value (charge and discharge) and leakage current with USB logging option and direct value read-out on the screen. As it runs on the SMU itself, it takes advantage of the full speed of the measurement system of the SMU with high-precision timestamps and does not require a host to run.


Throughout the tests, I learned that my fresh capacitors had great leakage current values and that the voltage headroom of electrolytic capacitors seems to vary depending on manufacturer (but only tested a sample of one from each). The headroom doesn’t quite reach to the next voltage “bin” at the 100µA leakage level. I also found that the script produced relatively good results in general, but was vulnerable to noise in the leakage current readings especially when using higher current ranges as the returned result is a single-point reading which may be affected by source voltage noise as well. Finally, it’s important to know what you are measuring, as the 2-wire front-panel banana jack test leads were no match for the low-leakage of my polyester film capacitors – what I was measuring was the insulation resistance of the leads and potentially the capacitor that formed between the leads, rather than the (small) MKT capacitor on the other end. This is where a proper guarded triax setup would have been able to make the difference, as the specifications for the 10/100nA range require the use of the rear triax connections. In all, this was quite a bit of fun playing around with a relatively humble passive component, albeit one with potentially explosive tendencies.