| ... | ... | @@ -16,52 +16,6 @@ The input contains two files: |
|
|
|
- `pair_style lj/charmm/coul/long 8.0 10.0` This is the line that specifies that we are using the *lj/charmm/coul/charmm* *pair_style*. If a different *pair_style* was selected, then `PairLJCharmmCoulLong::compute` would not be executed, and the optimizations would not have any impact. Moreover, the `8.0`and `10.0` represent the *cutoff distances*, which can have an impact to the execution of the function. For more information, check the LAMMPS [documentation](https://docs.lammps.org/pair_charmm.html#pair-style-lj-charmm-coul-long-command).
|
|
|
|
- `data.protein`: contains the initial data for the atoms in the simulation and their properties
|
|
|
|
|
|
|
|
# Overview of Algorithm and Data structures
|
|
|
|
|
|
|
|
LAMMPS computes interactions between atoms.
|
|
|
|
If a pair of atoms are "neighbors" (that is, the distance between them is smaller than the *pair_style* cutoff distance), it produces a *short-range* interaction in real space and is computed using a *pair_style*.
|
|
|
|
If atoms aren't within the cutoff distance, these become *long-range* interactions in reciprocal space (FFT domain).
|
|
|
|
The `PairLJCharmmCoulLong::compute` computes short-range interactions.
|
|
|
|
|
|
|
|
File `neigh_list.h` contains the `int **firstneigh` array.
|
|
|
|
Note that the `**` denotes that it is a double pointer or pointer to pointer.
|
|
|
|
In other words, `int **firstneigh` is a pointer to an array of pointers to arrays of `int`.
|
|
|
|
|
|
|
|
`firstneigh[i]` contains an array of the atoms `j` that are neighbors of atom `i`.
|
|
|
|
In this protein input, there are 32.000 `i` atoms.
|
|
|
|
For example, `firstneigh[i][0]` would be the first neighbor of atom `i`.
|
|
|
|
Both `i` and `j` are atom identifiers, and are represented using a 32-bit `int`.
|
|
|
|
To retrieve the properties of an atom, this `int` value needs to be used as an index for the arrays found in file `atom_vec.h` or `atom.h` such as `double **x` (position), `**f` (force) or `*q` (charge).
|
|
|
|
`x` and `f` are pointer to pointer since the second index in needed to split the magnitudes in XYZ components.
|
|
|
|
|
|
|
|
Function `PairLJCharmmCoulLong::compute` has an inner and an outer for loop.
|
|
|
|
The outer loop (i-loop) iterates through all 32.000 atoms in the protein simulation, while the inner loop (j-loop) iterates through each atom `j` that is a neighbor of `i`.
|
|
|
|
|
|
|
|
For each pair of atoms `i, j`, the algorithm first computes the distance between the two atoms.
|
|
|
|
Then, the distance is compared to different values which act as a threshold.
|
|
|
|
|
|
|
|
In the input line `pair_style lj/charmm/coul/long X Y`, `X` is `cut_lj_innersq` and Y is both `cut_ljsq` and `cut_coulsq`.
|
|
|
|
The alternative form with `X Y Z` parameters ([see](https://docs.lammps.org/pair_charmm.html#pair-style-lj-charmm-coul-long-command)) is not supported by the optimized function and falls back on the LAMMPS vanilla function.
|
|
|
|
`tabinnersq` can be modified using the `pair_modify table N`, altough its effects have not been explored in this study.
|
|
|
|
|
|
|
|
These values always follow:
|
|
|
|
- `cut_lj_innersq < cut_ljsq`
|
|
|
|
- `tabinnersq < cut_coulsq`
|
|
|
|
- `cut_ljsq = cut_coulsq` (only in optimized function)
|
|
|
|
- `cut_bothsq = MIN(cut_ljsq, cut_coulsq)`
|
|
|
|
|
|
|
|
In the code, `rsq` represents the distance between atoms `i,j`. It is saved in squared form to avoid computing an expensive `sqrt`.
|
|
|
|
- If `rsq` is larger than `cut_bothsq`, then, no computation is required because there is no short-range interaction between the two atoms. In that case, the inner loop iteration stops here (*do nothing*).
|
|
|
|
- If `rsq` is smaller than `tabinnersq`, then `forcecoul` is computed using a *fast* table method. If not, it is computed using a *slow* method with calls to `sqrt` and `exp` functions.
|
|
|
|
- If `rsq` is bigger than `cut_lj_innersq`, then `forcelj` needs a few additional computations.
|
|
|
|
|
|
|
|
The following flowchart shows the different cases based on `rsq`.
|
|
|
|
The condition on `forcelj`is not shown in order to focus on the `tabinnersq` condition.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
At the end, the code uses the computed `forcelj` and `forcecoul` values to update the `f` (force) values for both atoms `i` and `j`.
|
|
|
|
|
|
|
|
# Implementation
|
|
|
|
|
|
|
|
In this section we discuss the implementation of the optimized `PairLJCharmmCoulLong::compute` function, with a focus on the issues that presented when adapting the code for the RISC-V 0.7 scalable vector extension and how have been overcame.
|
| ... | ... | |
