How can I compute any electron - electron interactions I was
interested in understanding, with perfect precision, in a very quick
manner?  I would like to be able to perfectly model and predict any
arbitrarily large protein system.  Ideally, I want to model 1+ million
atom systems for periods of 1 second with computation time taking no
more than a day or two running on a single p4 system.  Preferably
provide an explanation and source code.

If a single P4 system not a realistic possibility for such
calculations, please detail what hypothetical computer architecture
and method that could calculate such an atomic system.  (i.e. how much
horsepower would that take, and how does this compare to current
supercomputing technologies? What mathematic methods would be used to
represent atoms?)

If 1 million is too large in terms of atoms, please describe a system
with the capability of perfectly predicting a single protein.

Thanks!

John

---

Clarification of Question by johnwhitlow-ga on 10 Sep 2005 20:26 PDT

Umm, yes, if this requires specific hardware to run, if you can ship
me a working unit, I'll double the $200 payment.

I am not a theoretical chemist, but even I know that what you are
suggesting is absurd:
1) Electron-electron interactions is one of the most difficult
problems of quantum mechanics. No exact solution for such systems
exists. Hence, there's no way to calculate them "with perfect
precision".
2) The best level on theory that you can hope for is usually labeled
ab initio. An example would be Density Functional Theory. However, in
such methods of calculation, the computational time rises
exponentially with the number of electrons. Calculating a million
atoms with, say, 6-10 electrons per atom on average, with the
currently existing hardware, would most likely take longer than the
age of the universe (just a wild guess here).
3) Protein structure calculations are usually carried out with a
method called Molecular Mechanics. It's an empirical method, which
gives decent results with respect to atom positions and dynamics.
Several commerical suites of sofware exist, and I think you should be
able to google some of the freeware ones. However, one million atoms
still sounds a little too much and would probably require a
supercomputer.

Modeling the structure of proteins is one of the unsolved "grand
challenge" problems of computational chemistry.  Check out
http://researchweb.watson.ibm.com/journal/sj/402/allen.html,
especially Table 1.  There, it is estimated that a petaflop/sec
computer (which is about an order of magnitude faster than the fastest
existing supercomputer) would require ~3 years to simulate ~100
microseconds of protein folding using *classical* molecular dynamics. 
"Classical" means no quantum mechanical calculations of electronic
energy levels; one would simply be using empirical force fields
assigned to each atom and using Newtonian mechanics to model the
evolution of the system.

Actually, the answer is very simple, even if probably not what
expected. As the other commenters pointed out, it is simply
impossible. There is no exact solution for any sistem with more than
one electron, and any approximate calculation for a system of the
complexity outlined and for time span requested will not probably
benefit even of future quantum computers.
The best we can do, at present, is to model the (small) most
interesting part of the system with quantum mechanics/DFT, and the
remaining part with molecular mechanics (no electrons allowed).

A graduate student in theoretical chemistry has told me that I've made
a mistake earlier. DFT is not an ab initio level of theory. Its
computation time rises with the number of electrons almost linerly: t
~ N^1.3 according to that man. However, when asked how much time would
be reqired to do a one million atom system similar to a protein by
DFT, his answer was "maybe forever". :)

I can't believe that you're actually serious about this question. 
Since you apparently know enough to formulate an accurate and
descriptive question, I seriously doubt that you're completely
ignorant of the massive computational requirements.

I've done a bit of this work (both QM and MD simulations) with small
(~5000 atom) proteins.  Doing a QM energy calculation of a small
organic molecule (~25 atoms) with a reasonable level of theory
(HF/6-31G** w/ B3LYP) with Gaussian(tm) takes about 10 minutes on a
single 2GHz P4.  Other programs/hardware will vary, but not by much
more than an order of magnitude.  But computation time increases
exponentially with system size, so my guess is that it would take
about 1 CPU-year to do a single energy calculation of a
multi-megadalton protein.  And it would probably take several hundred
gigabytes of RAM to do so.

And this is just a single energy calculation.  It's not even a
geometry optimization, nor anything even close to dynamics (which is
what you're asking).  Thus far, the only way to do dynamics is to skip
the QM and treat the system through Newtonian approximations: bonds
are springs, atoms are point charges, etc.  You can do a single
timestep of a 10k atom system in about 15 CPU seconds on a 2GHz P4. 
Increasing the system size in MD doesn't have quite the exponential
calculation penalty that QM does (because it assumes geometric cutoffs
for the interactions; eg, anything farther than 15 angstroms away
doesn't affect the atom you're looking at), but it's still a decent
penalty.  Figure maybe, 30 CPU-minutes per timestep if you have a 1e6
atom protein with solvent (implicit or explicit).  But the big hit
here is that you're calculating many, many timesteps for dynamics. 
Standard procedure is 1 fs timesteps, though you might be able to get
away with 2 fs if you don't care so much about accuracy (and your
hydrogens behave nicely).  So that means you're calculating 1e15
timesteps to get a full second of dynamics.  The longest simulations
ever done to date are on the order of a few milliseconds, and those
take months with a small protein.  You're looking at a good couple of
years to do a full second of dynamics for a small protein, and maybe a
decade for a large protein system.  And this isn't even taking the QM
into account.

Finally, even if you decide you can commit the computational resources
to doing a 10-year-long calculation, there's the matter of getting a
computer system that will actually run for that long.  That's roughly
316 million seconds of computational time.  Even if your system has
99.999% uptime, you'll still suffer about an hour of downtime per
compute node during those 10 years.  And trust me, MPI (which serves
as the multiprocessor platform for most computational chemistry
programs) is not exactly designed to be fault tolerant.  Losing one
node will probably cause the entire program to crash.

IBM's Blue Gene project is trying something along the lines of what
you want, but they're a lot more realistic than your parameters.