[Phys-L] capacitor-to-capacitor transfer ... with high efficiency

[John Denker <jsd@av8n.com>]

On 08/06/2014 10:35 AM, I wrote that to properly explain
what is going on would require diagrams.

Well, I drew some diagrams.  I also cobbled up a spreadsheet
that calculates the waveforms and phase-space plots.  Then
I wrote about 3000 words of explanation.  You can find it at:
  http://www.av8n.com/physics/capacitor-transfer.htm

This is new and very drafty, but I reckon it's better than 
figuring out everything out from scratch and drawing your 
own diagrams.

I quote from the abstract and table of contents:

> It is quite possible to transfer energy and charge (or rather gorge) 
> from one capacitor to another with high efficiency. The 
> energy-transfer efficiency can approach 100%, and the gorge-transfer 
> efficiency can easily exceed 100%. These numbers far surpass the
> limits that are often assumed, “proved”, and/or “explained” in the
> physics education literature. We discuss a simplified version of a
> technique that is very widely used in the electronics industry.

>     1  Introduction 
>     2  RC Scheme 
>     3  LC Scheme : Transfer 
>     4  LC Scheme : Equilibration 
>     5  Implications and Ramifications 
>     6  Pedagogical Remarks 
>     7  Appendix: Gorge versus Charge 
>     8  References

Also included is a link to the spreadsheet that produces
the plots.

===============

I am reminded of one of my favorite proverbs:
  It is bad luck to prove things that aren't true.

===============

The spreadsheet also provides a constructive answer to the
question that started the recent "LC circuit" thread.

The spreadsheet consists of
 -- the core numerical stuff
 -- a bunch of visualization stuff

In some sense, the core numerical stuff is ridiculously simple.
It consists of little more than typing in the usual equations
for "L" and "C" and then timestepping.  In other words, it is 
first-order Euler.  The accuracy is dramatically improved
because it is a /symplectic/ version of first-order Euler, aka
leapfrog, aka lots of other names.  Remarkably, this does not
require different equations or any additional runtime complexity.
All it requires is doing things in the right order.

It is remarkable that to the untrained eye, the code to do things 
right appears virtually indistinguishable from vastly worse code.

In any case, symplectic first-order Euler is super-convenient and
is more than accurate enough for present purposes.