Matrix based Tree operations

[gitpeterwind]

This issue is to discuss the implementation of a new way of doing orbital rotations (and also computation of Fock matrix elements).
The main idea is to do the rotation "nodewise": the nodes of all orbitals at a given position are rotated at once. In practice that means the loop over nodes is the outer loop, and the loop over orbitals is the inner loop.
With this procedure, the 0(N²) operations are done as efficient large matrix multiplications, and the tree operations are only required in 0(N) operations.

[gitpeterwind]

I start with an upgrade of the bank with the two routines:
put_blockdata(int id, int blockid, int size, double *data)
get_blockdata(int id, int blockid, int size, double *data)
which will store the coefficients from the orbitals and assemble them in a single block, and send them on demand (individually, or the entire block).
blockid is in practice the node identifier, and id the orbital index.

[stigrj]

What's your starting point, the current tasks branch or master?

[gitpeterwind]

master. But I add some features from tasks, as needed.

[gitpeterwind]

I will now make a routine that make a union grid, mpi::reduce_grid. It will be the same as mpi::reduce_function , but using mrcpp:refine_grid . Also the send_orbital should be replaced by a new send_grid.
The mrcpp:refine_grid and send_grid should eventually be replaced by a a new version that does not include the coefficients.

[gitpeterwind]

If I know the physical position, and nodeindex and other nodeinfo, but not its address, what is the fastest way to retrieve it?
For example getNode(NodeIndex<D> nIdx); or getNode(const Coord<D> &r, int depth = -1); or findNode(NodeIndex<D> nIdx); or something else?
Do they all traverse the tree starting at root, or is there a more direct way to jump directly to the node?

[stigrj]

Currently the only way to retrieve a node is by traversing from the root, and then these two options have slightly different behavior

MWNode<D> &node = tree.getNode(idx);  // this will always return the node you're asking for, i.e. generate if missing
MWNode<D> *node = tree.findNode(idx); // this will never generate new nodes, and returns nullptr if node does not exist

If you know that the idx you're looking for directly descends from another node that you already have, you can start traversing directly from that node to avoid starting from root every time, but this is usually not applicable.

[gitpeterwind]

OK, it is possible to use parent node, but this is probably not so important now.