If EIRENE is going to run bigger simulations, domain decomposition is
necessary, both for scale and performance.

 From my experience with Eiron, what we need is, at minimum:

1. Design two data structures: particle state and simulation context

1.1 The particle state is the current task
  - position, velocity
  - species id
  - monte carlo parameters
  - random numbers generated for this particle (need to find position in
rng stream)

1.2 The simulation context contains all resources for a task
     - the background grid of current subdomain
     - collision process data for the current particle species
     - tally grids for the current particle of current subdomain

2. Simulation must be modeled as a function
  particle_state <- f(particle state, simulation context)

3. All ranks need a lookup table from (subdomain,species) to sim context

4. Particle state must be sent from rank to rank
  - sent when particle leaves subdomain (have to detect this)
  - receive new particle when old task is done

5. A single rank has to be in charge of generating particles from one
source (stratum?). When a particle is terminated, it must notify the
rank that generated the particle
  - otherwise we won't know when the simulation is over, the original
sender keeps count of generated and terminated particles

6. A random number generation scheme where each particle gets its own
random number seed
  - can be as simple as seed_k = seed_global + k

7. A way to split and join the grid
8. A way to distribute and reduce the grid


Some other features will also be necessary for scaling up, but not for a
proof of concept, let's call these advanced features:

Advanced A: In order to load balance the domain decomposed simulations,
we will also need:
  - to assign multiple ranks to the same subdomain to balance the load
  - to always send particle state to the same rank for a particle
id,subdomain pair (if we want the variance calculation to be correct)

Advanced B: Memory on a single node will eventually run out, and the
subdomain grids will have to be initialized independently, without first
constructing the full grid, we have to read the input files and
construct many partial grids in memory


Questions:

  - How would we implement the minimum requirements in EIRENE given its
current state? What changes would need to be made?
  -  How much work would this be? Which tasks would be most difficult to
pull off?
  - Partial answers are ok, don't have to solve everything in one go
  - If we have time, how would the more advanced features be implemented?