Skip to content
GitLab
Projects Groups Topics Snippets
  • /
  • Help
    • Help
    • Support
    • Community forum
    • Submit feedback
  • Register
  • Sign in
  • S sdv-lammps
  • Project information
    • Project information
    • Activity
    • Labels
    • Members
  • Repository
    • Repository
    • Files
    • Commits
    • Branches
    • Tags
    • Contributor statistics
    • Graph
    • Compare revisions
  • Issues 100
    • Issues 100
    • List
    • Boards
    • Service Desk
    • Milestones
  • Merge requests 0
    • Merge requests 0
  • CI/CD
    • CI/CD
    • Pipelines
    • Jobs
    • Schedules
  • Deployments
    • Deployments
    • Environments
    • Releases
  • Packages and registries
    • Packages and registries
    • Package Registry
    • Container Registry
    • Terraform modules
  • Monitor
    • Monitor
    • Metrics
    • Incidents
  • Analytics
    • Analytics
    • Value stream
    • CI/CD
    • Repository
  • Wiki
    • Wiki
  • Snippets
    • Snippets
  • Activity
  • Graph
  • Create a new issue
  • Jobs
  • Commits
  • Issue Boards
Collapse sidebar
  • djurado
  • sdv-lammps
  • Wiki
  • Home

Home · Changes

Page history
Update Home authored Jan 11, 2023 by djurado's avatar djurado
Hide whitespace changes
Inline Side-by-side
Home.md
View page @ 12c5cbe3
...@@ -16,52 +16,6 @@ The input contains two files: ...@@ -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). - `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 - `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.
![flowchart](uploads/2c10a18b3cda9496b9eaed9e54e001db/flowchart.png)
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 # 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. 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.
......
Clone repository

Home

Overview