Move from Atom based topology to array based

[richardjgowers]

This is something @dotsdl and I have been tinkering with. Basically, it's changing the AtomGroup class to be a thin wrapper around a numpy array (rather than a list of Atoms).

The latest benchmark is here:
https://github.com/richardjgowers/atomgroup_olympics/blob/master/types2.ipynb
Dev list discussion:
https://groups.google.com/forum/#!topic/mdnalysis-devel/aHSB-ryCEQ0

We're seeing about 10-30x speedup for most common operations, so I think we can start to think about implementing this. I think this Issue will act as an anchor for sub issues.

I think first thing to do is to make sure that tests currently cover everything, so we're confident that we aren't changing behaviour as we go.

[orbeckst]

+1 (and we probably want this in a pre-1.0 milestone — either 0.12 or a 0.13 — just to make sure that we don't bake something into 1.0 that we haven't fully explored for a while)

[orbeckst]

And more test coverage like #362 is definitely necessary before embarking on this in earnest.
We will also need tests that check in more detail what happens when AtomGroups are changed and how changes propagate.

[kain88-de]

After having to add a new property to the Atom and AtomGroup class I can only say you should make the AtomGroup the base class for everything. I noticed this funny thing that I read a whole array in PrimitivePDBReader and make that accessible via the 'TimeStepobject to theAtomclass. Now remember atom can potentially access all the occupancy from all other atoms in the universe. But the code to access array inAtomGroup` is

@property
def some_metadata(self):
    return np.array([atom.metadata for atom in self.atoms])

This idiomatic code (when Atom it the base of the Topology) has to be slow by design. I iterate over a class container to iterate over an array just to build a shallow copy of said array and return it.

@property
def some_metadata(self):
        return self.ts.data['metadata'][self.atom_idx]

This should result in faster code by design in the end. We don't make hops between array in container classes. It gets much easier to set things correctly at the AtomGroup level. And it helps with the implicit assumption in the Readers that we work on whole frames.