There is one permanent master(-2) node that encompasses all of the domains

There are multiple domain (-1) nodes that may or may not be static depending on implementation.  
  Physically they won't move but the master node may distribute them to different processors depending on their subtree costs

There is at least one root grid (0) node per domain and there may be more if they are artificially fragmented to aid parallelization
  These may or may not physically move - but again their processor assignments may.
  These only take one step before being ready to regrid.

There are multiple level 1 nodes that exist for two steps

There are multiple level 2 nodes that exist for two steps.

and so on...




Let's assume for the moment that only the master node (-2) is truly static.

Then it creates -1 nodes once each step.  
So its children get neighbors from siblings.
And its children get overlaps from old children.
And its old children get overlaps from new children
It itself has no overlaps (but may have neighbors if periodic...)
so its children should get neighbors from its neighbors children

I prefer to age children immediately before creating newer ones...


Now -1 nodes are created fresh each step
So it never has old children
And its children only take one step
So its children get neighbors from siblings
and its children get overlaps from its overlaps children
and its children get neighbors from its neighbors children

And it gets aged and throws away its overlaps and neighbors
It then gets new overlaps from its parent
And then share children with its new overlaps
And send children new overlaps
And then gets destroyed


Now level 0 nodes are created fresh each step
So it too never has old children
And its children take two steps
So its children get neighbors from siblings
and its children get overlaps from its overlaps children
and its children get neighbors from its neighbors children

Then it gets aged and throws away its overlaps and neighors
It then gets new overlaps from its parent
so that it can send data to its new overlaps
And share children with its new overlaps
And send children new overlaps
And then gets destroyed


Now level 1 nodes are created fresh every other step
So its children always get neighbors from siblings
And the first time its children get overlaps from its overlaps children
And its children get neighbors from its neighbors children

Then at the start of the second step - it throws away its overlaps 
                                        copies its current neighbors to its overlaps
So now it ages its children
So its second children still get neighbors from siblings
But now get overlaps from its old children
And updates its old children with overlaps from the new children
And its children get additional overlaps from its overlaps (neighbors) ***OLD*** children
And its children get neighbors from its neighbors children

Then it gets aged and throws away its overlaps and neighbors
It then gets new overlaps from its parent
So that it can send data to its new overlaps
And share children with its new overlaps
And send children new overlaps
And then gets destroyed


Initially we want it to be as though we've finished......
So no old children
no old nodes
no overlaps or neighbors







Now what if we want the baselevel to be -1 or 0?  
If we have one domain or if we are running on one processsor then there will be only baselevel grid.
However if we are running in fixed grid with one domain then we can have multiple baselevelg girds,
but they will have no children to communicate with other base level grids.



Neighbor and Overlaps are constant on the baselevel

AgeNodesChildren() - !Should we also age external baselevel nodes children?  Probably - we do

The assumption is that we have our overlaps/neighbors previous children we have - since they would have sent them
on the previous step...

So our baselevel neighbors children need to be initially communicated, saved, & restored

They are initially communicated