The Major Parts

[tabedzki]

Note: all comments are for the pure field theory version of the code!

Part 1:

Implementing field_gradient from array_utils.cpp and all functions that are invoked underneath, including unstack_stack which maps the local index value to the master index value. Also unstack which takes the global index value and grabs the grid position of that index in all Dim. get_k_alias reorders the aliases.

Where I think LAMMPS orders its grid points: line 1377 in pppm.cpp in a function set_grid_local has an example; another example found in pppm_disp.cpp line 2687. Understanding this is important to both Part 1 and Part 3.

Part 2

Storing interactions and then calling using those in a base framework for compute_group_group. Fourier transforms of particle's densities on the grid should be done in this step after ensuring that they are going to be needed (PPPM scheme). After FFTW, then invoke the compute_group_group command.

How he ultimately uses it is found on lines 40-56 are for A acting on other monomers but provides the base framework to be repeated.

Part 3

Implementing compute_group_group and handling the differences between the grids of FFTW and PPPM scheme for convolution purposes.

in Riggle's code: Interactions are done in forces.cpp. Lines 40-56 are for A acting on other monomers but provides the base framework to be repeated.

Total polymer interactions is on lines 96 - 113 in forces.cpp

Part 4 (Really this should be higher up since this is more important than the other things)

Mapping the densities to the grid and figuring out how to pass in the densities and how to restore forces to the particles. Probably via group name would be best but that's TBD. Person should take inspiration from pppm_disp.cpp

Riggle puts particles on grid in charge_grid().
Interactions are done in forces.cpp.

Apply the nonbonded forces on each particle. Lines 182-219. This is also going to be interesting to apply.

@zvicars @amruthesht

[tabedzki]

The parameter reading is being taken care of since that was one of the most important things in my opinion. They are being stored ina matrix and the code wil loop through all the positions; if there are any variables that are non-zero then it will FT the densities, otherwise, it won't.

[tabedzki]

The initial construction of what I believe the field_gradient and get_k_space functions should be in the new scheme.

Currently working on the FFT scheme for particle densities. The mixing scheme going to be used (there are 3: geometric, arithmetic, and none) is none since Rob said we don't use it. I do not know whether we are going to want to implement all of them eventually but for now let's not.

Also, I think implementing the charges will be easier in the future since the pppm_disp already has functionality for both dispersion forces (based off real density) and charges (based off charge density).

The compute routine will also need to have some work done on it.

[tabedzki]

So the compute routine should be properly set up. This will need some validation.

What still needs to be verified and done are

1. Setting up the grid. There are two sets of distinct routines: one is taken from pppm.cpp and the other from pppm_disp.cpp. The first two are set_grid_global() and set_grid_local(). The first corresponds to set_grid() from pppm_disp and set_fft_parameters corresponds to set_grid_local().

   a) For now set_grid will be set up for the particle mapping. Eventually a second version of that code will have to be implemented in order to do coulombic interactions which we are seeking to do

2. Verifying the particle to mesh routine is done correctly with regards to the grouping. I am going to steal it from other codes that I think implement it but you will need to validate this. The check I am going to try is if (mask[i] & groupbit) found from many different sections in the code. It seems to do the trick.

[tabedzki]

So now that thing have been mostly implemented, I still need to do the following:

1. Ensure that the write variable for pack and unpack. Ensure that communication between the pack and unpack make sense.
2. Need to understand how packing and unpacking works for the GridComm since I don't get how the ghost grid points work and we use a different technique than the other systmes.
3. Also need to work on init()
4. Compute needs to further worked on though forcefield_param can do a lot of the work that we would need.
5. Identify unnecessary functions to get rid of, like field_groups.
6. Add in memory_usage and the timing functions.
7. Fix the brick2fft commands and such.

There's probably more stuff to do but this is the current list of things to do.
The group_group_command should be disabled and removed since there is not going to be an explicit compute group/group command line option available. Instead we have the user list the parameters and then when the compute command executes we cycle through everything.

[tabedzki]

The lammps code can now actually run through the TILD package and execute compute. Something is still wrong since forces are now very large (1e310) before it dies. Nevertheless, the other work previously done is probably successfully achieved. Right now it would be useful if someone were able to integrate over the entire box and see if the integrated value over the box equals the same value as the actual starting density. Like for one chain seeing where the system ends up and which values of the box are populated.