Efficient search for interacting particles

[RudolfWeeber]

Currently the search for (short-range) interacting particles, e.g., in the reaction ensemble, is n-square, as all other particles in the system are considered. This is not necessary when the cell system is a regular domain decomposition.

Objectives:

• Provide a function template in CellStructure that can execute a given kernel function on all particles within the short-range interaction range of a given particle p.
• Using that, implement a kernel that collects the ids of the particles in the neighborhood of p.
• In the same way, implement a kernel calculating the short range energy contribution of a particle with its neighbors
• Implement python interface functions for those two cases

Implement CellStructure::run_on_particle_short_range_neighbors

This should take a kernel and a particle, i.e.,

template <typename Kernel> 
bool run_on_particle_short_range_neighbors(const Particle& p) 

Steps:

• Identify the cell in which the particle is stored using particle_to_cell (It might be necessary to use the position at the last resort, which is also in p.r).
• If a nullptr is returned, the particle should not be on the mpi rank. Return false
• For the returned cell:
  • iterate over the particles in the cell itself (cell.particles()
  • Iterate over neighboring cells, both in in red_neighbors and black_neighbors (see Cell.hpp). Iterate over the particles in those neighboring cells
  • For all these particles, except p itself (compare using addresses, not values), run kernel(p)
• Return true

Implement get_short_range_neighbors(const Particle& p) in cells.cpp/hpp

• Initialize a std::vector<int> to store the particle ids.
• As kernel, to CellStrucutre.run_on_particle_short_range_neighbors(), use a lambda [&result_vector](const Particle& p) which appends the particle id to the result vector. See the get_pairs code in cells.cpp for inspiration

Implement particle_short_range_energy_contribution(const Particle& p) in energy.cpp/hpp

Same as above, but

• use a double as result type
• Capture the Particle p in the lambda [&result, &p](const Particle& q)
• In the lamdba, add the pair energy provided by add_non_bonded_pair_energy() (energy_inline.hpp) to the result

Python interface

• You need the head node function called from cython mpi_...
• The callback function (which should return a boost::optional)
• Register the callback via REGISTER_CALLBACK
• The callbacks should be declares such that a result from exactly one mpi rank is expected.
  See get_particle_data_local, corresponding REGISTER_CALLBACK_ONE_RANK and the mpi call in get_particle_data() (below where it says "cache miss") FOR INSPIRATION

[RudolfWeeber]

@stekajack @jhossbach @pm-blanco If you like, you can work on this, tomorrow.

[stekajack]

I can tinker with this, but probably don't manage to get to it today.