Merge pull request #3446 from akohlmey/next-patch-release

Update versions strings for the next patch release

.github/CODEOWNERS

@@ -13,20 +13,21 @@ lib/kim/*             @ellio167
 lib/mesont/*          @iafoss
 
 # whole packages
+src/AMOEBA/*          @sjplimp
 src/COMPRESS/*        @rbberger
 src/GPU/*             @ndtrung81
 src/KOKKOS/*          @stanmoore1
 src/KIM/*             @ellio167
 src/LATTE/*           @cnegre
-src/MESSAGE/*         @sjplimp
 src/MLIAP/*           @athomps
 src/SNAP/*            @athomps
 src/SPIN/*            @julient31
 src/BROWNIAN/*        @samueljmcameron
 src/CG-DNA/*          @ohenrich
-src/CG-SDK/*          @akohlmey
+src/CG-SPICA/*        @yskmiyazaki
 src/COLVARS/*         @giacomofiorin
 src/DIELECTRIC/*      @ndtrung81
+src/ELECTRODE/*       @ludwig-ahrens
 src/FEP/*             @agiliopadua
 src/ML-HDNNP/*        @singraber
 src/INTEL/*           @wmbrownintel
@@ -133,6 +134,7 @@ tools/coding_standard/* @rbberger
 tools/valgrind/*      @akohlmey
 tools/swig/*          @akohlmey
 tools/offline/*       @rbberger
+tools/vim/*           @hammondkd
 
 # tests
 unittest/*            @akohlmey @rbberger

.github/workflows/compile-msvc.yml

@@ -3,7 +3,11 @@ name: "Native Windows Compilation and Unit Tests"
 
 on:
   push:
-    branches: [develop]
+    branches:
+      - develop
+  pull_request:
+    branches:
+      - develop
 
   workflow_dispatch:
 

.github/workflows/coverity.yml

@@ -0,0 +1,103 @@
+name: "Run Coverity Scan"
+
+on:
+  schedule:
+    - cron: "0 0 * * FRI"
+
+  workflow_dispatch:
+
+jobs:
+  analyze:
+    name: Analyze
+    if: ${{ github.repository == 'lammps/lammps' }}
+    runs-on: ubuntu-latest
+    container:
+      image: lammps/buildenv:ubuntu20.04
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+      with:
+        fetch-depth: 2
+
+    - name: Create Build and Download Folder
+      run: mkdir build download
+
+    - name: Cache Coverity
+      id: cache-coverity
+      uses: actions/cache@v3
+      with:
+        path: ./download/
+        key: ${{ runner.os }}-download-${{ hashFiles('**/coverity_tool.*') }}
+
+    - name: Download Coverity if necessary
+      if: steps.cache-coverity.outputs.cache-hit != 'true'
+      working-directory: download
+      run: |
+        wget -nv https://scan.coverity.com/download/linux64 --post-data "token=${{ secrets.COVERITY_TOKEN }}&project=LAMMPS" -O coverity_tool.tgz
+        wget -nv https://scan.coverity.com/download/linux64 --post-data "token=${{ secrets.COVERITY_TOKEN }}&project=LAMMPS&md5=1" -O coverity_tool.md5
+        echo " coverity_tool.tgz" >> coverity_tool.md5
+        md5sum -c coverity_tool.md5
+
+    - name: Setup Coverity
+      run: |
+        tar xzf download/coverity_tool.tgz
+        ln -s cov-analysis-linux64-* coverity
+
+    - name: Configure LAMMPS via CMake
+      shell: bash
+      working-directory: build
+      run: |
+        cmake \
+        -C ../cmake/presets/clang.cmake \
+        -C ../cmake/presets/most.cmake \
+        -C ../cmake/presets/kokkos-openmp.cmake \
+        -D CMAKE_BUILD_TYPE="RelWithDebug" \
+        -D CMAKE_TUNE_FLAGS="-Wall -Wextra -Wno-unused-result" \
+        -D BUILD_MPI=on \
+        -D BUILD_OMP=on \
+        -D BUILD_SHARED_LIBS=on \
+        -D LAMMPS_SIZES=SMALLBIG \
+        -D LAMMPS_EXCEPTIONS=off \
+        -D PKG_MESSAGE=on \
+        -D PKG_MPIIO=on \
+        -D PKG_ATC=on \
+        -D PKG_AWPMD=on \
+        -D PKG_BOCS=on \
+        -D PKG_EFF=on \
+        -D PKG_H5MD=on \
+        -D PKG_INTEL=on \
+        -D PKG_LATBOLTZ=on \
+        -D PKG_MANIFOLD=on \
+        -D PKG_MGPT=on \
+        -D PKG_ML-PACE=on \
+        -D PKG_ML-RANN=on \
+        -D PKG_MOLFILE=on \
+        -D PKG_NETCDF=on \
+        -D PKG_PTM=on \
+        -D PKG_QTB=on \
+        -D PKG_SMTBQ=on \
+        -D PKG_TALLY=on \
+        ../cmake
+
+    - name: Run Coverity Scan
+      shell: bash
+      working-directory: build
+      run: |
+        export PATH=$GITHUB_WORKSPACE/coverity/bin:$PATH
+        cov-build --dir cov-int cmake --build . --parallel 2
+
+    - name: Create tarball with scan results
+      shell: bash
+      working-directory: build
+      run: tar czf lammps.tgz cov-int
+
+    - name: Upload scan result to Coverity
+      shell: bash
+      run: |
+        curl --form token=${{ secrets.COVERITY_TOKEN }} \
+             --form email=${{ secrets.COVERITY_EMAIL }} \
+             --form file=@build/lammps.tgz \
+             --form version=${{ github.sha }} \
+             --form description="LAMMPS automated build" \
+             https://scan.coverity.com/builds?project=LAMMPS

.github/workflows/unittest-macos.yml

@@ -3,7 +3,11 @@ name: "Unittest for MacOS"
 
 on:
   push:
-    branches: [develop]
+    branches:
+      - develop
+  pull_request:
+    branches:
+      - develop
 
   workflow_dispatch:
 
@@ -39,6 +43,7 @@ jobs:
       working-directory: build
       run: |
         ccache -z
+        python3 -m pip install numpy
         python3 -m pip install pyyaml
         cmake -C ../cmake/presets/clang.cmake \
               -C ../cmake/presets/most.cmake \

cmake/CMakeLists.txt

@@ -135,13 +135,11 @@ set(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "Use compiler extensions")
 # ugly hacks for MSVC which by default always reports an old C++ standard in the __cplusplus macro
 # and prints lots of pointless warnings about "unsafe" functions
 if(MSVC)
-  if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+  if((CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") OR (CMAKE_CXX_COMPILER_ID STREQUAL "Intel"))
     add_compile_options(/Zc:__cplusplus)
     add_compile_options(/wd4244)
     add_compile_options(/wd4267)
-    if(LAMMPS_EXCEPTIONS)
-      add_compile_options(/EHsc)
-    endif()
+    add_compile_options(/EHsc)
   endif()
   add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
 endif()
@@ -378,6 +376,7 @@ pkg_depends(DIELECTRIC EXTRA-PAIR)
 pkg_depends(CG-DNA MOLECULE)
 pkg_depends(CG-DNA ASPHERE)
 pkg_depends(ELECTRODE KSPACE)
+pkg_depends(EXTRA-MOLECULE MOLECULE)
 
 # detect if we may enable OpenMP support by default
 set(BUILD_OMP_DEFAULT OFF)

cmake/Modules/LAMMPSUtils.cmake

@@ -110,14 +110,16 @@ function(FetchPotentials pkgfolder potfolder)
       math(EXPR plusone "${blank}+1")
       string(SUBSTRING ${line} 0 ${blank} pot)
       string(SUBSTRING ${line} ${plusone} -1 sum)
-      if(EXISTS ${LAMMPS_POTENTIALS_DIR}/${pot})
+      if(EXISTS "${LAMMPS_POTENTIALS_DIR}/${pot}")
         file(MD5 "${LAMMPS_POTENTIALS_DIR}/${pot}" oldsum)
       endif()
       if(NOT sum STREQUAL oldsum)
-        message(STATUS "Checking external potential ${pot} from ${LAMMPS_POTENTIALS_URL}")
-        file(DOWNLOAD "${LAMMPS_POTENTIALS_URL}/${pot}.${sum}" "${CMAKE_BINARY_DIR}/${pot}"
+        message(STATUS "Downloading external potential ${pot} from ${LAMMPS_POTENTIALS_URL}")
+        string(MD5 TMP_EXT "${CMAKE_BINARY_DIR}")
+        file(DOWNLOAD "${LAMMPS_POTENTIALS_URL}/${pot}.${sum}" "${CMAKE_BINARY_DIR}/${pot}.${TMP_EXT}"
           EXPECTED_HASH MD5=${sum} SHOW_PROGRESS)
-        file(COPY "${CMAKE_BINARY_DIR}/${pot}" DESTINATION ${LAMMPS_POTENTIALS_DIR})
+        file(COPY "${CMAKE_BINARY_DIR}/${pot}.${TMP_EXT}" DESTINATION "${LAMMPS_POTENTIALS_DIR}")
+        file(RENAME "${LAMMPS_POTENTIALS_DIR}/${pot}.${TMP_EXT}" "${LAMMPS_POTENTIALS_DIR}/${pot}")
       endif()
     endforeach()
   endif()

cmake/Modules/Packages/MDI.cmake

@@ -8,8 +8,8 @@ option(DOWNLOAD_MDI "Download and compile the MDI library instead of using an al
 
 if(DOWNLOAD_MDI)
   message(STATUS "MDI download requested - we will build our own")
-  set(MDI_URL "https://github.com/MolSSI-MDI/MDI_Library/archive/v1.4.1.tar.gz" CACHE STRING "URL for MDI tarball")
-  set(MDI_MD5 "f9505fccd4c79301a619f6452dad4ad9" CACHE STRING "MD5 checksum for MDI tarball")
+  set(MDI_URL "https://github.com/MolSSI-MDI/MDI_Library/archive/v1.4.11.tar.gz" CACHE STRING "URL for MDI tarball")
+  set(MDI_MD5 "3791fe5081405c14aac07d4687f1cc58" CACHE STRING "MD5 checksum for MDI tarball")
   mark_as_advanced(MDI_URL)
   mark_as_advanced(MDI_MD5)
   enable_language(C)

cmake/presets/clang.cmake

@@ -3,6 +3,13 @@
 # prefer flang over gfortran, if available
 find_program(CLANG_FORTRAN NAMES flang gfortran f95)
 set(ENV{OMPI_FC} ${CLANG_FORTRAN})
+get_filename_component(_tmp_fc ${CLANG_FORTRAN} NAME)
+if (_tmp_fc STREQUAL "flang")
+  set(FC_STD_VERSION "-std=f2018")
+  set(BUILD_MPI OFF)
+else()
+  set(FC_STD_VERSION "-std=f2003")
+endif()
 
 set(CMAKE_CXX_COMPILER "clang++" CACHE STRING "" FORCE)
 set(CMAKE_C_COMPILER "clang" CACHE STRING "" FORCE)
@@ -10,9 +17,9 @@ set(CMAKE_Fortran_COMPILER ${CLANG_FORTRAN} CACHE STRING "" FORCE)
 set(CMAKE_CXX_FLAGS_DEBUG "-Wall -Wextra -g" CACHE STRING "" FORCE)
 set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-Wall -Wextra -g -O2 -DNDEBUG" CACHE STRING "" FORCE)
 set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG" CACHE STRING "" FORCE)
-set(CMAKE_Fortran_FLAGS_DEBUG "-Wall -Wextra -g -std=f2003" CACHE STRING "" FORCE)
-set(CMAKE_Fortran_FLAGS_RELWITHDEBINFO "-Wall -Wextra -g -O2 -DNDEBUG -std=f2003" CACHE STRING "" FORCE)
-set(CMAKE_Fortran_FLAGS_RELEASE "-O3 -DNDEBUG -std=f2003" CACHE STRING "" FORCE)
+set(CMAKE_Fortran_FLAGS_DEBUG "-Wall -Wextra -g ${FC_STD_VERSION}" CACHE STRING "" FORCE)
+set(CMAKE_Fortran_FLAGS_RELWITHDEBINFO "-Wall -Wextra -g -O2 -DNDEBUG ${FC_STD_VERSION}" CACHE STRING "" FORCE)
+set(CMAKE_Fortran_FLAGS_RELEASE "-O3 -DNDEBUG ${FC_STD_VERSION}" CACHE STRING "" FORCE)
 set(CMAKE_C_FLAGS_DEBUG "-Wall -Wextra -g" CACHE STRING "" FORCE)
 set(CMAKE_C_FLAGS_RELWITHDEBINFO "-Wall -Wextra -g -O2 -DNDEBUG" CACHE STRING "" FORCE)
 set(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG" CACHE STRING "" FORCE)

doc/lammps.1

@@ -1,7 +1,7 @@
-.TH LAMMPS "1" "3 August 2022" "2022-8-3"
+.TH LAMMPS "1" "15 September 2022" "2022-9-15"
 .SH NAME
 .B LAMMPS
-\- Molecular Dynamics Simulator.  Version 3 August 2022
+\- Molecular Dynamics Simulator.  Version 15 September 2022
 
 .SH SYNOPSIS
 .B lmp

doc/src/Bibliography.rst

@@ -1373,7 +1373,7 @@ Bibliography
    Zhu, Tajkhorshid, and Schulten, Biophys. J. 83, 154 (2002).
 
 **(Ziegler)**
-   J.F. Ziegler, J. P. Biersack and U. Littmark, "The Stopping and Range of Ions in Matter," Volume 1, Pergamon, 1985.
+   J.F. Ziegler, J. P. Biersack and U. Littmark, "The Stopping and Range of Ions in Matter", Volume 1, Pergamon, 1985.
 
 **(Zimmerman2004)**
    Zimmerman, JA; Webb, EB; Hoyt, JJ;. Jones, RE; Klein, PA; Bammann, DJ, "Calculation of stress in atomistic simulation." Special Issue of Modelling and Simulation in Materials Science and Engineering (2004),12:S319.

doc/src/Commands_all.rst

@@ -15,7 +15,9 @@
 General commands
 ================
 
-An alphabetic list of general LAMMPS commands.
+An alphabetic list of general LAMMPS commands.  Note that style
+commands with many variants, can be more easily accessed via the small
+table above.
 
 .. table_from_list::
    :columns: 5
@@ -61,6 +63,7 @@ An alphabetic list of general LAMMPS commands.
    * :doc:`kspace_modify <kspace_modify>`
    * :doc:`kspace_style <kspace_style>`
    * :doc:`label <label>`
+   * :doc:`labelmap <labelmap>`
    * :doc:`lattice <lattice>`
    * :doc:`log <log>`
    * :doc:`mass <mass>`

doc/src/Commands_bond.rst

@@ -44,6 +44,7 @@ OPT.
    * :doc:`harmonic (iko) <bond_harmonic>`
    * :doc:`harmonic/shift (o) <bond_harmonic_shift>`
    * :doc:`harmonic/shift/cut (o) <bond_harmonic_shift_cut>`
+   * :doc:`mesocnt <bond_mesocnt>`
    * :doc:`mm3 <bond_mm3>`
    * :doc:`morse (o) <bond_morse>`
    * :doc:`nonlinear (o) <bond_nonlinear>`
@@ -92,6 +93,7 @@ OPT.
    * :doc:`fourier/simple (o) <angle_fourier_simple>`
    * :doc:`gaussian <angle_gaussian>`
    * :doc:`harmonic (iko) <angle_harmonic>`
+   * :doc:`mesocnt <angle_mesocnt>`
    * :doc:`mm3 <angle_mm3>`
    * :doc:`quartic (o) <angle_quartic>`
    * :doc:`spica (o) <angle_spica>`

doc/src/Commands_fix.rst

@@ -165,6 +165,7 @@ OPT.
    * :doc:`orient/fcc <fix_orient>`
    * :doc:`orient/eco <fix_orient_eco>`
    * :doc:`pafi <fix_pafi>`
+   * :doc:`pair <fix_pair>`
    * :doc:`phonon <fix_phonon>`
    * :doc:`pimd <fix_pimd>`
    * :doc:`planeforce <fix_planeforce>`

doc/src/Commands_pair.rst

@@ -201,6 +201,7 @@ OPT.
    * :doc:`meam/spline (o) <pair_meam_spline>`
    * :doc:`meam/sw/spline <pair_meam_sw_spline>`
    * :doc:`mesocnt <pair_mesocnt>`
+   * :doc:`mesocnt/viscous <pair_mesocnt>`
    * :doc:`mesont/tpm <pair_mesont_tpm>`
    * :doc:`mgpt <pair_mgpt>`
    * :doc:`mie/cut (g) <pair_mie>`

doc/src/Developer_updating.rst

@@ -23,6 +23,8 @@ Available topics in mostly chronological order are:
 - `Simplify customized error messages`_
 - `Use of "override" instead of "virtual"`_
 - `Simplified and more compact neighbor list requests`_
+- `Split of fix STORE into fix STORE/GLOBAL and fix STORE/PERATOM`_
+- `Use Output::get_dump_by_id() instead of Output::find_dump()`_
 
 ----
 
@@ -287,7 +289,7 @@ New:
    comm->forward_comm(this);
    comm->reverse_comm(this);
 
-This change is required or else the code will not compile.
+This change is **required** or else the code will not compile.
 
 Simplified and more compact neighbor list requests
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -321,4 +323,103 @@ New:
    if (cutflag) req->set_cutoff(mycutneigh);
 
 Public access to the ``NeighRequest`` class data members has been
-removed so this update is *required* to avoid compilation failure.
+removed so this update is **required** to avoid compilation failure.
+
+Split of fix STORE into fix STORE/GLOBAL and fix STORE/PERATOM
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. versionchanged:: 15Sep2022
+
+This change splits the GLOBAL and PERATOM modes of fix STORE into two
+separate fixes STORE/GLOBAL and STORE/PERATOM.  There was very little
+shared code between the two fix STORE modes and the two different code
+paths had to be prefixed with if statements.  Furthermore, some flags
+were used differently in the two modes leading to confusion.  Splitting
+the code into two fix styles, makes it more easily maintainable.  Since
+these are internal fixes, there is no user visible change.
+
+Old:
+
+.. code-block:: C++
+
+   #include "fix_store.h"
+
+   FixStore *fix = dynamic_cast<FixStore *>(
+      modify->add_fix(fmt::format("{} {} STORE peratom 1 13",id_pole,group->names[0]));
+
+   FixStore *fix = dynamic_cast<FixStore *>(modify->get_fix_by_id(id_pole));
+
+New:
+
+.. code-block:: C++
+
+   #include "fix_store_peratom.h"
+
+   FixStorePeratom *fix = dynamic_cast<FixStorePeratom *>(
+      modify->add_fix(fmt::format("{} {} STORE/PERATOM 1 13",id_pole,group->names[0]));
+
+   FixStorePeratom *fix = dynamic_cast<FixStorePeratom *>(modify->get_fix_by_id(id_pole));
+
+Old:
+
+.. code-block:: C++
+
+   #include "fix_store.h"
+
+   FixStore *fix = dynamic_cast<FixStore *>(
+      modify->add_fix(fmt::format("{} {} STORE global 1 1",id_fix,group->names[igroup]));
+
+   FixStore *fix = dynamic_cast<FixStore *>(modify->get_fix_by_id(id_fix));
+
+New:
+
+.. code-block:: C++
+
+   #include "fix_store_global.h"
+
+   FixStoreGlobal *fix = dynamic_cast<FixStoreGlobal *>(
+      modify->add_fix(fmt::format("{} {} STORE/GLOBAL 1 1",id_fix,group->names[igroup]));
+
+   FixStoreGlobal *fix = dynamic_cast<FixStoreGlobal *>(modify->get_fix_by_id(id_fix));
+
+This change is **required** or else the code will not compile.
+
+Use Output::get_dump_by_id() instead of Output::find_dump()
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. versionchanged:: 15Sep2022
+
+The accessor function to individual dump style instances has been changed
+from ``Output::find_dump()`` returning the index of the dump instance in
+the list of dumps to ``Output::get_dump_by_id()`` returning a pointer to
+the dump directly.  Example:
+
+Old:
+
+.. code-block:: C++
+
+   int idump = output->find_dump(arg[iarg+1]);
+   if (idump < 0)
+     error->all(FLERR,"Dump ID in hyper command does not exist");
+   memory->grow(dumplist,ndump+1,"hyper:dumplist");
+   dumplist[ndump++] = idump;
+
+   [...]
+
+   if (dumpflag)
+     for (int idump = 0; idump < ndump; idump++)
+       output->dump[dumplist[idump]]->write();
+
+New:
+
+.. code-block:: C++
+
+   auto idump = output->get_dump_by_id(arg[iarg+1]);
+   if (!idump) error->all(FLERR,"Dump ID {} in hyper command does not exist", arg[iarg+1]);
+   dumplist.emplace_back(idump);
+
+   [...]
+
+   if (dumpflag) for (auto idump : dumplist) idump->write();
+
+This change is **required** or else the code will not compile.

doc/src/Developer_utils.rst

@@ -175,6 +175,12 @@ and parsing files or arguments.
 .. doxygenfunction:: is_double
    :project: progguide
 
+.. doxygenfunction:: is_id
+   :project: progguide
+
+.. doxygenfunction:: is_type
+   :project: progguide
+
 Potential file functions
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -205,10 +211,13 @@ Argument processing
 .. doxygenfunction:: expand_args
    :project: progguide
 
+.. doxygenfunction:: expand_type
+   :project: progguide
+
 Convenience functions
 ^^^^^^^^^^^^^^^^^^^^^
 
-.. doxygenfunction:: logmesg(LAMMPS *lmp, const S &format, Args&&... args)
+.. doxygenfunction:: logmesg(LAMMPS *lmp, const std::string &format, Args&&... args)
    :project: progguide
 
 .. doxygenfunction:: logmesg(LAMMPS *lmp, const std::string &mesg)

doc/src/Errors_messages.rst

@@ -5453,6 +5453,11 @@ Doc page with :doc:`WARNING messages <Errors_warnings>`
    Mass command must set a type from 1-N where N is the number of atom
    types.
 
+*Invalid label2type() function syntax in variable formula*
+   The first argument must be a label map kind (atom, bond, angle,
+   dihedral, or improper) and the second argument must be a valid type
+   label that has been assigned to a numeric type.
+
 *Invalid use of library file() function*
    This function is called through the library interface.  This
    error should not occur.  Contact the developers if it does.
@@ -5585,9 +5590,18 @@ Doc page with :doc:`WARNING messages <Errors_warnings>`
 *LJ6 off not supported in pair_style buck/long/coul/long*
    Self-explanatory.
 
+*Label map is incomplete: all types must be assigned a unique type label*
+   For a given type-kind (atom types, bond types, etc.) to be written to
+   the data file, all associated types must be assigned a type label, and
+   each type label can be assigned to only one numeric type.
+
 *Label wasn't found in input script*
    Self-explanatory.
 
+*Labelmap command before simulation box is defined*
+   The labelmap command cannot be used before a read_data,
+   read_restart, or create_box command.
+
 *Lattice orient vectors are not orthogonal*
    The three specified lattice orientation vectors must be mutually
    orthogonal.
@@ -5863,6 +5877,12 @@ Doc page with :doc:`WARNING messages <Errors_warnings>`
 *Must not have multiple fixes change box parameter ...*
    Self-explanatory.
 
+*Must read Angle Type Labels before Angles*
+   An Angle Type Labels section of a data file must come before the Angles section.
+
+*Must read Atom Type Labels before Atoms*
+   An Atom Type Labels section of a data file must come before the Atoms section.
+
 *Must read Atoms before Angles*
    The Atoms section of a data file must come before an Angles section.
 
@@ -5893,6 +5913,15 @@ Doc page with :doc:`WARNING messages <Errors_warnings>`
    The Atoms section of a data file must come before a Velocities
    section.
 
+*Must read Bond Type Labels before Bonds*
+   A Bond Type Labels section of a data file must come before the Bonds section.
+
+*Must read Dihedral Type Labels before Dihedrals*
+   An Dihedral Type Labels section of a data file must come before the Dihedrals section.
+
+*Must read Improper Type Labels before Impropers*
+   An Improper Type Labels section of a data file must come before the Impropers section.
+
 *Must re-specify non-restarted pair style (xxx) after read_restart*
    For pair styles, that do not store their settings in a restart file,
    it must be defined with a new 'pair_style' command after read_restart.
@@ -7849,6 +7878,10 @@ keyword to allow for additional bonds to be formed
    Number of local atoms times number of columns must fit in a 32-bit
    integer for dump.
 
+*Topology type exceeds system topology type*
+   The number of bond, angle, etc types exceeds the system setting. See
+   the create_box or read_data command for how to specify these values.
+
 *Tree structure in joint connections*
    Fix poems cannot (yet) work with coupled bodies whose joints connect
    the bodies in a tree structure.
@@ -7873,6 +7906,13 @@ keyword to allow for additional bonds to be formed
 *Two groups cannot be the same in fix spring couple*
    Self-explanatory.
 
+*The %s type label %s is already in use for type %s*
+   For a given type-kind (atom types, bond types, etc.), a given type
+   label can be assigned to only one numeric type.
+
+*Type label string %s for %s type %s is invalid*
+   See the labelmap command documentation for valid type labels.
+
 *Unable to initialize accelerator for use*
    There was a problem initializing an accelerator for the gpu package
 

doc/src/Fortran.rst

@@ -38,11 +38,11 @@ found together with equivalent examples in C and C++ in the
 
 .. note::
 
-   A contributed (and complete!) Fortran interface that more
-   closely resembles the C-library interface is available
-   in the ``examples/COUPLE/fortran2`` folder.  Please see the
-   ``README`` file in that folder for more information about it
-   and how to contact its author and maintainer.
+   A contributed (and more complete!) Fortran interface that more
+   closely resembles the C-library interface is available in the
+   ``examples/COUPLE/fortran2`` folder.  Please see the ``README`` file
+   in that folder for more information about it and how to contact its
+   author and maintainer.
 
 ----------
 
@@ -65,8 +65,9 @@ the optional logical argument set to ``.true.``. Here is a simple example:
 
    PROGRAM testlib
      USE LIBLAMMPS                 ! include the LAMMPS library interface
+     IMPLICIT NONE
      TYPE(lammps)     :: lmp       ! derived type to hold LAMMPS instance
-     CHARACTER(len=*), DIMENSION(*), PARAMETER :: args = &
+     CHARACTER(len=*), PARAMETER :: args(3) = &
          [ CHARACTER(len=12) :: 'liblammps', '-log', 'none' ]
 
      ! create a LAMMPS instance (and initialize MPI)
@@ -78,6 +79,41 @@ the optional logical argument set to ``.true.``. Here is a simple example:
 
    END PROGRAM testlib
 
+It is also possible to pass command line flags from Fortran to C/C++ and
+thus make the resulting executable behave similar to the standalone
+executable (it will ignore the `-in/-i` flag, though).  This allows to
+use the command line to configure accelerator and suffix settings,
+configure screen and logfile output, or to set index style variables
+from the command line and more. Here is a correspondingly adapted
+version of the previous example:
+
+.. code-block:: fortran
+
+   PROGRAM testlib2
+     USE LIBLAMMPS                 ! include the LAMMPS library interface
+     IMPLICIT NONE
+     TYPE(lammps)     :: lmp       ! derived type to hold LAMMPS instance
+     CHARACTER(len=128), ALLOCATABLE :: command_args(:)
+     INTEGER :: i, argc
+
+     ! copy command line flags to `command_args()`
+     argc = COMMAND_ARGUMENT_COUNT()
+     ALLOCATE(command_args(0:argc))
+     DO i=0, argc
+       CALL GET_COMMAND_ARGUMENT(i, command_args(i))
+     END DO
+
+     ! create a LAMMPS instance (and initialize MPI)
+     lmp = lammps(command_args)
+     ! get and print numerical version code
+     PRINT*, 'Program name:   ', command_args(0)
+     PRINT*, 'LAMMPS Version: ', lmp%version()
+     ! delete LAMMPS instance (and shuts down MPI)
+     CALL lmp%close(.TRUE.)
+     DEALLOCATE(command_args)
+
+   END PROGRAM testlib2
+
 --------------------
 
 Executing LAMMPS commands
@@ -102,7 +138,7 @@ Below is a small demonstration of the uses of the different functions:
      USE LIBLAMMPS
      TYPE(lammps)     :: lmp
      CHARACTER(len=512) :: cmds
-     CHARACTER(len=40),ALLOCATABLE :: cmdlist(:)
+     CHARACTER(len=40), ALLOCATABLE :: cmdlist(:)
      CHARACTER(len=10) :: trimmed
      INTEGER :: i
 
@@ -111,10 +147,10 @@ Below is a small demonstration of the uses of the different functions:
      CALL lmp%command('variable zpos index 1.0')
      ! define 10 groups of 10 atoms each
      ALLOCATE(cmdlist(10))
-     DO i=1,10
+     DO i=1, 10
          WRITE(trimmed,'(I10)') 10*i
          WRITE(cmdlist(i),'(A,I1,A,I10,A,A)')       &
-             'group g',i-1,' id ',10*(i-1)+1,':',ADJUSTL(trimmed)
+             'group g', i-1, ' id ', 10*(i-1)+1, ':', ADJUSTL(trimmed)
      END DO
      CALL lmp%commands_list(cmdlist)
      ! run multiple commands from multi-line string
@@ -123,7 +159,7 @@ Below is a small demonstration of the uses of the different functions:
          'create_box 1 box' // NEW_LINE('A') //               &
          'create_atoms 1 single 1.0 1.0 ${zpos}'
      CALL lmp%commands_string(cmds)
-     CALL lmp%close()
+     CALL lmp%close(.TRUE.)
 
    END PROGRAM testcmd
 
@@ -137,9 +173,9 @@ of the contents of the ``LIBLAMMPS`` Fortran interface to LAMMPS.
 
 .. f:type:: lammps
 
-   Derived type that is the general class of the Fortran interface.
-   It holds a reference to the :cpp:class:`LAMMPS <LAMMPS_NS::LAMMPS>` class instance
-   that any of the included calls are forwarded to.
+   Derived type that is the general class of the Fortran interface.  It
+   holds a reference to the :cpp:class:`LAMMPS <LAMMPS_NS::LAMMPS>`
+   class instance that any of the included calls are forwarded to.
 
    :f c_ptr handle: reference to the LAMMPS class
    :f close: :f:func:`close`
@@ -202,7 +238,7 @@ of the contents of the ``LIBLAMMPS`` Fortran interface to LAMMPS.
    This method will call :cpp:func:`lammps_commands_list` to have LAMMPS
    execute a list of input lines.
 
-   :p character(len=*) cmd(*): list of LAMMPS input lines
+   :p character(len=*) cmd(:): list of LAMMPS input lines
 
 .. f:subroutine:: commands_string(str)
 
@@ -210,4 +246,3 @@ of the contents of the ``LIBLAMMPS`` Fortran interface to LAMMPS.
    execute a block of commands from a string.
 
    :p character(len=*) str: LAMMPS input in string
-

doc/src/Howto.rst

@@ -34,6 +34,7 @@ Settings howto
    :maxdepth: 1
 
    Howto_2d
+   Howto_type_labels
    Howto_triclinic
    Howto_thermostat
    Howto_barostat

doc/src/Howto_amoeba.rst

@@ -2,9 +2,9 @@ AMOEBA and HIPPO force fields
 =============================
 
 The AMOEBA and HIPPO polarizable force fields were developed by Jay
-Ponder's group at the U Washington at St Louis.  Their implementation
-in LAMMPS was done using F90 code provided by the Ponder group from
-their `Tinker MD code <https://dasher.wustl.edu/tinker/>`_.
+Ponder's group at the U Washington at St Louis.  The LAMMPS
+implementation is based on Fortran 90 code provided by the Ponder
+group in their `Tinker MD software <https://dasher.wustl.edu/tinker/>`_.
 
 The current implementation (July 2022) of AMOEBA in LAMMPS matches the
 version discussed in :ref:`(Ponder) <amoeba-Ponder>`, :ref:`(Ren)

doc/src/Howto_type_labels.rst

@@ -0,0 +1,126 @@
+Type labels
+===========
+
+.. versionadded:: 15Sep2022
+
+Each atom in LAMMPS has an associated numeric atom type. Similarly,
+each bond, angle, dihedral, and improper is assigned a bond type,
+angle type, and so on.  The primary use of these types is to map
+potential (force field) parameters to the interactions of the atom,
+bond, angle, dihedral, and improper.
+
+By default, type values are entered as integers from 1 to Ntypes
+wherever they appear in LAMMPS input or output files.  The total number
+Ntypes for each interaction is "locked in" when the simulation box
+is created.
+
+A recent addition to LAMMPS is the option to use strings - referred
+to as type labels - as an alternative.  Using type labels instead of
+numeric types can be advantageous in various scenarios.  For example,
+type labels can make inputs more readable and generic (i.e. usable through
+the :doc:`include command <include>` for different systems with different
+numerical values assigned to types.  This generality also applies to
+other inputs like data files read by :doc:`read_data <read_data>` or
+molecule template files read by the :doc:`molecule <molecule>`
+command.  See below for a list of other commands that can use
+type labels in different ways.
+
+LAMMPS will *internally* continue to use numeric types, which means
+that many previous restrictions still apply.  For example, the total
+number of types is locked in when creating the simulation box, and
+potential parameters for each type must be provided even if not used
+by any interactions.
+
+A collection of type labels for all type-kinds (atom types, bond types,
+etc.) is stored as a "label map" which is simply a list of numeric types
+and their associated type labels.  Within a type-kind, each type label
+must be unique.  It can be assigned to only one numeric type.  To read
+and write type labels to data files for a given type-kind, *all*
+associated numeric types need have a type label assigned.  Partial
+maps can be saved with the :doc:`labelmap write <labelmap>` command
+and read back with the :doc:`include <include>` command.
+
+Valid type labels can contain most ASCII characters, but cannot start
+with a number, a '#', or a '*'.  Also, labels must not contain whitespace
+characters.  When using the :doc:`labelmap command <labelmap>` in the
+LAMMPS input, if certain characters appear in the type label, such as
+the single (') or double (") quote or the '#' character, the label
+must be put in either double, single, or triple (""") quotes.  Triple
+quotes allow for the most generic type label strings, but they require
+to have a leading and trailing blank space.  When defining type labels
+the blanks will be ignored. Example:
+
+.. code-block:: LAMMPS
+
+   labelmap angle 1 """ C1'-C2"-C3# """
+
+This command will map the string ```C1'-C2"-C3#``` to the angle type 1.
+
+There are two ways to define label maps.  One is via the :doc:`labelmap
+<labelmap>` command.  The other is via the :doc:`read_data <read_data>`
+command.  A data file can have sections such as *Atom Type Labels*, *Bond
+Type Labels*, etc., which assign type labels to numeric types.  The
+label map can be written out to data files by the :doc:`write_data
+<write_data>` command.  This map is also written to and read from
+restart files, by the :doc:`write_restart <write_restart>` and
+:doc:`read_restart <read_restart>` commands.
+
+----------
+
+Use of type labels in LAMMPS input or output
+""""""""""""""""""""""""""""""""""""""""""""
+
+Many LAMMPS input script commands that take a numeric type as an
+argument can use the associated type label instead.  If a type label
+is not defined for a particular numeric type, only its numeric type
+can be used.
+
+This example assigns labels to the atom types, and then uses the type
+labels to redefine the pair coefficients.
+
+.. code-block:: LAMMPS
+
+   pair_coeff 1 2 1.0 1.0              # numeric types
+   labelmap atom 1 C 2 H
+   pair_coeff C H 1.0 1.0              # type labels
+
+Adding support for type labels to various commands is an ongoing
+project.  If an input script command (or a section in a file read by a
+command) allows substituting a type label for a numeric type argument,
+it will be explicitly mentioned in that command's documentation page.
+
+As a temporary measure, input script commands can take advantage of
+variables and how they can be expanded during processing of the input.
+The variables can use functions that will translate type label strings
+to their respective number as defined in the current label map.  See the
+:doc:`variable <variable>` command for details.
+
+For example, here is how the pair_coeff command could be used with
+type labels if it did not yet support them, either with an explicit
+variable command or an implicit variable used in the pair_coeff
+command.
+
+.. code-block:: LAMMPS
+
+   labelmap atom 1 C 2 H
+   variable atom1 equal label2type(atom,C)
+   variable atom2 equal label2type(atom,H)
+   pair_coeff ${atom1} ${atom2} 1.0 1.0
+
+.. code-block:: LAMMPS
+
+   labelmap atom 1 C 2 H
+   pair_coeff $(label2type(atom,C)) $(label2type(atom,H)) 80.0 1.2
+
+----------
+
+Commands that can use label types
+"""""""""""""""""""""""""""""""""
+
+Any workflow that involves reading multiple data files, molecule
+templates or a combination of the two can be streamlined by using type
+labels instead of numeric types, because types are automatically synced
+between the files.  The creation of simulation-ready reaction templates
+for :doc:`fix bond/react <fix_bond_react>` is much simpler when using
+type labels, and results in templates that can be used without
+modification in multiple simulations or different systems.

doc/src/Manual.rst

@@ -49,12 +49,12 @@ descriptions of all commands included in the LAMMPS code.
 
 ----------
 
+.. _user_documentation:
 
 ************
 User Guide
 ************
 
-.. _user_documentation:
 .. toctree::
    :maxdepth: 2
    :numbered: 3
@@ -75,11 +75,12 @@ User Guide
    Errors
 
 
+.. _programmer_documentation:
+
 ******************
 Programmer Guide
 ******************
 
-.. _programmer_documentation:
 .. toctree::
    :maxdepth: 2
    :numbered: 3

doc/src/Packages_details.rst

@@ -157,14 +157,28 @@ AMOEBA package
 
 **Contents:**
 
-TODO
+Implementation of the AMOEBA and HIPPO polarized force fields
+originally developed by Jay Ponder's group at the U Washington at St
+Louis.  The LAMMPS implementation is based on Fortran 90 code
+provided by the Ponder group in their
+`Tinker MD software <https://dasher.wustl.edu/tinker/>`_.
+
+**Authors:** Josh Rackers and Steve Plimpton (Sandia), Trung Nguyen (U
+ Chicago)
 
 **Supporting info:**
 
 * src/AMOEBA: filenames -> commands
 * :doc:`AMOEBA and HIPPO howto <Howto_amoeba>`
+* :doc:`pair_style amoeba <pair_amoeba>`
+* :doc:`pair_style hippo <pair_amoeba>`
+* :doc:`atom_style amoeba <atom_style>`
+* :doc:`angle_style amoeba <angle_amoeba>`
+* :doc:`improper_style amoeba <improper_amoeba>`
+* :doc:`fix amoeba/bitorsion <fix_amoeba_bitorsion>`
+* :doc:`fix amoeba/pitorsion <fix_amoeba_pitorsion>`
+* tools/tinker/tinker2lmp.py
 * examples/amoeba
-* TODO
 
 ----------
 
@@ -200,9 +214,10 @@ ATC package
 
 **Contents:**
 
-ATC stands for atoms-to-continuum.  This package implements a :doc:`fix atc <fix_atc>` command to either couple molecular dynamics with
-continuum finite element equations or perform on-the-fly conversion of
-atomic information to continuum fields.
+ATC stands for atoms-to-continuum.  This package implements a
+:doc:`fix atc <fix_atc>` command to either couple molecular dynamics
+with continuum finite element equations or perform on-the-fly
+conversion of atomic information to continuum fields.
 
 **Authors:** Reese Jones, Jeremy Templeton, Jon Zimmerman (Sandia).
 
@@ -261,7 +276,7 @@ the barostat as outlined in:
 
 N. J. H. Dunn and W. G. Noid, "Bottom-up coarse-grained models that
 accurately describe the structure, pressure, and compressibility of
-molecular liquids," J. Chem. Phys. 143, 243148 (2015).
+molecular liquids", J. Chem. Phys. 143, 243148 (2015).
 
 **Authors:** Nicholas J. H. Dunn and Michael R. DeLyser (The
 Pennsylvania State University)
@@ -637,7 +652,7 @@ short-range or long-range interactions.
 * :doc:`pair_style lj/cut/dipole/cut <pair_dipole>`
 * :doc:`pair_style lj/cut/dipole/long <pair_dipole>`
 * :doc:`pair_style lj/long/dipole/long <pair_dipole>`
-* :doc: `angle_style dipole <angle_dipole>`
+* :doc:`angle_style dipole <angle_dipole>`
 * examples/dipole
 
 ----------
@@ -917,6 +932,10 @@ EXTRA-MOLECULE package
 
 Additional bond, angle, dihedral, and improper styles that are less commonly used.
 
+**Install:**
+
+To use this package, also the :ref:`MOLECULE <PKG-MOLECULE>` package needs to be installed.
+
 **Supporting info:**
 
 * src/EXTRA-MOLECULE: filenames -> commands
@@ -1389,7 +1408,7 @@ This package has :ref:`specific installation instructions <machdyn>` on the :doc
 
 * src/MACHDYN: filenames -> commands
 * src/MACHDYN/README
-* doc/PDF/MACHDYN_LAMMPS_userguide.pdf
+* `doc/PDF/MACHDYN_LAMMPS_userguide.pdf <PDF/MACHDYN_LAMMPS_userguide.pdf>`_
 * examples/PACKAGES/machdyn
 * https://www.lammps.org/movies.html#smd
 
@@ -1541,31 +1560,40 @@ MESONT package
 
 **Contents:**
 
-MESONT is a LAMMPS package for simulation of nanomechanics of
-nanotubes (NTs). The model is based on a coarse-grained representation
-of NTs as "flexible cylinders" consisting of a variable number of
+MESONT is a LAMMPS package for simulation of nanomechanics of nanotubes
+(NTs). The model is based on a coarse-grained representation of NTs as
+"flexible cylinders" consisting of a variable number of
 segments. Internal interactions within a NT and the van der Waals
 interaction between the tubes are described by a mesoscopic force field
 designed and parameterized based on the results of atomic-level
 molecular dynamics simulations. The description of the force field is
-provided in the papers listed below. This package contains two
-independent implementations of this model: :doc:`pair_style mesocnt
-<pair_mesocnt>` is a (minimal) C++ implementation, and :doc:`pair_style
-mesont/tpm <pair_mesont_tpm>` is a more general and feature rich
-implementation based on a Fortran library in the ``lib/mesont`` folder.
+provided in the papers listed below.
+
+This package contains two independent implementations of this model:
+:doc:`pair_style mesont/tpm <pair_mesont_tpm>` is the original
+implementation of the model based on a Fortran library in the
+``lib/mesont`` folder. The second implementation is provided by the
+mesocnt styles (:doc:`bond_style mesocnt <bond_mesocnt>`,
+:doc:`angle_style mesocnt <angle_mesocnt>` and :doc:`pair_style mesocnt
+<pair_mesocnt>`).  The mesocnt implementation has the same features as
+the original implementation with the addition of friction, but is
+directly implemented in C++, interfaces more cleanly with general LAMMPS
+functionality, and is typically faster. It also does not require its own
+atom style and can be installed without any external libraries.
 
 **Download of potential files:**
 
-The potential files for these pair styles are *very* large and thus
-are not included in the regular downloaded packages of LAMMPS or the
-git repositories.  Instead, they will be automatically downloaded
-from a web server when the package is installed for the first time.
+The potential files for these pair styles are *very* large and thus are
+not included in the regular downloaded packages of LAMMPS or the git
+repositories.  Instead, they will be automatically downloaded from a web
+server when the package is installed for the first time.
 
 **Authors of the *mesont* styles:**
 
-Maxim V. Shugaev (University of Virginia), Alexey N. Volkov (University of Alabama), Leonid V. Zhigilei (University of Virginia)
+Maxim V. Shugaev (University of Virginia), Alexey N. Volkov (University
+of Alabama), Leonid V. Zhigilei (University of Virginia)
 
-**Author of the *mesocnt* pair style:**
+**Author of the *mesocnt* styles:**
 Philipp Kloza (U Cambridge)
 
 **Supporting info:**
@@ -1575,6 +1603,8 @@ Philipp Kloza (U Cambridge)
 * :doc:`atom_style mesont <atom_style>`
 * :doc:`pair_style mesont/tpm <pair_mesont_tpm>`
 * :doc:`compute mesont <compute_mesont>`
+* :doc:`bond_style mesocnt <bond_mesocnt>`
+* :doc:`angle_style mesocnt <angle_mesocnt>`
 * :doc:`pair_style mesocnt <pair_mesocnt>`
 * examples/PACKAGES/mesont
 * tools/mesont
@@ -2677,7 +2707,7 @@ Dynamics, Ernst Mach Institute, Germany).
 
 * src/SPH: filenames -> commands
 * src/SPH/README
-* doc/PDF/SPH_LAMMPS_userguide.pdf
+* `doc/PDF/SPH_LAMMPS_userguide.pdf <PDF/SPH_LAMMPS_userguide.pdf>`_
 * examples/PACKAGES/sph
 * https://www.lammps.org/movies.html#sph
 

doc/src/Run_options.rst

@@ -14,6 +14,7 @@ letter abbreviation can be used:
 * :ref:`-m or -mpicolor <mpicolor>`
 * :ref:`-c or -cite <cite>`
 * :ref:`-nc or -nocite <nocite>`
+* :ref:`-nb or -nonbuf <nonbuf>`
 * :ref:`-pk or -package <package>`
 * :ref:`-p or -partition <partition>`
 * :ref:`-pl or -plog <plog>`
@@ -257,6 +258,24 @@ Disable generating a citation reminder (see above) at all.
 
 ----------
 
+.. _nonbuf:
+
+**-nonbuf**
+
+Turn off buffering for screen and logfile output.  For performance
+reasons, output to the screen and logfile is usually buffered, i.e.
+output is only written to a file if its buffer - typically 4096 bytes -
+has been filled.  When LAMMPS crashes for some reason, however, that can
+mean that there is important output missing.  With this flag the
+buffering can be turned off (only for screen and logfile output) and any
+output will be committed immediately.  Note that when running in
+parallel with MPI, the screen output may still be buffered by the MPI
+library and this cannot be changed by LAMMPS.  This flag should only be
+used for debugging and not for production simulations as the performance
+impact can be significant, especially for large parallel runs.
+
+----------
+
 .. _package:
 
 **-package style args ....**
@@ -476,7 +495,7 @@ run:
    write_dump group-ID dumpstyle dumpfile arg1 arg2 ...
 
 Note that the specified restartfile and dumpfile names may contain
-wild-card characters ("\*","%") as explained on the
+wild-card characters ("\*" or "%") as explained on the
 :doc:`read_restart <read_restart>` and :doc:`write_dump <write_dump>` doc
 pages.  The use of "%" means that a parallel restart file and/or
 parallel dump file can be read and/or written.  Note that a filename

doc/src/Speed_intel.rst

@@ -536,6 +536,6 @@ supported.
 References
 """"""""""
 
-* Brown, W.M., Carrillo, J.-M.Y., Mishra, B., Gavhane, N., Thakkar, F.M., De Kraker, A.R., Yamada, M., Ang, J.A., Plimpton, S.J., "Optimizing Classical Molecular Dynamics in LAMMPS," in Intel Xeon Phi Processor High Performance Programming: Knights Landing Edition, J. Jeffers, J. Reinders, A. Sodani, Eds. Morgan Kaufmann.
+* Brown, W.M., Carrillo, J.-M.Y., Mishra, B., Gavhane, N., Thakkar, F.M., De Kraker, A.R., Yamada, M., Ang, J.A., Plimpton, S.J., "Optimizing Classical Molecular Dynamics in LAMMPS", in Intel Xeon Phi Processor High Performance Programming: Knights Landing Edition, J. Jeffers, J. Reinders, A. Sodani, Eds. Morgan Kaufmann.
 * Brown, W. M., Semin, A., Hebenstreit, M., Khvostov, S., Raman, K., Plimpton, S.J. `Increasing Molecular Dynamics Simulation Rates with an 8-Fold Increase in Electrical Power Efficiency. <http://dl.acm.org/citation.cfm?id=3014915>`_ 2016 High Performance Computing, Networking, Storage and Analysis, SC16: International Conference (pp. 82-95).
 * Brown, W.M., Carrillo, J.-M.Y., Gavhane, N., Thakkar, F.M., Plimpton, S.J. Optimizing Legacy Molecular Dynamics Software with Directive-Based Offload. Computer Physics Communications. 2015. 195: p. 95-101.

doc/src/accel_styles.rst

@@ -6,7 +6,7 @@ page.  The accelerated styles take the same arguments and should
 produce the same results, except for round-off and precision issues.
 
 These accelerated styles are part of the GPU, INTEL, KOKKOS,
-OPENMP and OPT packages, respectively.  They are only enabled if
+OPENMP, and OPT packages, respectively.  They are only enabled if
 LAMMPS was built with those packages.  See the :doc:`Build package <Build_package>` page for more info.
 
 You can specify the accelerated styles explicitly in your input script

doc/src/angle_coeff.rst

@@ -10,7 +10,7 @@ Syntax
 
    angle_coeff N args
 
-* N = angle type (see asterisk form below)
+* N = numeric angle type (see asterisk form below), or type label
 * args = coefficients for one or more angle types
 
 Examples
@@ -22,6 +22,9 @@ Examples
    angle_coeff * 5.0
    angle_coeff 2*10 5.0
 
+   labelmap angle 1 hydroxyl
+   angle_coeff hydroxyl 300.0 107.0
+
 Description
 """""""""""
 
@@ -30,18 +33,24 @@ The number and meaning of the coefficients depends on the angle style.
 Angle coefficients can also be set in the data file read by the
 :doc:`read_data <read_data>` command or in a restart file.
 
-N can be specified in one of two ways.  An explicit numeric value can
-be used, as in the first example above.  Or a wild-card asterisk can be
-used to set the coefficients for multiple angle types.  This takes the
-form "\*" or "\*n" or "n\*" or "m\*n".  If N = the number of angle types,
-then an asterisk with no numeric values means all types from 1 to N.  A
-leading asterisk means all types from 1 to n (inclusive).  A trailing
-asterisk means all types from n to N (inclusive).  A middle asterisk
-means all types from m to n (inclusive).
+:math:`N` can be specified in one of two ways.  An explicit numeric
+value can be used, as in the first example above.  Or :math:`N` can be a
+type label, which is an alphanumeric string defined by the
+:doc:`labelmap <labelmap>` command or in a section of a data file read
+by the :doc:`read_data <read_data>` command.
 
-Note that using an :doc:`angle_coeff <angle_coeff>` command can override a previous setting
-for the same angle type.  For example, these commands set the coeffs
-for all angle types, then overwrite the coeffs for just angle type 2:
+For numeric values only, a wild-card asterisk can be used to set the
+coefficients for multiple angle types.  This takes the form "\*" or
+"\*n" or "n\*" or "m\*n".  If :math:`N` is the number of angle types,
+then an asterisk with no numeric values means all types from 1 to
+:math:`N`.  A leading asterisk means all types from 1 to n (inclusive).
+A trailing asterisk means all types from n to :math:`N` (inclusive).  A
+middle asterisk means all types from m to n (inclusive).
+
+Note that using an :doc:`angle_coeff <angle_coeff>` command can
+override a previous setting for the same angle type.  For example,
+these commands set the coeffs for all angle types, then overwrite the
+coeffs for just angle type 2:
 
 .. code-block:: LAMMPS
 
@@ -49,11 +58,11 @@ for all angle types, then overwrite the coeffs for just angle type 2:
    angle_coeff 2 50.0 107.0
 
 A line in a data file that specifies angle coefficients uses the exact
-same format as the arguments of the :doc:`angle_coeff <angle_coeff>` command in an input
-script, except that wild-card asterisks should not be used since
-coefficients for all N types must be listed in the file.  For example,
-under the "Angle Coeffs" section of a data file, the line that
-corresponds to the first example above would be listed as
+same format as the arguments of the :doc:`angle_coeff <angle_coeff>`
+command in an input script, except that wild-card asterisks should not
+be used since coefficients for all :math:`N` types must be listed in the
+file.  For example, under the "Angle Coeffs" section of a data file, the
+line that corresponds to the first example above would be listed as
 
 .. parsed-literal::
 
@@ -61,15 +70,14 @@ corresponds to the first example above would be listed as
 
 The :doc:`angle_style class2 <angle_class2>` is an exception to this
 rule, in that an additional argument is used in the input script to
-allow specification of the cross-term coefficients.   See its
-doc page for details.
+allow specification of the cross-term coefficients.  See its doc page
+for details.
 
 ----------
 
 The list of all angle styles defined in LAMMPS is given on the
 :doc:`angle_style <angle_style>` doc page.  They are also listed in more
-compact form on the :ref:`Commands angle <angle>` doc
-page.
+compact form on the :ref:`Commands angle <angle>` doc page.
 
 On either of those pages, click on the style to display the formula it
 computes and its coefficients as specified by the associated

doc/src/angle_mesocnt.rst

@@ -0,0 +1,146 @@
+.. index:: angle_style mesocnt
+
+angle_style mesocnt command
+===========================
+
+Syntax
+""""""
+
+.. code-block:: LAMMPS
+
+   angle_style mesocnt
+
+Examples
+""""""""
+
+.. code-block:: LAMMPS
+
+   angle_style mesocnt
+   angle_coeff 1 buckling C 10 10 20.0
+   angle_coeff 4 harmonic C 8 4 10.0
+   angle_coeff 2 buckling custom 400.0 50.0 5.0
+   angle_coeff 1 harmonic custom 300.0
+
+Description
+"""""""""""
+
+.. versionadded:: 15Sep2022
+
+The *mesocnt* angle style uses the potential
+
+.. math::
+
+   E = K_\text{H} \Delta \theta^2, \qquad |\Delta \theta| < \Delta
+   \theta_\text{B} \\
+   E = K_\text{H} \Delta \theta_\text{B}^2 +
+   K_\text{B} (\Delta \theta - \Delta \theta_\text{B}), \qquad |\Delta
+   \theta| \geq \Delta \theta_\text{B}
+
+where :math:`\Delta \theta = \theta - \pi` is the bending angle of the
+nanotube, :math:`K_\text{H}` and :math:`K_\text{B}` are prefactors for
+the harmonic and linear regime respectively and :math:`\Delta
+\theta_\text{B}` is the buckling angle. Note that the usual 1/2 factor
+for the harmonic potential is included in :math:`K_\text{H}`.
+
+The style implements parameterization presets of :math:`K_\text{H}`,
+:math:`K_\text{B}` and :math:`\Delta \theta_\text{B}` for mesoscopic
+simulations of carbon nanotubes based on the atomistic simulations of
+:ref:`(Srivastava) <Srivastava_2>` and buckling considerations of
+:ref:`(Zhigilei) <Zhigilei1_1>`.
+
+The following coefficients must be defined for each angle type via the
+:doc:`angle_coeff <angle_coeff>` command as in the examples above, or
+in the data file or restart files read by the :doc:`read_data
+<read_data>` or :doc:`read_restart <read_restart>` commands:
+
+* mode = *buckling* or *harmonic*
+* preset = *C* or *custom*
+* additional parameters depending on preset
+
+If mode *harmonic* is chosen, the potential is simply harmonic and
+does not switch to the linear term when the buckling angle is
+reached. In *buckling* mode, the full piecewise potential is used.
+
+Preset *C* is for carbon nanotubes, and the additional parameters are:
+
+* chiral index :math:`n` (unitless)
+* chiral index :math:`m` (unitless)
+* :math:`r_0` (distance)
+
+Here, :math:`r_0` is the equilibrium distance of the bonds included in
+the angle, see :doc:`bond_style mesocnt <bond_mesocnt>`.
+
+In harmonic mode with preset *custom*, the additional parameter is:
+
+* :math:`K_\text{H}` (energy)
+
+Hence, this setting is simply a wrapper for :doc:`bond_style harmonic
+<bond_harmonic>` with an equilibrium angle of 180 degrees.
+
+In harmonic mode with preset *custom*, the additional parameters are:
+
+* :math:`K_\text{H}` (energy)
+* :math:`K_\text{B}` (energy)
+* :math:`\Delta \theta_\text{B}` (degrees)
+
+:math:`\Delta \theta_\text{B}` is specified in degrees, but LAMMPS
+converts it to radians internally; hence :math:`K_\text{H}` is
+effectively energy per radian\^2 and :math:`K_\text{B}` is energy per
+radian.
+
+----------
+
+In *buckling* mode, this angle style adds the *buckled* property to
+all atoms in the simulation, which is an integer flag indicating
+whether the bending angle at a given atom has exceeded :math:`\Delta
+\theta_\text{B}`. It can be accessed as an atomic variable, e.g. for
+custom dump commands, as *i_buckled*.
+
+.. note::
+
+   If the initial state of the simulation contains buckled nanotubes
+   and :doc:`pair_style mesocnt <pair_mesocnt>` is used, the
+   *i_buckled* atomic variable needs to be initialized before the
+   pair_style is defined by doing a *run 0* command straight after the
+   angle_style command. See below for an example.
+
+If CNTs are already buckled at the start of the simulation, this
+script will correctly initialize *i_buckled*:
+
+.. code-block:: LAMMPS
+
+   angle_style mesocnt
+   angle_coeff 1 buckling C 10 10 20.0
+
+   run 0
+
+   pair_style mesocnt 60.0
+   pair_coeff * * C_10_10.mesocnt 1
+
+Restrictions
+""""""""""""
+
+This angle style can only be used if LAMMPS was built with the
+MOLECULE and MESONT packages.  See the :doc:`Build package
+<Build_package>` doc page for more info.
+
+Related commands
+""""""""""""""""
+
+:doc:`angle_coeff <angle_coeff>`
+
+Default
+"""""""
+
+none
+
+----------
+
+.. _Srivastava_2:
+
+**(Srivastava)** Zhigilei, Wei, Srivastava, Phys. Rev. B 71, 165417
+(2005).
+
+.. _Zhigilei1_1:
+
+**(Zhigilei)** Volkov and Zhigilei, ACS Nano 4, 6187 (2010).

doc/src/angle_style.rst

@@ -10,7 +10,7 @@ Syntax
 
    angle_style style
 
-* style = *none* or *hybrid* or *charmm* or *class2* or *cosine* or         *cosine/squared* or *harmonic*
+* style = *none* or *zero* or *hybrid* or *amoeba* or *charmm* or *class2* or *class2/p6* or *cosine* or *cosine/buck6d* or *cosine/delta* or *cosine/periodic* or *cosine/shift* or *cosine/shift/exp* or *cosine/squared* or *cross* or *dipole* or *fourier* or *fourier/simple* or *gaussian* or *harmonic* or *mm3* or *quartic* or *spica* or *table*
 
 Examples
 """"""""
@@ -90,6 +90,7 @@ of (g,i,k,o,t) to indicate which accelerated styles exist.
 * :doc:`fourier/simple <angle_fourier_simple>` - angle with a single cosine term
 * :doc:`gaussian <angle_gaussian>` - multi-centered Gaussian-based angle potential
 * :doc:`harmonic <angle_harmonic>` - harmonic angle
+* :doc:`mesocnt <angle_mesocnt>` - piecewise harmonic and linear angle for bending-buckling of nanotubes
 * :doc:`mm3 <angle_mm3>` - anharmonic angle
 * :doc:`quartic <angle_quartic>` - angle with cubic and quartic terms
 * :doc:`spica <angle_spica>` - harmonic angle with repulsive SPICA pair style between 1-3 atoms

doc/src/angle_zero.rst

@@ -8,7 +8,10 @@ Syntax
 
 .. code-block:: LAMMPS
 
-   angle_style zero *nocoeff*
+   angle_style zero keyword
+
+* zero or more keywords may be appended
+* keyword = *nocoeff*
 
 Examples
 """"""""

doc/src/atom_style.rst

@@ -10,7 +10,7 @@ Syntax
 
    atom_style style args
 
-* style = *amoeba* or *angle* or *atomic* or *body* or *bond* or *charge* or *dipole* or *dpd* or *edpd* or *electron* or *ellipsoid* or *full* or *line* or *mdpd* or *molecular* or *oxdna* or *peri* or *smd* or *sph* or *sphere* or or *bpm/sphere* or *spin* or *tdpd* or *tri* or *template* or *hybrid*
+* style = *amoeba* or *angle* or *atomic* or *body* or *bond* or *charge* or *dielectric* or *dipole* or  *dpd* or *edpd* or *electron* or *ellipsoid* or *full* or *line* or *mdpd* or *mesont* or *molecular* or *oxdna* or *peri* or *smd* or *sph* or *sphere* or *bpm/sphere* or *spin* or *tdpd* or *tri* or *template* or *wavepacket* or *hybrid*
 
   .. parsed-literal::
 

doc/src/balance.rst

@@ -6,7 +6,7 @@ balance command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    balance thresh style args ... keyword args ...
 

doc/src/bond_bpm_rotational.rst

@@ -38,8 +38,7 @@ Examples
    bond_style bpm/rotational
    bond_coeff 1 1.0 0.2 0.02 0.02 0.20 0.04 0.04 0.04 0.1 0.02 0.002 0.002
 
-   bond_style bpm/rotational myfix 1000 time id1 id2
-   fix myfix all store/local 1000 3
+   bond_style bpm/rotational store/local myfix 1000 time id1 id2
    dump 1 all local 1000 dump.broken f_myfix[1] f_myfix[2] f_myfix[3]
    dump_modify 1 write_header no
 

doc/src/bond_coeff.rst

@@ -10,7 +10,7 @@ Syntax
 
    bond_coeff N args
 
-* N = bond type (see asterisk form below)
+* N = numeric bond type (see asterisk form below), or type label
 * args = coefficients for one or more bond types
 
 Examples
@@ -21,7 +21,10 @@ Examples
    bond_coeff 5 80.0 1.2
    bond_coeff * 30.0 1.5 1.0 1.0
    bond_coeff 1*4 30.0 1.5 1.0 1.0
-   bond_coeff 1 harmonic 200.0 1.0
+   bond_coeff 1 harmonic 200.0 1.0 (for bond_style hybrid)
+
+   labelmap bond 5 carbonyl
+   bond_coeff carbonyl 80.0 1.2
 
 Description
 """""""""""
@@ -31,14 +34,19 @@ The number and meaning of the coefficients depends on the bond style.
 Bond coefficients can also be set in the data file read by the
 :doc:`read_data <read_data>` command or in a restart file.
 
-N can be specified in one of two ways.  An explicit numeric value can
-be used, as in the first example above.  Or a wild-card asterisk can be
-used to set the coefficients for multiple bond types.  This takes the
-form "\*" or "\*n" or "n\*" or "m\*n".  If N = the number of bond types,
-then an asterisk with no numeric values means all types from 1 to N.  A
+:math:`N` can be specified in one of several ways.  An explicit numeric
+value can be used, as in the first example above.  Or :math:`N` can be a
+type label, which is an alphanumeric string defined by the
+:doc:`labelmap <labelmap>` command or in a section of a data file read
+by the :doc:`read_data <read_data>` command.
+
+For numeric values only, a wild-card asterisk can be used to set the
+coefficients for multiple bond types.  This takes the form "\*" or "\*n"
+or "n\*" or "m\*n".  If :math:`N` is the number of bond types, then an
+asterisk with no numeric values means all types from 1 to :math:`N`.  A
 leading asterisk means all types from 1 to n (inclusive).  A trailing
-asterisk means all types from n to N (inclusive).  A middle asterisk
-means all types from m to n (inclusive).
+asterisk means all types from n to :math:`N` (inclusive).  A middle
+asterisk means all types from m to n (inclusive).
 
 Note that using a bond_coeff command can override a previous setting
 for the same bond type.  For example, these commands set the coeffs
@@ -52,8 +60,8 @@ for all bond types, then overwrite the coeffs for just bond type 2:
 A line in a data file that specifies bond coefficients uses the exact
 same format as the arguments of the bond_coeff command in an input
 script, except that wild-card asterisks should not be used since
-coefficients for all N types must be listed in the file.  For example,
-under the "Bond Coeffs" section of a data file, the line that
+coefficients for all :math:`N` types must be listed in the file.  For
+example, under the "Bond Coeffs" section of a data file, the line that
 corresponds to the first example above would be listed as
 
 .. parsed-literal::

doc/src/bond_mesocnt.rst

@@ -0,0 +1,84 @@
+.. index:: bond_style mesocnt
+
+bond_style mesocnt command
+===========================
+
+Syntax
+""""""
+
+.. code-block:: LAMMPS
+
+   bond_style mesocnt
+
+Examples
+""""""""
+
+.. code-block:: LAMMPS
+
+   bond_style mesocnt
+   bond_coeff 1 C 10 10 20.0
+   bond_coeff 4 custom 800.0 10.0
+
+Description
+"""""""""""
+
+.. versionadded:: 15Sep2022
+
+The *mesocnt* bond style is a wrapper for the :doc:`harmonic
+<bond_harmonic>` style, and uses the potential
+
+.. math::
+
+   E = K (r - r_0)^2
+
+where :math:`r_0` is the equilibrium bond distance.  Note that the
+usual 1/2 factor is included in :math:`K`.  The style implements
+parameterization presets of :math:`K` for mesoscopic simulations of
+carbon nanotubes based on the atomistic simulations of
+:ref:`(Srivastava) <Srivastava_1>`.
+
+Other presets can be readily implemented in the future.
+
+The following coefficients must be defined for each bond type via the
+:doc:`bond_coeff <bond_coeff>` command as in the example above, or in
+the data file or restart files read by the :doc:`read_data
+<read_data>` or :doc:`read_restart <read_restart>` commands:
+
+* preset = *C* or *custom*
+* additional parameters depending on preset
+
+Preset *C* is for carbon nanotubes, and the additional parameters are:
+
+* chiral index :math:`n` (unitless)
+* chiral index :math:`m` (unitless)
+* :math:`r_0` (distance)
+
+Preset *custom* is simply a direct wrapper for the :doc:`harmonic
+<bond_harmonic>` style, and the additional parameters are:
+
+* :math:`K` (energy/distance\^2)
+* :math:`r_0` (distance)
+
+Restrictions
+""""""""""""
+
+This bond style can only be used if LAMMPS was built with the MOLECULE
+and MESONT packages.  See the :doc:`Build package <Build_package>`
+page for more info.
+
+Related commands
+""""""""""""""""
+
+:doc:`bond_coeff <bond_coeff>`, :doc:`delete_bonds <delete_bonds>`
+
+Default
+"""""""
+
+none
+
+----------
+
+.. _Srivastava_1:
+
+**(Srivastava)** Zhigilei, Wei and Srivastava, Phys. Rev. B 71, 165417
+(2005).

doc/src/bond_style.rst

@@ -10,7 +10,7 @@ Syntax
 
    bond_style style args
 
-* style = *none* or *hybrid* or *class2* or *fene* or *fene/expand* or         *harmonic* or *morse* or *nonlinear* or *quartic*
+* style = *none* or *zero* or *hybrid* or *bpm/rotational* or *bpm/spring* or *class2* or *fene* or *fene/expand* or *fene/nm* or *gaussian* or *gromos* or *harmonic* or *harmonic/shift* or *harmonic/shift/cut* or *morse* or *nonlinear* or *oxdna/fene* or *oxdena2/fene* or *oxrna2/fene* or *quartic* or *special* or *table*
 
 * args = none for any style except *hybrid*
 
@@ -95,6 +95,7 @@ accelerated styles exist.
 * :doc:`harmonic <bond_harmonic>` - harmonic bond
 * :doc:`harmonic/shift <bond_harmonic_shift>` - shifted harmonic bond
 * :doc:`harmonic/shift/cut <bond_harmonic_shift_cut>` - shifted harmonic bond with a cutoff
+* :doc:`mesocnt <bond_mesocnt>` - Harmonic bond wrapper with parameterization presets for nanotubes
 * :doc:`mm3 <bond_mm3>` - MM3 anharmonic bond
 * :doc:`morse <bond_morse>` - Morse bond
 * :doc:`nonlinear <bond_nonlinear>` - nonlinear bond

doc/src/bond_zero.rst

@@ -8,7 +8,10 @@ Syntax
 
 .. code-block:: LAMMPS
 
-   bond_style zero [nocoeff]
+   bond_style zero keyword
+
+* zero or more keywords may be appended
+* keyword = *nocoeff*
 
 Examples
 """"""""

doc/src/boundary.rst

@@ -6,7 +6,7 @@ boundary command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    boundary x y z
 

doc/src/box.rst

@@ -6,7 +6,7 @@ box command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    box keyword value ...
 

doc/src/clear.rst

@@ -6,18 +6,18 @@ clear command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    clear
 
 Examples
 """"""""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
-   (commands for 1st simulation)
+   # (commands for 1st simulation)
    clear
-   (commands for 2nd simulation)
+   # (commands for 2nd simulation)
 
 Description
 """""""""""

doc/src/comm_modify.rst

@@ -10,8 +10,8 @@ Syntax
 
    comm_modify keyword value ...
 
-* zero or more keyword/value pairs may be appended
-* keyword = *mode* or *cutoff* or *cutoff/multi* or *multi/reduce* or *group* or *vel*
+* one or more keyword/value pairs may be appended
+* keyword = *mode* or *cutoff* or *cutoff/multi* or *group* or *reduce/multi* or *vel*
 
   .. parsed-literal::
 

doc/src/commands_list.rst

@@ -56,6 +56,7 @@ Commands
    kspace_modify
    kspace_style
    label
+   labelmap
    lattice
    log
    mass

doc/src/compute.rst

@@ -6,7 +6,7 @@ compute command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID style args
 
@@ -33,8 +33,8 @@ they are calculated from information about atoms on the current
 timestep or iteration, though a compute may internally store some
 information about a previous state of the system.  Defining a compute
 does not perform a computation.  Instead computes are invoked by other
-LAMMPS commands as needed, e.g. to calculate a temperature needed for
-a thermostat fix or to generate thermodynamic or dump file output.
+LAMMPS commands as needed (e.g., to calculate a temperature needed for
+a thermostat fix or to generate thermodynamic or dump file output).
 See the :doc:`Howto output <Howto_output>` page for a summary of
 various LAMMPS output options, many of which involve computes.
 
@@ -45,15 +45,15 @@ underscores.
 
 Computes calculate one of three styles of quantities: global,
 per-atom, or local.  A global quantity is one or more system-wide
-values, e.g. the temperature of the system.  A per-atom quantity is
-one or more values per atom, e.g. the kinetic energy of each atom.
+values (e.g., the temperature of the system).  A per-atom quantity is
+one or more values per atom (e.g., the kinetic energy of each atom).
 Per-atom values are set to 0.0 for atoms not in the specified compute
 group.  Local quantities are calculated by each processor based on the
-atoms it owns, but there may be zero or more per atom, e.g. a list of
-bond distances.  Computes that produce per-atom quantities have the
-word "atom" in their style, e.g. *ke/atom*\ .  Computes that produce
-local quantities have the word "local" in their style,
-e.g. *bond/local*\ .  Styles with neither "atom" or "local" in their
+atoms it owns, but there may be zero or more per atom (e.g., a list of
+bond distances).  Computes that produce per-atom quantities have the
+word "atom" in their style (e.g., *ke/atom*\ ).  Computes that produce
+local quantities have the word "local" in their style
+(e.g., *bond/local*\ ).  Styles with neither "atom" or "local" in their
 style produce global quantities.
 
 Note that a single compute can produce either global or per-atom or
@@ -64,8 +64,8 @@ compute page will explain.
 Global, per-atom, and local quantities each come in three kinds: a
 single scalar value, a vector of values, or a 2d array of values.  The
 doc page for each compute describes the style and kind of values it
-produces, e.g. a per-atom vector.  Some computes produce more than one
-kind of a single style, e.g. a global scalar and a global vector.
+produces (e.g., a per-atom vector).  Some computes produce more than one
+kind of a single style (e.g., a global scalar and a global vector).
 
 When a compute quantity is accessed, as in many of the output commands
 discussed below, it can be referenced via the following bracket
@@ -80,14 +80,14 @@ notation, where ID is the ID of the compute:
 +-------------+--------------------------------------------+
 
 In other words, using one bracket reduces the dimension of the
-quantity once (vector -> scalar, array -> vector).  Using two brackets
-reduces the dimension twice (array -> scalar).  Thus a command that
-uses scalar compute values as input can also process elements of a
+quantity once (vector :math:`\to` scalar, array :math:`\to` vector).  Using two
+brackets reduces the dimension twice (array :math:`\to` scalar).  Thus a
+command that uses scalar compute values as input can also process elements of a
 vector or array.
 
 Note that commands and :doc:`variables <variable>` which use compute
-quantities typically do not allow for all kinds, e.g. a command may
-require a vector of values, not a scalar.  This means there is no
+quantities typically do not allow for all kinds (e.g., a command may
+require a vector of values, not a scalar).  This means there is no
 ambiguity about referring to a compute quantity as c_ID even if it
 produces, for example, both a scalar and vector.  The doc pages for
 various commands explain the details.
@@ -111,14 +111,14 @@ ways:
 
 The results of computes that calculate global quantities can be either
 "intensive" or "extensive" values.  Intensive means the value is
-independent of the number of atoms in the simulation,
-e.g. temperature.  Extensive means the value scales with the number of
-atoms in the simulation, e.g. total rotational kinetic energy.
+independent of the number of atoms in the simulation
+(e.g., temperature).  Extensive means the value scales with the number of
+atoms in the simulation (e.g., total rotational kinetic energy).
 :doc:`Thermodynamic output <thermo_style>` will normalize extensive
 values by the number of atoms in the system, depending on the
 "thermo_modify norm" setting.  It will not normalize intensive values.
-If a compute value is accessed in another way, e.g. by a
-:doc:`variable <variable>`, you may want to know whether it is an
+If a compute value is accessed in another way (e.g., by a
+:doc:`variable <variable>`), you may want to know whether it is an
 intensive or extensive value.  See the page for individual
 computes for further info.
 
@@ -187,8 +187,8 @@ The individual style names on the :doc:`Commands compute <Commands_compute>` pag
 * :doc:`cluster/atom <compute_cluster_atom>` - cluster ID for each atom
 * :doc:`cna/atom <compute_cna_atom>` - common neighbor analysis (CNA) for each atom
 * :doc:`cnp/atom <compute_cnp_atom>` - common neighborhood parameter (CNP) for each atom
-* :doc:`com <compute_com>` - center-of-mass of group of atoms
-* :doc:`com/chunk <compute_com_chunk>` - center-of-mass for each chunk
+* :doc:`com <compute_com>` - center of mass of group of atoms
+* :doc:`com/chunk <compute_com_chunk>` - center of mass for each chunk
 * :doc:`contact/atom <compute_contact_atom>` - contact count for each spherical particle
 * :doc:`coord/atom <compute_coord_atom>` - coordination number for each atom
 * :doc:`damage/atom <compute_damage_atom>` - Peridynamic damage for each atom
@@ -198,10 +198,10 @@ The individual style names on the :doc:`Commands compute <Commands_compute>` pag
 * :doc:`dipole <compute_dipole>` - dipole vector and total dipole
 * :doc:`dipole/chunk <compute_dipole_chunk>` - dipole vector and total dipole for each chunk
 * :doc:`displace/atom <compute_displace_atom>` - displacement of each atom
-* :doc:`dpd <compute_dpd>` -
-* :doc:`dpd/atom <compute_dpd_atom>` -
+* :doc:`dpd <compute_dpd>` - total values of internal conductive energy, internal mechanical energy, chemical energy, and harmonic average of internal temperature
+* :doc:`dpd/atom <compute_dpd_atom>` - per-particle values of internal conductive energy, internal mechanical energy, chemical energy, and internal temperature
 * :doc:`edpd/temp/atom <compute_edpd_temp_atom>` - per-atom temperature for each eDPD particle in a group
-* :doc:`efield/atom <compute_efield_atom>` -
+* :doc:`efield/atom <compute_efield_atom>` - electric field at each atom
 * :doc:`entropy/atom <compute_entropy_atom>` - pair entropy fingerprint of each atom
 * :doc:`erotate/asphere <compute_erotate_asphere>` - rotational energy of aspherical particles
 * :doc:`erotate/rigid <compute_erotate_rigid>` - rotational energy of rigid bodies
@@ -213,7 +213,7 @@ The individual style names on the :doc:`Commands compute <Commands_compute>` pag
 * :doc:`fep/ta <compute_fep_ta>` - compute free energies for a test area perturbation
 * :doc:`force/tally <compute_tally>` - force between two groups of atoms via the tally callback mechanism
 * :doc:`fragment/atom <compute_cluster_atom>` - fragment ID for each atom
-* :doc:`global/atom <compute_global_atom>` -
+* :doc:`global/atom <compute_global_atom>` - assign global values to each atom from arrays of global values
 * :doc:`group/group <compute_group_group>` - energy/force between two groups of atoms
 * :doc:`gyration <compute_gyration>` - radius of gyration of group of atoms
 * :doc:`gyration/chunk <compute_gyration_chunk>` - radius of gyration for each chunk
@@ -232,7 +232,7 @@ The individual style names on the :doc:`Commands compute <Commands_compute>` pag
 * :doc:`ke/atom/eff <compute_ke_atom_eff>` - per-atom translational and radial kinetic energy in the electron force field model
 * :doc:`ke/eff <compute_ke_eff>` - kinetic energy of a group of nuclei and electrons in the electron force field model
 * :doc:`ke/rigid <compute_ke_rigid>` - translational kinetic energy of rigid bodies
-* :doc:`mliap <compute_mliap>` - gradients of energy and forces w.r.t. model parameters and related quantities for training machine learning interatomic potentials
+* :doc:`mliap <compute_mliap>` - gradients of energy and forces with respect to model parameters and related quantities for training machine learning interatomic potentials
 * :doc:`momentum <compute_momentum>` - translational momentum
 * :doc:`msd <compute_msd>` - mean-squared displacement of group of atoms
 * :doc:`msd/chunk <compute_msd_chunk>` - mean-squared displacement for each chunk
@@ -254,35 +254,35 @@ The individual style names on the :doc:`Commands compute <Commands_compute>` pag
 * :doc:`property/chunk <compute_property_chunk>` - extract various per-chunk attributes
 * :doc:`property/local <compute_property_local>` - convert local attributes to localvectors/arrays
 * :doc:`ptm/atom <compute_ptm_atom>` - determines the local lattice structure based on the Polyhedral Template Matching method
-* :doc:`rdf <compute_rdf>` - radial distribution function g(r) histogram of group of atoms
+* :doc:`rdf <compute_rdf>` - radial distribution function :math:`g(r)` histogram of group of atoms
 * :doc:`reduce <compute_reduce>` - combine per-atom quantities into a single global value
 * :doc:`reduce/chunk <compute_reduce_chunk>` - reduce per-atom quantities within each chunk
 * :doc:`reduce/region <compute_reduce>` - same as compute reduce, within a region
 * :doc:`rigid/local <compute_rigid_local>` - extract rigid body attributes
 * :doc:`saed <compute_saed>` - electron diffraction intensity on a mesh of reciprocal lattice nodes
 * :doc:`slice <compute_slice>` - extract values from global vector or array
-* :doc:`smd/contact/radius <compute_smd_contact_radius>` -
+* :doc:`smd/contact/radius <compute_smd_contact_radius>` - contact radius for Smooth Mach Dynamics
 * :doc:`smd/damage <compute_smd_damage>` - damage status of SPH particles in Smooth Mach Dynamics
-* :doc:`smd/hourglass/error <compute_smd_hourglass_error>` -
+* :doc:`smd/hourglass/error <compute_smd_hourglass_error>` - error associated with approximated relative separation in Smooth Mach Dynamics
 * :doc:`smd/internal/energy <compute_smd_internal_energy>` - per-particle enthalpy in Smooth Mach Dynamics
 * :doc:`smd/plastic/strain <compute_smd_plastic_strain>` - equivalent plastic strain per particle in Smooth Mach Dynamics
 * :doc:`smd/plastic/strain/rate <compute_smd_plastic_strain_rate>` - time rate of the equivalent plastic strain in Smooth Mach Dynamics
 * :doc:`smd/rho <compute_smd_rho>` - per-particle mass density in Smooth Mach Dynamics
 * :doc:`smd/tlsph/defgrad <compute_smd_tlsph_defgrad>` - deformation gradient in Smooth Mach Dynamics
 * :doc:`smd/tlsph/dt <compute_smd_tlsph_dt>` - CFL-stable time increment per particle in Smooth Mach Dynamics
-* :doc:`smd/tlsph/num/neighs <compute_smd_tlsph_num_neighs>` -
-* :doc:`smd/tlsph/shape <compute_smd_tlsph_shape>` -
-* :doc:`smd/tlsph/strain <compute_smd_tlsph_strain>` -
-* :doc:`smd/tlsph/strain/rate <compute_smd_tlsph_strain_rate>` -
+* :doc:`smd/tlsph/num/neighs <compute_smd_tlsph_num_neighs>` - number of particles inside the smoothing kernel radius for Smooth Mach Dynamics
+* :doc:`smd/tlsph/shape <compute_smd_tlsph_shape>` - current shape of the volume of a particle for Smooth Mach Dynamics
+* :doc:`smd/tlsph/strain <compute_smd_tlsph_strain>` - Green--Lagrange strain tensor for Smooth Mach Dynamics
+* :doc:`smd/tlsph/strain/rate <compute_smd_tlsph_strain_rate>` - rate of strain for Smooth Mach Dynamics
 * :doc:`smd/tlsph/stress <compute_smd_tlsph_stress>` - per-particle Cauchy stress tensor for SPH particles
-* :doc:`smd/triangle/vertices <compute_smd_triangle_vertices>` -
+* :doc:`smd/triangle/vertices <compute_smd_triangle_vertices>` - coordinates of vertices corresponding to the triangle elements of a mesh for Smooth Mach Dynamics
 * :doc:`smd/ulsph/effm <compute_smd_ulsph_effm>` - per-particle effective shear modulus
-* :doc:`smd/ulsph/num/neighs <compute_smd_ulsph_num_neighs>` -
-* :doc:`smd/ulsph/strain <compute_smd_ulsph_strain>` -
-* :doc:`smd/ulsph/strain/rate <compute_smd_ulsph_strain_rate>` -
+* :doc:`smd/ulsph/num/neighs <compute_smd_ulsph_num_neighs>` - number of neighbor particles inside the smoothing kernel radius for Smooth Mach Dynamics
+* :doc:`smd/ulsph/strain <compute_smd_ulsph_strain>` - logarithmic strain tensor for Smooth Mach Dynamics
+* :doc:`smd/ulsph/strain/rate <compute_smd_ulsph_strain_rate>` - logarithmic strain rate for Smooth Mach Dynamics
 * :doc:`smd/ulsph/stress <compute_smd_ulsph_stress>` - per-particle Cauchy stress tensor and von Mises equivalent stress in Smooth Mach Dynamics
 * :doc:`smd/vol <compute_smd_vol>` - per-particle volumes and their sum in Smooth Mach Dynamics
-* :doc:`snap <compute_sna_atom>` - gradients of SNAP energy and forces w.r.t. linear coefficients and related quantities for fitting SNAP potentials
+* :doc:`snap <compute_sna_atom>` - gradients of SNAP energy and forces with respect to linear coefficients and related quantities for fitting SNAP potentials
 * :doc:`sna/atom <compute_sna_atom>` - bispectrum components for each atom
 * :doc:`sna/grid <compute_sna_atom>` - global array of bispectrum components on a regular grid
 * :doc:`sna/grid/local <compute_sna_atom>` - local array of bispectrum components on a regular grid
@@ -308,7 +308,7 @@ The individual style names on the :doc:`Commands compute <Commands_compute>` pag
 * :doc:`temp/cs <compute_temp_cs>` - temperature based on the center-of-mass velocity of atom pairs that are bonded to each other
 * :doc:`temp/deform <compute_temp_deform>` - temperature excluding box deformation velocity
 * :doc:`temp/deform/eff <compute_temp_deform_eff>` - temperature excluding box deformation velocity in the electron force field model
-* :doc:`temp/drude <compute_temp_drude>` - temperature of Core-Drude pairs
+* :doc:`temp/drude <compute_temp_drude>` - temperature of Core--Drude pairs
 * :doc:`temp/eff <compute_temp_eff>` - temperature of a group of nuclei and electrons in the electron force field model
 * :doc:`temp/partial <compute_temp_partial>` - temperature excluding one or more dimensions of velocity
 * :doc:`temp/profile <compute_temp_profile>` - temperature excluding a binned velocity profile
@@ -324,7 +324,7 @@ The individual style names on the :doc:`Commands compute <Commands_compute>` pag
 * :doc:`vcm/chunk <compute_vcm_chunk>` - velocity of center-of-mass for each chunk
 * :doc:`viscosity/cos <compute_viscosity_cos>` - velocity profile under cosine-shaped acceleration
 * :doc:`voronoi/atom <compute_voronoi_atom>` - Voronoi volume and neighbors for each atom
-* :doc:`xrd <compute_xrd>` - x-ray diffraction intensity on a mesh of reciprocal lattice nodes
+* :doc:`xrd <compute_xrd>` - X-ray diffraction intensity on a mesh of reciprocal lattice nodes
 
 Restrictions
 """"""""""""
@@ -333,7 +333,9 @@ Restrictions
 Related commands
 """"""""""""""""
 
-:doc:`uncompute <uncompute>`, :doc:`compute_modify <compute_modify>`, :doc:`fix ave/atom <fix_ave_atom>`, :doc:`fix ave/time <fix_ave_time>`, :doc:`fix ave/histo <fix_ave_histo>`
+:doc:`uncompute <uncompute>`, :doc:`compute_modify <compute_modify>`,
+:doc:`fix ave/atom <fix_ave_atom>`, :doc:`fix ave/time <fix_ave_time>`,
+:doc:`fix ave/histo <fix_ave_histo>`
 
 Default
 """""""

doc/src/compute_ackland_atom.rst

@@ -6,7 +6,7 @@ compute ackland/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID ackland/atom keyword/value
 
@@ -17,7 +17,7 @@ Syntax
 
   .. parsed-literal::
 
-       *legacy* yes/no = use (\ *yes*\ ) or do not use (\ *no*\ ) legacy ackland algorithm implementation
+       *legacy* args = *yes* or *no* = use (\ *yes*\ ) or do not use (\ *no*\ ) legacy Ackland algorithm implementation
 
 Examples
 """"""""

doc/src/compute_adf.rst

@@ -6,7 +6,7 @@ compute adf command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID adf Nbin itype1 jtype1 ktype1 Rjinner1 Rjouter1 Rkinner1 Rkouter1 ...
 
@@ -16,10 +16,10 @@ Syntax
 * itypeN = central atom type for Nth ADF histogram (see asterisk form below)
 * jtypeN = J atom type for Nth ADF histogram (see asterisk form below)
 * ktypeN = K atom type for Nth ADF histogram (see asterisk form below)
-* RjinnerN =  inner radius of J atom shell for Nth ADF histogram (distance units)
-* RjouterN =  outer radius of J atom shell for Nth ADF histogram (distance units)
+* RjinnerN = inner radius of J atom shell for Nth ADF histogram (distance units)
+* RjouterN = outer radius of J atom shell for Nth ADF histogram (distance units)
 * RkinnerN = inner radius of K atom shell for Nth ADF histogram (distance units)
-* RkouterN =  outer radius of K atom shell for Nth ADF histogram (distance units)
+* RkouterN = outer radius of K atom shell for Nth ADF histogram (distance units)
 * zero or one keyword/value pairs may be appended
 * keyword = *ordinate*
 
@@ -177,8 +177,8 @@ Output info
 """""""""""
 
 This compute calculates a global array with the number of rows =
-*Nbins*, and the number of columns = 1 + 2\*Ntriples, where Ntriples is the
-number of I,J,K triples specified.  The first column has the bin
+*Nbins* and the number of columns = :math:`1 + 2 \times` *Ntriples*, where *Ntriples*
+is the number of I,J,K triples specified.  The first column has the bin
 coordinate (angle-related ordinate at midpoint of bin). Each subsequent column has
 the two ADF values for a specific set of (\ *itypeN*,\ *jtypeN*,\ *ktypeN*\ )
 interactions, as described above.  These values can be used
@@ -192,10 +192,10 @@ The first column of array values is the angle-related ordinate, either
 the angle in degrees or radians, or the cosine of the angle.  Each
 subsequent pair of columns gives the first and second kinds of ADF
 for a specific set of (\ *itypeN*,\ *jtypeN*,\ *ktypeN*\ ). The values
-in the first ADF column are normalized numbers >= 0.0,
+in the first ADF column are normalized numbers :math:`\ge 0.0`,
 whose integral w.r.t. the ordinate is 1,
 i.e. the first ADF is a normalized probability distribution.
-The values in the second ADF column are also numbers >= 0.0.
+The values in the second ADF column are also numbers :math:`\ge 0.0`.
 They are the cumulative density distribution of angles per atom.
 By definition, this ADF is monotonically increasing from zero to
 a maximum value equal to the average total number of

doc/src/compute_angle.rst

@@ -6,7 +6,7 @@ compute angle command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID angle
 
@@ -35,12 +35,12 @@ the hybrid sub-styles.
 Output info
 """""""""""
 
-This compute calculates a global vector of length N where N is the number of
-sub_styles defined by the :doc:`angle_style hybrid <angle_style>` command,
-which can be accessed by indices 1-N.  These values can be used by any command
-that uses global scalar or vector values from a compute as input.  See the
-:doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
-options.
+This compute calculates a global vector of length *N*, where *N* is the number
+of sub_styles defined by the :doc:`angle_style hybrid <angle_style>` command,
+which can be accessed by indices 1 through *N*.  These values can be used by
+any command that uses global scalar or vector values from a compute as input.
+See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS
+output options.
 
 The vector values are "extensive" and will be in energy
 :doc:`units <units>`.

doc/src/compute_angle_local.rst

@@ -6,7 +6,7 @@ compute angle/local command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID angle/local value1 value2 ... keyword args ...
 
@@ -47,7 +47,7 @@ interactions.  The number of datums generated, aggregated across all
 processors, equals the number of angles in the system, modified by the
 group parameter as explained below.
 
-The value *theta* is the angle for the 3 atoms in the interaction.
+The value *theta* is the angle for the three atoms in the interaction.
 
 The value *eng* is the interaction energy for the angle.
 
@@ -65,8 +65,8 @@ Note that the value of theta for each angle which stored in the
 internal variable is in radians, not degrees.
 
 As an example, these commands can be added to the bench/in.rhodo
-script to compute the cosine and cosine\^2 of every angle in the system
-and output the statistics in various ways:
+script to compute the cosine and cosine-squared of every angle in the
+system and output the statistics in various ways:
 
 .. code-block:: LAMMPS
 
@@ -83,19 +83,20 @@ and output the statistics in various ways:
 
    fix 10 all ave/histo 10 10 100 -1 1 20 c_2[3] mode vector file tmp.histo
 
-The :doc:`dump local <dump>` command will output the energy, angle,
-cosine(angle), cosine\^2(angle) for every angle in the system.  The
-:doc:`thermo_style <thermo_style>` command will print the average of
-those quantities via the :doc:`compute reduce <compute_reduce>` command
-with thermo output.  And the :doc:`fix ave/histo <fix_ave_histo>`
-command will histogram the cosine(angle) values and write them to a
+The :doc:`dump local <dump>` command will output the potential energy
+(:math:`\phi`), the angle (:math:`\theta`), :math:`\cos(\theta`), and
+:math:`\cos^2(\theta)` for every angle :math:`\theta` in the system.
+The :doc:`thermo_style <thermo_style>` command will print the
+average of those quantities via the :doc:`compute reduce <compute_reduce>`
+command with thermo output.  And the :doc:`fix ave/histo <fix_ave_histo>`
+command will histogram the :math:`\cos(\theta)` values and write them to a
 file.
 
 ----------
 
 The local data stored by this command is generated by looping over all
 the atoms owned on a processor and their angles.  An angle will only
-be included if all 3 atoms in the angle are in the specified compute
+be included if all three atoms in the angle are in the specified compute
 group.  Any angles that have been broken (see the
 :doc:`angle_style <angle_style>` command) by setting their angle type to
 0 are not included.  Angles that have been turned off (see the :doc:`fix shake <fix_shake>` or :doc:`delete_bonds <delete_bonds>` commands) by

doc/src/compute_angmom_chunk.rst

@@ -6,7 +6,7 @@ compute angmom/chunk command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID angmom/chunk chunkID
 
@@ -72,8 +72,8 @@ Output info
 """""""""""
 
 This compute calculates a global array where the number of rows = the
-number of chunks *Nchunk* as calculated by the specified :doc:`compute chunk/atom <compute_chunk_atom>` command.  The number of columns =
-3 for the 3 xyz components of the angular momentum for each chunk.
+number of chunks *Nchunk* as calculated by the specified :doc:`compute chunk/atom <compute_chunk_atom>` command.  The number of columns = 3 for the three
+(*x*, *y*, *z*) components of the angular momentum for each chunk.
 These values can be accessed by any command that uses global array
 values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
 options.

doc/src/compute_ave_sphere_atom.rst

@@ -9,7 +9,7 @@ Accelerator Variants: *ave/sphere/atom/kk*
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID ave/sphere/atom keyword values ...
 
@@ -37,13 +37,13 @@ Description
 
 Define a computation that calculates the local mass density and
 temperature for each atom based on its neighbors inside a spherical
-cutoff.  If an atom has M neighbors, then its local mass density is
-calculated as the sum of its mass and its M neighbor masses, divided
+cutoff.  If an atom has :math:`M` neighbors, then its local mass density is
+calculated as the sum of its mass and its :math:`M` neighbor masses, divided
 by the volume of the cutoff sphere (or circle in 2d).  The local
 temperature of the atom is calculated as the temperature of the
-collection of M+1 atoms, after subtracting the center-of-mass velocity
-of the M+1 atoms from each of the M+1 atom's velocities.  This is
-effectively the thermal velocity of the neighborhood of the central
+collection of :math:`M+1` atoms, after subtracting the center-of-mass velocity
+of the :math:`M+1` atoms from each of the :math:`M+1` atom's velocities.  This
+is effectively the thermal velocity of the neighborhood of the central
 atom, similar to :doc:`compute temp/com <compute_temp_com>`.
 
 The optional keyword *cutoff* defines the distance cutoff used when

doc/src/compute_basal_atom.rst

@@ -6,7 +6,7 @@ compute basal/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID basal/atom
 
@@ -47,12 +47,12 @@ in examples/PACKAGES/basal.
 Output info
 """""""""""
 
-This compute calculates a per-atom array with 3 columns, which can be
-accessed by indices 1-3 by any command that uses per-atom values from
+This compute calculates a per-atom array with three columns, which can be
+accessed by indices 1--3 by any command that uses per-atom values from
 a compute as input.  See the :doc:`Howto output <Howto_output>` doc page
 for an overview of LAMMPS output options.
 
-The per-atom vector values are unitless since the 3 columns represent
+The per-atom vector values are unitless since the three columns represent
 components of a unit vector.
 
 Restrictions

doc/src/compute_body_local.rst

@@ -6,7 +6,7 @@ compute body/local command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID body/local input1 input2 ...
 
@@ -33,7 +33,7 @@ Description
 """""""""""
 
 Define a computation that calculates properties of individual body
-sub-particles.  The number of datums generated, aggregated across all
+sub-particles.  The number of data generated, aggregated across all
 processors, equals the number of body sub-particles plus the number of
 non-body particles in the system, modified by the group parameter as
 explained below.  See the :doc:`Howto body <Howto_body>` page for
@@ -41,8 +41,8 @@ more details on using body particles.
 
 The local data stored by this command is generated by looping over all
 the atoms.  An atom will only be included if it is in the group.  If
-the atom is a body particle, then its N sub-particles will be looped
-over, and it will contribute N datums to the count of datums.  If it
+the atom is a body particle, then its :math:`N` sub-particles will be looped
+over, and it will contribute :math:`N` data to the count of data.  If it
 is not a body particle, it will contribute 1 datum.
 
 For both body particles and non-body particles, the *id* keyword
@@ -64,8 +64,8 @@ by the :doc:`atom_style body <atom_style>`, determines how many fields
 exist and what they are.  See the :doc:`Howto_body <Howto_body>` doc
 page for details of the different styles.
 
-Here is an example of how to output body information using the :doc:`dump local <dump>` command with this compute.  If fields 1,2,3 for the
-body sub-particles are x,y,z coordinates, then the dump file will be
+Here is an example of how to output body information using the :doc:`dump local <dump>` command with this compute.  If fields 1, 2, and 3 for the
+body sub-particles are (*x*, *y*, *z*) coordinates, then the dump file will be
 formatted similar to the output of a :doc:`dump atom or custom <dump>`
 command.
 
@@ -79,7 +79,7 @@ Output info
 
 This compute calculates a local vector or local array depending on the
 number of keywords.  The length of the vector or number of rows in the
-array is the number of datums as described above.  If a single keyword
+array is the number of data as described above.  If a single keyword
 is specified, a local vector is produced.  If two or more keywords are
 specified, a local array is produced where the number of columns = the
 number of keywords.  The vector or array can be accessed by any

doc/src/compute_bond.rst

@@ -6,7 +6,7 @@ compute bond command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID bond
 
@@ -35,10 +35,13 @@ or more of the hybrid sub-styles.
 Output info
 """""""""""
 
-This compute calculates a global vector of length N where N is the
-number of sub_styles defined by the :doc:`bond_style hybrid <bond_style>` command, which can be accessed by indices 1-N.
+This compute calculates a global vector of length :math:`N`, where :math:`N`
+is the number of sub_styles defined by the
+:doc:`bond_style hybrid <bond_style>` command,
+which can be accessed by indices 1 through :math:`N`.
 These values can be used by any command that uses global scalar or
-vector values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
+vector values from a compute as input.  See the
+:doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
 options.
 
 The vector values are "extensive" and will be in energy

doc/src/compute_bond_local.rst

@@ -6,7 +6,7 @@ compute bond/local command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID bond/local value1 value2 ... keyword args ...
 
@@ -35,8 +35,8 @@ Syntax
 
 .. parsed-literal::
 
-     *set* args = dist name
-       dist = only currently allowed arg
+     *set* args = *dist* name
+       *dist* = only currently allowed arg
        name = name of variable to set with distance (dist)
 
 Examples
@@ -49,7 +49,7 @@ Examples
 
    compute 1 all bond/local dist fx fy fz
 
-   compute 1 all angle/local dist v_distsq set dist d
+   compute 1 all bond/local dist v_distsq set dist d
 
 Description
 """""""""""
@@ -82,32 +82,34 @@ relative to the center of mass (COM) velocity of the 2 atoms in the
 bond.
 
 The value *engvib* is the vibrational kinetic energy of the two atoms
-in the bond, which is simply 1/2 m1 v1\^2 + 1/2 m2 v2\^2, where v1 and
-v2 are the magnitude of the velocity of the 2 atoms along the bond
-direction, after the COM velocity has been subtracted from each.
-
-The value *engrot* is the rotational kinetic energy of the two atoms
-in the bond, which is simply 1/2 m1 v1\^2 + 1/2 m2 v2\^2, where v1 and
-v2 are the magnitude of the velocity of the 2 atoms perpendicular to
-the bond direction, after the COM velocity has been subtracted from
+in the bond, which is simply :math:`\frac12 m_1 v_1^2 + \frac12 m_2 v_2^2,`
+where :math:`v_1` and :math:`v_2` are the magnitude of the velocity of the two
+atoms along the bond direction, after the COM velocity has been subtracted from
 each.
 
-The value *engtrans* is the translational kinetic energy associated
-with the motion of the COM of the system itself, namely 1/2 (m1+m2)
-Vcm\^2 where Vcm = magnitude of the velocity of the COM.
+The value *engrot* is the rotational kinetic energy of the two atoms
+in the bond, which is simply :math:`\frac12 m_1 v_1^2 + \frac12 m_2 v_2^2,`
+where :math:`v_1` and :math:`v_2` are the magnitude of the velocity of the two
+atoms perpendicular to the bond direction, after the COM velocity has been
+subtracted from each.
 
-Note that these 3 kinetic energy terms are simply a partitioning of
-the summed kinetic energy of the 2 atoms themselves.  I.e. total KE =
-1/2 m1 v1\^2 + 1/2 m2 v2\^2 = engvib + engrot + engtrans, where v1,v2
-are the magnitude of the velocities of the 2 atoms, without any
-adjustment for the COM velocity.
+The value *engtrans* is the translational kinetic energy associated
+with the motion of the COM of the system itself, namely :math:`\frac12(m_1+m_2)
+V_{\mathrm{cm}}^2`, where `Vcm` = magnitude of the velocity of the COM.
+
+Note that these three kinetic energy terms are simply a partitioning of
+the summed kinetic energy of the two atoms themselves.  That is, the total
+kinetic energy is
+:math:`\frac12 m_1 v_1^2 + \frac12 m_2 v_2^2` = engvib + engrot + engtrans,
+where :math:`v_1` and :math:`v_2` are the magnitude of the velocities of the
+two atoms, without any adjustment for the COM velocity.
 
 The value *omega* is the magnitude of the angular velocity of the
 two atoms around their COM position.
 
 The value *velvib* is the magnitude of the relative velocity of the
 two atoms in the bond towards each other.  A negative value means the
-2 atoms are moving toward each other; a positive value means they are
+two atoms are moving toward each other; a positive value means they are
 moving apart.
 
 The value *v_name* can be used together with the *set* keyword to
@@ -121,7 +123,7 @@ directly.  The *set* keyword is used to identify the name of this
 other variable associated with theta.
 
 As an example, these commands can be added to the bench/in.rhodo
-script to compute the distance\^2 of every bond in the system and
+script to compute the length\ :math:`^2` of every bond in the system and
 output the statistics in various ways:
 
 .. code-block:: LAMMPS
@@ -138,12 +140,12 @@ output the statistics in various ways:
 
    fix 10 all ave/histo 10 10 100 0 6 20 c_2[3] mode vector file tmp.histo
 
-The :doc:`dump local <dump>` command will output the energy, distance,
-distance\^2 for every bond in the system.  The
+The :doc:`dump local <dump>` command will output the energy, length,
+and length\ :math:`^2` for every bond in the system.  The
 :doc:`thermo_style <thermo_style>` command will print the average of
 those quantities via the :doc:`compute reduce <compute_reduce>` command
-with thermo output.  And the :doc:`fix ave/histo <fix_ave_histo>`
-command will histogram the distance\^2 values and write them to a file.
+with thermo output, and the :doc:`fix ave/histo <fix_ave_histo>`
+command will histogram the length\ :math:`^2` values and write them to a file.
 
 ----------
 

doc/src/compute_born_matrix.rst

@@ -6,20 +6,26 @@ compute born/matrix command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID born/matrix keyword value ...
 
 * ID, group-ID are documented in :doc:`compute <compute>` command
 * born/matrix = style name of this compute command
-* zero or more keyword/value pairs may be appended
+* zero or more keywords or keyword/value pairs may be appended
 
   .. parsed-literal::
 
-     keyword = *numdiff*
+     keyword = *numdiff* or *pair* or *bond* or *angle* or *dihedral* or *improper*
        *numdiff* values = delta virial-ID
          delta = magnitude of strain (dimensionless)
          virial-ID = ID of pressure compute for virial (string)
+         (*numdiff* cannot be used with any other keyword)
+       *pair* = compute pair-wise contributions
+       *bond* = compute bonding contributions
+       *angle* = compute angle contributions
+       *dihedral* = compute dihedral contributions
+       *improper* = compute improper contributions
 
 Examples
 """"""""
@@ -36,8 +42,8 @@ Description
 .. versionadded:: 4May2022
 
 Define a compute that calculates
-:math:`\frac{\partial{}^2U}{\partial\varepsilon_{i}\partial\varepsilon_{j}}` the
-second derivatives of the potential energy :math:`U` w.r.t. strain
+:math:`\frac{\partial{}^2U}{\partial\varepsilon_{i}\partial\varepsilon_{j}},` the
+second derivatives of the potential energy :math:`U` with respect to the strain
 tensor :math:`\varepsilon` elements. These values are related to:
 
 .. math::
@@ -69,14 +75,14 @@ whose 21 independent elements are output in this order:
 
 .. math::
 
-    \begin{matrix}
+    \begin{bmatrix}
        C_{1}  & C_{7}   & C_{8}  & C_{9}  & C_{10} & C_{11} \\
        C_{7}  & C_{2}   & C_{12} & C_{13} & C_{14} & C_{15} \\
        \vdots & C_{12}  & C_{3}  & C_{16} & C_{17} & C_{18} \\
        \vdots & C_{13}  & C_{16} & C_{4}  & C_{19} & C_{20} \\
        \vdots & \vdots  & \vdots & C_{19} & C_{5}  & C_{21} \\
        \vdots & \vdots  & \vdots & \vdots & C_{21} & C_{6}
-    \end{matrix}
+    \end{bmatrix}
 
 in this matrix the indices of :math:`C_{k}` value are the corresponding element
 :math:`k` in the global vector output by this compute. Each term comes from the sum
@@ -169,7 +175,7 @@ requiring that it use the virial keyword e.g.
 **Output info:**
 
 This compute calculates a global vector with 21 values that are
-the second derivatives of the potential energy w.r.t. strain.
+the second derivatives of the potential energy with respect to strain.
 The values are in energy units.
 The values are ordered as explained above. These values can be used
 by any command that uses global values from a compute as input. See
@@ -188,7 +194,7 @@ the :doc:`Build package <Build_package>` page for more info.
 
 The Born term can be decomposed as a product of two terms. The first one is a
 general term which depends on the configuration. The second one is specific to
-every interaction composing your force field (non-bonded, bonds, angle...).
+every interaction composing your force field (non-bonded, bonds, angle, ...).
 Currently not all LAMMPS interaction styles implement the *born_matrix* method
 giving first and second order derivatives and LAMMPS will exit with an error if
 this compute is used with such interactions unless the *numdiff* option is

doc/src/compute_centro_atom.rst

@@ -6,17 +6,17 @@ compute centro/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID centro/atom lattice keyword value ...
 
 * ID, group-ID are documented in :doc:`compute <compute>` command
-  centro/atom = style name of this compute command
-  lattice = *fcc* or *bcc* or N = # of neighbors per atom to include
+* centro/atom = style name of this compute command
+* lattice = *fcc* or *bcc* or N = # of neighbors per atom to include
 * zero or more keyword/value pairs may be appended
 * keyword = *axes*
 
-.. parsed-literal::
+  .. parsed-literal::
 
      *axes* value = *no* or *yes*
        *no* = do not calculate 3 symmetry axes
@@ -83,12 +83,13 @@ atoms with smallest contributions to the centrosymmetry parameter,
 i.e. the two most symmetric pairs of atoms.  The third vector is
 normal to the first two by the right-hand rule.  All three vectors are
 normalized to unit length.  For FCC crystals, the first two vectors
-will lie along a <110> direction, while the third vector will lie
-along either a <100> or <111> direction.  For HCP crystals, the first
-two vectors will lie along <1000> directions, while the third vector
-will lie along <0001>.  This provides a simple way to measure local
-orientation in HCP structures.  In general, the *axes* keyword can be
-used to estimate the orientation of symmetry axes in the neighborhood
+will lie along a :math:`\langle110\rangle` direction, while the third vector
+will lie along either a :math:`\langle100\rangle` or :math:`\langle111\rangle`
+direction.  For HCP crystals, the first two vectors will lie along
+:math:`\langle1000\rangle` directions, while the third vector
+will lie along :math:`\langle0001\rangle`.  This provides a simple way to
+measure local orientation in HCP structures.  In general, the *axes* keyword
+can be used to estimate the orientation of symmetry axes in the neighborhood
 of any atom.
 
 Only atoms within the cutoff of the pairwise neighbor list are
@@ -96,7 +97,7 @@ considered as possible neighbors.  Atoms not in the compute group are
 included in the :math:`N` neighbors used in this calculation.
 
 The neighbor list needed to compute this quantity is constructed each
-time the calculation is performed (e.g. each time a snapshot of atoms
+time the calculation is performed (e.g., each time a snapshot of atoms
 is dumped).  Thus it can be inefficient to compute/dump this quantity
 too frequently or to have multiple compute/dump commands, each with a
 *centro/atom* style.
@@ -111,11 +112,11 @@ options.
 
 If the *axes* keyword setting is *yes*, then a per-atom array is
 calculated. The first column is the centrosymmetry parameter.  The
-next three columns are the x, y, and z components of the first
+next three columns are the *x*, *y*, and *z* components of the first
 symmetry axis, followed by the second, and third symmetry axes in
-columns 5-7 and 8-10.
+columns 5--7 and 8--10.
 
-The centrosymmetry values are unitless values >= 0.0.  Their magnitude
+The centrosymmetry values are unitless values :math:`\ge 0.0`. Their magnitude
 depends on the lattice style due to the number of contributing neighbor
 pairs in the summation in the formula above.  And it depends on the
 local defects surrounding the central atom, as described above.  For

doc/src/compute_chunk_atom.rst

@@ -6,7 +6,7 @@ compute chunk/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID chunk/atom style args keyword values ...
 
@@ -15,7 +15,7 @@ Syntax
 
   .. parsed-literal::
 
-     style = *bin/1d* or *bin/2d* or *bin/3d* or *bin/sphere* or *type* or *molecule* or c_ID, c_ID[I], f_ID, f_ID[I], v_name
+     style = *bin/1d* or *bin/2d* or *bin/3d* or *bin/sphere* or *bin/cylinder* or *type* or *molecule* or c_ID, c_ID[I], f_ID, f_ID[I], v_name
        *bin/1d* args = dim origin delta
          dim = *x* or *y* or *z*
          origin = *lower* or *center* or *upper* or coordinate value (distance units)
@@ -49,7 +49,7 @@ Syntax
          v_name = per-atom vector calculated by an atom-style variable with name
 
 * zero or more keyword/values pairs may be appended
-* keyword = *region* or *nchunk* or *static* or *compress* or *bound* or *discard* or *pbc* or *units*
+* keyword = *region* or *nchunk* or *limit* or *ids* or *compress* or *discard* or *bound* or *pbc* or *units*
 
   .. parsed-literal::
 
@@ -74,7 +74,7 @@ Syntax
          no = keep atoms with out-of-range chunk IDs by assigning a valid chunk ID
          mixed = keep or discard such atoms according to spatial binning rule
        *bound* values = x/y/z lo hi
-         x/y/z = *x* or *y* or *z* to bound sptial bins in this dimension
+         x/y/z = *x* or *y* or *z* to bound spatial bins in this dimension
          lo = *lower* or coordinate value (distance units)
          hi = *upper* or coordinate value (distance units)
        *pbc* value = *no* or *yes*
@@ -150,14 +150,14 @@ The *binning* styles perform a spatial binning of atoms, and assign an
 atom the chunk ID corresponding to the bin number it is in.  *Nchunk*
 is set to the number of bins, which can change if the simulation box
 size changes.  This also depends on the setting of the *units*
-keyword; e.g. for *reduced* units the number of chunks may not change
-even if the box size does.
+keyword (e.g., for *reduced* units the number of chunks may not change
+even if the box size does).
 
 The *bin/1d*, *bin/2d*, and *bin/3d* styles define bins as 1d layers
 (slabs), 2d pencils, or 3d boxes.  The *dim*, *origin*, and *delta*
 settings are specified 1, 2, or 3 times.  For 2d or 3d bins, there is
-no restriction on specifying dim = x before dim = y or z, or dim = y
-before dim = z.  Bins in a particular *dim* have a bin size in that
+no restriction on specifying dim = *x* before dim = *y* or *z*, or dim = *y*
+before dim = *z*.  Bins in a particular *dim* have a bin size in that
 dimension given by *delta*\ .  In each dimension, bins are defined
 relative to a specified *origin*, which may be the lower/upper edge of
 the simulation box (in that dimension), or its center point, or a
@@ -170,10 +170,11 @@ boxes aligned with the xyz coordinate axes.  For triclinic
 (non-orthogonal) simulation boxes, the bin faces are parallel to the
 tilted faces of the simulation box.  See the :doc:`Howto triclinic <Howto_triclinic>` page for a discussion of the
 geometry of triclinic boxes in LAMMPS.  As described there, a tilted
-simulation box has edge vectors a,b,c.  In that nomenclature, bins in
-the x dimension have faces with normals in the "b" cross "c"
-direction.  Bins in y have faces normal to the "a" cross "c"
-direction.  And bins in z have faces normal to the "a" cross "b"
+simulation box has edge vectors :math:`\vec a`, :math:`\vec b`, and
+:math:`\vec c`.  In that nomenclature, bins in
+the *x* dimension have faces with normals in the :math:`\vec b \times \vec c`
+direction, bins in *y* have faces normal to the :math:`\vec a \times \vec c`
+direction, and bins in *z* have faces normal to the :math:`\vec a \times \vec b`
 direction.  Note that in order to define the size and position of
 these bins in an unambiguous fashion, the *units* option must be set
 to *reduced* when using a triclinic simulation box, as noted below.
@@ -181,46 +182,46 @@ to *reduced* when using a triclinic simulation box, as noted below.
 The meaning of *origin* and *delta* for triclinic boxes is as follows.
 Consider a triclinic box with bins that are 1d layers or slabs in the
 x dimension.  No matter how the box is tilted, an *origin* of 0.0
-means start layers at the lower "b" cross "c" plane of the simulation
-box and an *origin* of 1.0 means to start layers at the upper "b"
-cross "c" face of the box.  A *delta* value of 0.1 in *reduced* units
-means there will be 10 layers from 0.0 to 1.0, regardless of the
-current size or shape of the simulation box.
+means start layers at the lower :math:`\vec b \times \vec c` plane of the
+simulation box and an *origin* of 1.0 means to start layers at the upper
+:math:`\vec b \times \vec c` face of the box.  A *delta* value of 0.1 in
+*reduced* units means there will be 10 layers from 0.0 to 1.0, regardless of
+the current size or shape of the simulation box.
 
 The *bin/sphere* style defines a set of spherical shell bins around
 the origin (\ *xorig*,\ *yorig*,\ *zorig*\ ), using *nsbin* bins with radii
 equally spaced between *srmin* and *srmax*\ .  This is effectively a 1d
 vector of bins.  For example, if *srmin* = 1.0 and *srmax* = 10.0 and
-*nsbin* = 9, then the first bin spans 1.0 < r < 2.0, and the last bin
-spans 9.0 < r 10.0.  The geometry of the bins is the same whether the
-simulation box is orthogonal or triclinic; i.e. the spherical shells
+*nsbin* = 9, then the first bin spans :math:`1.0 < r < 2.0`, and the last bin
+spans :math:`9.0 < r < 10.0`.  The geometry of the bins is the same whether the
+simulation box is orthogonal or triclinic (i.e., the spherical shells
 are not tilted or scaled differently in different dimensions to
-transform them into ellipsoidal shells.
+transform them into ellipsoidal shells).
 
 The *bin/cylinder* style defines bins for a cylinder oriented along
 the axis *dim* with the axis coordinates in the other two radial
-dimensions at (\ *c1*,\ *c2*\ ).  For dim = x, c1/c2 = y/z; for dim = y,
-c1/c2 = x/z; for dim = z, c1/c2 = x/y.  This is effectively a 2d array
-of bins.  The first dimension is along the cylinder axis, the second
-dimension is radially outward from the cylinder axis.  The bin size
-and positions along the cylinder axis are specified by the *origin*
-and *delta* values, the same as for the *bin/1d*, *bin/2d*, and
-*bin/3d* styles.  There are *ncbin* concentric circle bins in the
+dimensions at (\ *c1*,\ *c2*\ ).  For dim = *x*, :math:`c_1/c_2 = y/z`;
+for dim = *y*, :math:`c_1/c_2 = x/z`; for dim = *z*,
+:math:`c_1/c_2 = x/y`.  This is effectively a 2d array of bins.  The first
+dimension is along the cylinder axis, the second dimension is radially outward
+from the cylinder axis.  The bin size and positions along the cylinder axis are
+specified by the *origin* and *delta* values, the same as for the *bin/1d*,
+*bin/2d*, and *bin/3d* styles.  There are *ncbin* concentric circle bins in the
 radial direction from the cylinder axis with radii equally spaced
 between *crmin* and *crmax*\ .  For example, if *crmin* = 1.0 and
-*crmax* = 10.0 and *ncbin* = 9, then the first bin spans 1.0 < r <
-2.0, and the last bin spans 9.0 < r 10.0.  The geometry of the bins in
+*crmax* = 10.0 and *ncbin* = 9, then the first bin spans :math:`1.0 < r < 2.0`
+and the last bin spans :math:`9.0 < r < 10.0`.  The geometry of the bins in
 the radial dimensions is the same whether the simulation box is
-orthogonal or triclinic; i.e. the concentric circles are not tilted or
+orthogonal or triclinic (i.e., the concentric circles are not tilted or
 scaled differently in the two different dimensions to transform them
-into ellipses.
+into ellipses).
 
 The created bins (and hence the chunk IDs) are numbered consecutively
 from 1 to the number of bins = *Nchunk*\ .  For *bin2d* and *bin3d*, the
 numbering varies most rapidly in the first dimension (which could be
-x, y, or z), next rapidly in the second dimension, and most slowly in the
+*x*, *y*, or *z*), next rapidly in the second dimension, and most slowly in the
 third dimension.  For *bin/sphere*, the bin with smallest radii is chunk
-1 and the bni with largest radii is chunk Nchunk = *ncbin*\ .  For
+1 and the bin with largest radii is chunk Nchunk = *ncbin*\ .  For
 *bin/cylinder*, the numbering varies most rapidly in the dimension
 along the cylinder axis and most slowly in the radial direction.
 
@@ -236,8 +237,8 @@ assigned to the atom.
 ----------
 
 The *type* style uses the atom type as the chunk ID.  *Nchunk* is set
-to the number of atom types defined for the simulation, e.g. via the
-:doc:`create_box <create_box>` or :doc:`read_data <read_data>` commands.
+to the number of atom types defined for the simulation (e.g., via the
+:doc:`create_box <create_box>` or :doc:`read_data <read_data>` commands).
 
 ----------
 
@@ -264,8 +265,8 @@ on a quantity calculated and stored by a compute, fix, or variable.
 In each case, it must be a per-atom quantity.  In each case the
 referenced floating point values are converted to an integer chunk ID
 as follows.  The floating point value is truncated (rounded down) to
-an integer value.  If the integer value is <= 0, then a chunk ID of 0
-is assigned to the atom.  If the integer value is > 0, it becomes the
+an integer value.  If the integer value is :math:`\le 0`, then a chunk ID of 0
+is assigned to the atom.  If the integer value is :math:`> 0`, it becomes the
 chunk ID to the atom.  *Nchunk* is set to the largest chunk ID.  Note
 that this excludes atoms which are not in the specified group or
 optional region.
@@ -362,7 +363,7 @@ If *limit* is set to *Nc* = 0, then no limit is imposed on *Nchunk*,
 though the *compress* keyword can still be used to reduce *Nchunk*, as
 described below.
 
-If *Nc* > 0, then the effect of the *limit* keyword depends on whether
+If *Nc* :math:`>` 0, then the effect of the *limit* keyword depends on whether
 the *compress* keyword is also used with a setting of *yes*, and
 whether the *compress* keyword is specified before the *limit* keyword
 or after.
@@ -374,7 +375,7 @@ First, here is what occurs if *compress yes* is not set.  If *limit*
 is set to *Nc max*, then *Nchunk* is reset to the smaller of *Nchunk*
 and *Nc*\ .  If *limit* is set to *Nc exact*, then *Nchunk* is reset to
 *Nc*, whether the original *Nchunk* was larger or smaller than *Nc*\ .
-If *Nchunk* shrank due to the *limit* setting, then atom chunk IDs >
+If *Nchunk* shrank due to the *limit* setting, then atom chunk IDs :math:`>`
 *Nchunk* will be reset to 0 or *Nchunk*, depending on the setting of
 the *discard* keyword.  If *Nchunk* grew, there will simply be some
 chunks with no atoms assigned to them.
@@ -384,22 +385,22 @@ If *compress yes* is set, and the *compress* keyword comes before the
 described below, which resets *Nchunk*\ .  The *limit* keyword is then
 applied to the new *Nchunk* value, exactly as described in the
 preceding paragraph.  Note that in this case, all atoms will end up
-with chunk IDs <= *Nc*, but their original values (e.g. molecule ID or
-compute/fix/variable) may have been > *Nc*, because of the compression
-operation.
+with chunk IDs :math:`\le` *Nc*, but their original values (e.g., molecule ID
+or compute/fix/variable) may have been :math:`>` *Nc*, because of the
+compression operation.
 
 If *compress yes* is set, and the *compress* keyword comes after the
 *limit* keyword, then the *limit* value of *Nc* is applied first to
-the uncompressed value of *Nchunk*, but only if *Nc* < *Nchunk*
+the uncompressed value of *Nchunk*, but only if *Nc* :math:`<` *Nchunk*
 (whether *Nc max* or *Nc exact* is used).  This effectively means all
-atoms with chunk IDs > *Nc* have their chunk IDs reset to 0 or *Nc*,
+atoms with chunk IDs :math:`>` *Nc* have their chunk IDs reset to 0 or *Nc*,
 depending on the setting of the *discard* keyword.  The compression
 operation is then performed, which may shrink *Nchunk* further.  If
-the new *Nchunk* < *Nc* and *limit* = *Nc exact* is specified, then
+the new *Nchunk* :math:`<` *Nc* and *limit* = *Nc exact* is specified, then
 *Nchunk* is reset to *Nc*, which results in extra chunks with no atoms
 assigned to them.  Note that in this case, all atoms will end up with
-chunk IDs <= *Nc*, and their original values (e.g. molecule ID or
-compute/fix/variable value) will also have been <= *Nc*\ .
+chunk IDs :math:`\le` *Nc*, and their original values (e.g., molecule ID or
+compute/fix/variable value) will also have been :math:`\le` *Nc*\ .
 
 ----------
 
@@ -601,7 +602,8 @@ be used.  For non-orthogonal (triclinic) simulation boxes, only the
 *reduced* option may be used.
 
 A *box* value selects standard distance units as defined by the
-:doc:`units <units>` command, e.g. Angstroms for units = real or metal.
+:doc:`units <units>` command (e.g., :math:`\mathrm{\mathring A}`
+for units = *real* or *metal*).
 A *lattice* value means the distance units are in lattice spacings.
 The :doc:`lattice <lattice>` command must have been previously used to
 define the lattice spacing.  A *reduced* value means normalized
@@ -615,8 +617,8 @@ scaled by the lattice spacing or reduced value of the *x* dimension.
 
 Note that for the *bin/cylinder* style, the radii *crmin* and *crmax*
 are scaled by the lattice spacing or reduced value of the first
-dimension perpendicular to the cylinder axis.  E.g. y for an x-axis
-cylinder, x for a y-axis cylinder, and x for a z-axis cylinder.
+dimension perpendicular to the cylinder axis (e.g., *y* for an *x*-axis
+cylinder, *x* for a *y*-axis cylinder, and *x* for a *z*-axis cylinder).
 
 ----------
 

doc/src/compute_chunk_spread_atom.rst

@@ -6,7 +6,7 @@ compute chunk/spread/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID chunk/spread/atom chunkID input1 input2 ...
 
@@ -18,10 +18,10 @@ Syntax
 
   .. parsed-literal::
 
-       c_ID = global vector calculated by a compute with ID
-       c_ID[I] = Ith column of global array calculated by a compute with ID, I can include wildcard (see below)
-       f_ID = global vector calculated by a fix with ID
-       f_ID[I] = Ith column of global array calculated by a fix with ID, I can include wildcard (see below)
+     c_ID = global vector calculated by a compute with ID
+     c_ID[I] = Ith column of global array calculated by a compute with ID, I can include wildcard (see below)
+     f_ID = global vector calculated by a fix with ID
+     f_ID[I] = Ith column of global array calculated by a fix with ID, I can include wildcard (see below)
 
 Examples
 """"""""

doc/src/compute_cluster_atom.rst

@@ -14,7 +14,7 @@ compute aggregate/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID cluster/atom cutoff
    compute ID group-ID fragment/atom keyword value ...
@@ -69,9 +69,9 @@ fragments or not, based on the *yes* or *no* setting.  If the setting
 is *no* (the default), their fragment IDs are set to 0.
 
 An aggregate is defined by combining the rules for clusters and
-fragments, i.e. a set of atoms, where each of it is within the cutoff
+fragments (i.e., a set of atoms, where each of them is within the cutoff
 distance from one or more atoms within a fragment that is part of
-the same cluster. This measure can be used to track molecular assemblies
+the same cluster). This measure can be used to track molecular assemblies
 like micelles.
 
 For computes *cluster/atom* and *aggregate/atom* a neighbor list
@@ -92,9 +92,9 @@ style computes.
    does not apply when using long-range coulomb (\ *coul/long*, *coul/msm*,
    *coul/wolf* or similar.  One way to get around this would be to set
    special_bond scaling factors to very tiny numbers that are not exactly
-   zero (e.g. 1.0e-50). Another workaround is to write a dump file, and
-   use the :doc:`rerun <rerun>` command to compute the clusters for
-   snapshots in the dump file.  The rerun script can use a
+   zero (e.g., :math:`1.0 \times 10^{-50}`). Another workaround is to write a
+   dump file and use the :doc:`rerun <rerun>` command to compute the clusters
+   for snapshots in the dump file.  The rerun script can use a
    :doc:`special_bonds <special_bonds>` command that includes all pairs in
    the neighbor list.
 
@@ -114,7 +114,7 @@ any command that uses per-atom values from a compute as input.  See
 the :doc:`Howto output <Howto_output>` page for an overview of
 LAMMPS output options.
 
-The per-atom vector values will be an ID > 0, as explained above.
+The per-atom vector values will be an ID :math:`> 0`, as explained above.
 
 Restrictions
 """"""""""""
@@ -129,5 +129,5 @@ Related commands
 Default
 """""""
 
-The default for fragment/atom is single no.
+The default for fragment/atom is single=no.
 

doc/src/compute_cna_atom.rst

@@ -6,7 +6,7 @@ compute cna/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID cna/atom cutoff
 
@@ -44,20 +44,22 @@ performed on mono-component systems.
 
 The CNA calculation can be sensitive to the specified cutoff value.
 You should insure the appropriate nearest neighbors of an atom are
-found within the cutoff distance for the presumed crystal structure.
-E.g. 12 nearest neighbor for perfect FCC and HCP crystals, 14 nearest
-neighbors for perfect BCC crystals.  These formulas can be used to
+found within the cutoff distance for the presumed crystal structure
+(e.g., 12 nearest neighbor for perfect FCC and HCP crystals, 14 nearest
+neighbors for perfect BCC crystals).  These formulas can be used to
 obtain a good cutoff distance:
 
 .. math::
 
-  r_{c}^{fcc} = & \frac{1}{2} \left(\frac{\sqrt{2}}{2} + 1\right) \mathrm{a} \simeq 0.8536 \:\mathrm{a} \\
-  r_{c}^{bcc} = & \frac{1}{2}(\sqrt{2} + 1) \mathrm{a} \simeq 1.207 \:\mathrm{a} \\
-  r_{c}^{hcp} = & \frac{1}{2}\left(1+\sqrt{\frac{4+2x^{2}}{3}}\right) \mathrm{a}
+  r_{c}^{\mathrm{fcc}} = & \frac{1}{2} \left(\frac{\sqrt{2}}{2} + 1\right) a
+    \approx 0.8536 a \\
+  r_{c}^{\mathrm{bcc}} = & \frac{1}{2}(\sqrt{2} + 1) a
+    \approx 1.207 a \\
+  r_{c}^{\mathrm{hcp}} = & \frac{1}{2}\left(1+\sqrt{\frac{4+2x^{2}}{3}}\right) a
 
-where a is the lattice constant for the crystal structure concerned
-and in the HCP case, x = (c/a) / 1.633, where 1.633 is the ideal c/a
-for HCP crystals.
+where :math:`a` is the lattice constant for the crystal structure concerned
+and in the HCP case, :math:`x = (c/a) / 1.633`, where 1.633 is the ideal
+:math:`c/a` for HCP crystals.
 
 Also note that since the CNA calculation in LAMMPS uses the neighbors
 of an owned atom to find the nearest neighbors of a ghost atom, the

doc/src/compute_cnp_atom.rst

@@ -6,7 +6,7 @@ compute cnp/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID cnp/atom cutoff
 
@@ -28,7 +28,7 @@ Define a computation that calculates the Common Neighborhood
 Parameter (CNP) for each atom in the group.  In solid-state systems
 the CNP is a useful measure of the local crystal structure
 around an atom and can be used to characterize whether the
-atom is part of a perfect lattice, a local defect (e.g. a dislocation
+atom is part of a perfect lattice, a local defect (e.g., a dislocation
 or stacking fault), or at a surface.
 
 The value of the CNP parameter will be 0.0 for atoms not in the
@@ -40,7 +40,7 @@ This parameter is computed using the following formula from
 
 .. math::
 
-   Q_{i} = \frac{1}{n_i}\sum_{j = 1}^{n_i} \left | \sum_{k = 1}^{n_{ij}}  \vec{R}_{ik} + \vec{R}_{jk} \right | ^{2}
+   Q_{i} = \frac{1}{n_i}\sum_{j = 1}^{n_i} \left\lVert \sum_{k = 1}^{n_{ij}}  \vec{R}_{ik} + \vec{R}_{jk} \right\rVert^{2}
 
 where the index *j* goes over the :math:`n_i` nearest neighbors of atom
 *i*, and the index *k* goes over the :math:`n_{ij}` common nearest neighbors
@@ -58,13 +58,15 @@ obtain a good cutoff distance:
 
 .. math::
 
-  r_{c}^{fcc} = & \frac{1}{2} \left(\frac{\sqrt{2}}{2} + 1\right) \mathrm{a} \simeq 0.8536 \:\mathrm{a} \\
-  r_{c}^{bcc} = & \frac{1}{2}(\sqrt{2} + 1) \mathrm{a} \simeq 1.207 \:\mathrm{a} \\
-  r_{c}^{hcp} = & \frac{1}{2}\left(1+\sqrt{\frac{4+2x^{2}}{3}}\right) \mathrm{a}
+  r_{c}^{\mathrm{fcc}} = & \frac{1}{2} \left(\frac{\sqrt{2}}{2} + 1\right) a
+    \approx 0.8536 a \\
+  r_{c}^{\mathrm{bcc}} = & \frac{1}{2}(\sqrt{2} + 1) a
+    \approx 1.207 a \\
+  r_{c}^{\mathrm{hcp}} = & \frac{1}{2}\left(1+\sqrt{\frac{4+2x^{2}}{3}}\right) a
 
-where a is the lattice constant for the crystal structure concerned
-and in the HCP case, x = (c/a) / 1.633, where 1.633 is the ideal c/a
-for HCP crystals.
+where :math:`a` is the lattice constant for the crystal structure concerned
+and in the HCP case, :math:`x = (c/a) / 1.633`, where 1.633 is the ideal
+:math:`c/a` for HCP crystals.
 
 Also note that since the CNP calculation in LAMMPS uses the neighbors
 of an owned atom to find the nearest neighbors of a ghost atom, the
@@ -81,7 +83,7 @@ cutoff is the argument used with the compute cnp/atom command.  LAMMPS
 will issue a warning if this is not the case.
 
 The neighbor list needed to compute this quantity is constructed each
-time the calculation is performed (e.g. each time a snapshot of atoms
+time the calculation is performed (e.g., each time a snapshot of atoms
 is dumped).  Thus it can be inefficient to compute/dump this quantity
 too frequently or to have multiple compute/dump commands, each with a
 *cnp/atom* style.
@@ -103,9 +105,9 @@ values:
    BCC lattice = 0.0
    HCP lattice = 4.4
 
-   FCC (111) surface ~ 13.0
-   FCC (100) surface ~ 26.5
-   FCC dislocation core ~ 11
+   FCC (111) surface = 13.0
+   FCC (100) surface = 26.5
+   FCC dislocation core = 11
 
 Restrictions
 """"""""""""

doc/src/compute_com.rst

@@ -6,7 +6,7 @@ compute com command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID com
 
@@ -28,7 +28,7 @@ of atoms, including all effects due to atoms passing through periodic
 boundaries.
 
 A vector of three quantities is calculated by this compute, which
-are the x,y,z coordinates of the center of mass.
+are the :math:`(x,y,z)` coordinates of the center of mass.
 
 .. note::
 
@@ -38,13 +38,14 @@ are the x,y,z coordinates of the center of mass.
    "unwrapped" coordinates.  See the Atoms section of the
    :doc:`read_data <read_data>` command for a discussion of image flags and
    how they are set for each atom.  You can reset the image flags
-   (e.g. to 0) before invoking this compute by using the :doc:`set image <set>` command.
+   (e.g., to 0) before invoking this compute by using the
+   :doc:`set image <set>` command.
 
 Output info
 """""""""""
 
 This compute calculates a global vector of length 3, which can be
-accessed by indices 1-3 by any command that uses global vector values
+accessed by indices 1--3 by any command that uses global vector values
 from a compute as input.  See the :doc:`Howto output <Howto_output>` doc
 page for an overview of LAMMPS output options.
 

doc/src/compute_com_chunk.rst

@@ -6,7 +6,7 @@ compute com/chunk command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID com/chunk chunkID
 
@@ -34,7 +34,7 @@ molecule or atoms in a spatial bin.  See the :doc:`compute chunk/atom <compute_c
 doc pages for details of how chunks can be defined and examples of how
 they can be used to measure properties of a system.
 
-This compute calculates the x,y,z coordinates of the center-of-mass
+This compute calculates the :math:`(x,y,z)` coordinates of the center of mass
 for each chunk, which includes all effects due to atoms passing through
 periodic boundaries.
 
@@ -54,7 +54,8 @@ non-zero chunk IDs.
    for a discussion of "unwrapped" coordinates.  See the Atoms section of
    the :doc:`read_data <read_data>` command for a discussion of image flags
    and how they are set for each atom.  You can reset the image flags
-   (e.g. to 0) before invoking this compute by using the :doc:`set image <set>` command.
+   (e.g., to 0) before invoking this compute by using the
+   :doc:`set image <set>` command.
 
 The simplest way to output the results of the compute com/chunk
 calculation to a file is to use the :doc:`fix ave/time <fix_ave_time>`
@@ -70,8 +71,8 @@ Output info
 """""""""""
 
 This compute calculates a global array where the number of rows = the
-number of chunks *Nchunk* as calculated by the specified :doc:`compute chunk/atom <compute_chunk_atom>` command.  The number of columns =
-3 for the x,y,z center-of-mass coordinates of each chunk.  These
+number of chunks *Nchunk* as calculated by the specified :doc:`compute chunk/atom <compute_chunk_atom>` command.  The number of columns is
+3 for the :math:`(x,y,z)` center-of-mass coordinates of each chunk.  These
 values can be accessed by any command that uses global array values
 from a compute as input.  See the :doc:`Howto output <Howto_output>` doc
 page for an overview of LAMMPS output options.

doc/src/compute_contact_atom.rst

@@ -6,7 +6,7 @@ compute contact/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID contact/atom group2-ID
 
@@ -44,11 +44,11 @@ accessed by any command that uses per-atom values from a compute as
 input.  See the :doc:`Howto output <Howto_output>` page for an
 overview of LAMMPS output options.
 
-The per-atom vector values will be a number >= 0.0, as explained
+The per-atom vector values will be a number :math:`\ge 0.0`, as explained
 above.
 
 The optional *group2-ID* argument allows to specify from which group atoms
-contribute to the coordination number. Default setting is group 'all'.
+contribute to the coordination number. Default setting is group 'all.'
 
 Restrictions
 """"""""""""

doc/src/compute_coord_atom.rst

@@ -9,23 +9,23 @@ Accelerator Variants: *coord/atom/kk*
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
-   compute ID group-ID coord/atom cstyle args ...
+   compute ID group-ID coord/atom style args ...
 
 * ID, group-ID are documented in :doc:`compute <compute>` command
 * coord/atom = style name of this compute command
-* cstyle = *cutoff* or *orientorder*
+* style = *cutoff* or *orientorder*
 
   .. parsed-literal::
 
-       *cutoff* args = cutoff [group group2-ID] typeN
-         cutoff = distance within which to count coordination neighbors (distance units)
-         group *group2-ID* = select group-ID to restrict which atoms to consider for coordination number (optional)
-         typeN = atom type for Nth coordination count (see asterisk form below)
-       *orientorder* args = orientorderID threshold
-         orientorderID = ID of an orientorder/atom compute
-         threshold = minimum value of the product of two "connected" atoms
+     *cutoff* args = cutoff [*group* group2-ID] typeN
+       cutoff = distance within which to count coordination neighbors (distance units)
+       *group* group2-ID = select group-ID to restrict which atoms to consider for coordination number (optional)
+       typeN = atom type for Nth coordination count (see asterisk form below)
+     *orientorder* args = orientorderID threshold
+       orientorderID = ID of an orientorder/atom compute
+       threshold = minimum value of the product of two "connected" atoms
 
 Examples
 """"""""
@@ -54,7 +54,7 @@ neighboring atoms, unless selected by type, type range, or group option,
 are included in the coordination number tally.
 
 The optional *group* keyword allows to specify from which group atoms
-contribute to the coordination number. Default setting is group 'all'.
+contribute to the coordination number. Default setting is group 'all.'
 
 The *typeN* keywords allow specification of which atom types
 contribute to each coordination number.  One coordination number is
@@ -65,15 +65,15 @@ includes atoms of all types (same as the "\*" format, see below).
 The *typeN* keywords can be specified in one of two ways.  An explicit
 numeric value can be used, as in the second example above.  Or a
 wild-card asterisk can be used to specify a range of atom types.  This
-takes the form "\*" or "\*n" or "n\*" or "m\*n".  If N = the number of
+takes the form "\*" or "\*n" or "m\*" or "m\*n".  If :math:`N` is the number of
 atom types, then an asterisk with no numeric values means all types
-from 1 to N.  A leading asterisk means all types from 1 to n
-(inclusive).  A trailing asterisk means all types from n to N
+from 1 to :math:`N`.  A leading asterisk means all types from 1 to n
+(inclusive).  A trailing asterisk means all types from m to :math:`N`
 (inclusive).  A middle asterisk means all types from m to n
 (inclusive).
 
 The *orientorder* cstyle calculates the number of "connected" neighbor
-atoms J around each central atom I.  For this *cstyle*, connected is
+atoms *j* around each central atom *i*\ .  For this *cstyle*, connected is
 defined by the orientational order parameter calculated by the
 :doc:`compute orientorder/atom <compute_orientorder_atom>` command.
 This *cstyle* thus allows one to apply the ten Wolde's criterion to
@@ -84,16 +84,16 @@ The ID of the previously specified :doc:`compute orientorder/atom <compute_orien
 calculate components of the *Ybar_lm* vector for each atoms, as
 described in its documentation.  Note that orientorder/atom compute
 defines its own criteria for identifying neighboring atoms.  If the
-scalar product (*Ybar_lm(i)*,*Ybar_lm(j)*), calculated by the
+scalar product (*Ybar_lm(i)*, *Ybar_lm(j)*), calculated by the
 orientorder/atom compute is larger than the specified *threshold*,
-then I and J are connected, and the coordination value of I is
+then *i* and *j* are connected, and the coordination value of *i* is
 incremented by one.
 
 For all *cstyle* settings, all coordination values will be 0.0 for
 atoms not in the specified compute group.
 
 The neighbor list needed to compute this quantity is constructed each
-time the calculation is performed (i.e. each time a snapshot of atoms
+time the calculation is performed (i.e., each time a snapshot of atoms
 is dumped).  Thus it can be inefficient to compute/dump this quantity
 too frequently.
 
@@ -127,7 +127,7 @@ For *cstyle* cutoff, this compute can calculate a per-atom vector or
 array.  If single *type1* keyword is specified (or if none are
 specified), this compute calculates a per-atom vector.  If multiple
 *typeN* keywords are specified, this compute calculates a per-atom
-array, with N columns.
+array, with :math:`N` columns.
 
 For *cstyle* orientorder, this compute calculates a per-atom vector.
 
@@ -135,7 +135,7 @@ These values can be accessed by any command that uses per-atom values
 from a compute as input.  See the :doc:`Howto output <Howto_output>` doc
 page for an overview of LAMMPS output options.
 
-The per-atom vector or array values will be a number >= 0.0, as
+The per-atom vector or array values will be a number :math:`\ge 0.0`, as
 explained above.
 
 Restrictions

doc/src/compute_damage_atom.rst

@@ -6,7 +6,7 @@ compute damage/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID damage/atom
 
@@ -48,7 +48,7 @@ any command that uses per-atom values from a compute as input.  See
 the :doc:`Howto output <Howto_output>` page for an overview of
 LAMMPS output options.
 
-The per-atom vector values are unitless numbers (damage) >= 0.0.
+The per-atom vector values are unitless numbers (damage) :math:`\ge 0.0`.
 
 Restrictions
 """"""""""""

doc/src/compute_dihedral.rst

@@ -6,7 +6,7 @@ compute dihedral command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID dihedral
 
@@ -34,10 +34,12 @@ total energy contributed by one or more of the hybrid sub-styles.
 Output info
 """""""""""
 
-This compute calculates a global vector of length N where N is the
-number of sub_styles defined by the :doc:`dihedral_style hybrid <dihedral_style>` command.  which can be accessed by indices
-1-N.  These values can be used by any command that uses global scalar
-or vector values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
+This compute calculates a global vector of length :math:`N`, where :math:`N`
+is the number of sub_styles defined by the
+:doc:`dihedral_style hybrid <dihedral_style>` command, which can be accessed by
+the indices 1 through :math:`N`.  These values can be used by any command that
+uses global scalar or vector values from a compute as input.  See the
+:doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
 options.
 
 The vector values are "extensive" and will be in energy

doc/src/compute_dihedral_local.rst

@@ -6,7 +6,7 @@ compute dihedral/local command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID dihedral/local value1 value2 ... keyword args ...
 
@@ -35,7 +35,6 @@ Examples
 .. code-block:: LAMMPS
 
    compute 1 all dihedral/local phi
-
    compute 1 all dihedral/local phi v_cos set phi p
 
 Description
@@ -46,25 +45,26 @@ interactions.  The number of datums generated, aggregated across all
 processors, equals the number of dihedral angles in the system, modified
 by the group parameter as explained below.
 
-The value *phi* is the dihedral angle, as defined in the diagram on
-the :doc:`dihedral_style <dihedral_style>` doc page.
+The value *phi* (:math:`\phi`) is the dihedral angle, as defined in the diagram
+on the :doc:`dihedral_style <dihedral_style>` doc page.
 
-The value *v_name* can be used together with the *set* keyword to
-compute a user-specified function of the dihedral angle phi.  The
-*name* specified for the *v_name* value is the name of an :doc:`equal-style variable <variable>` which should evaluate a formula based on a
-variable which will store the angle phi.  This other variable must
+The value *v_name* can be used together with the *set* keyword to compute a
+user-specified function of the dihedral angle :math:`\phi`.  The *name*
+specified for the *v_name* value is the name of an
+:doc:`equal-style variable <variable>` which should evaluate a formula based on
+a variable which will store the angle :math:`\phi`.  This other variable must
 be an :doc:`internal-style variable <variable>` defined in the input
 script; its initial numeric value can be anything.  It must be an
 internal-style variable, because this command resets its value
 directly.  The *set* keyword is used to identify the name of this
-other variable associated with phi.
+other variable associated with :math:`\phi`.
 
-Note that the value of phi for each angle which stored in the internal
+Note that the value of :math:`\phi` for each angle which stored in the internal
 variable is in radians, not degrees.
 
 As an example, these commands can be added to the bench/in.rhodo
-script to compute the cosine and cosine\^2 of every dihedral angle in
-the system and output the statistics in various ways:
+script to compute the :math:`\cos\phi` and :math:`\cos^2\phi` of every dihedral
+angle in the system and output the statistics in various ways:
 
 .. code-block:: LAMMPS
 
@@ -81,19 +81,18 @@ the system and output the statistics in various ways:
 
    fix 10 all ave/histo 10 10 100 -1 1 20 c_2[2] mode vector file tmp.histo
 
-The :doc:`dump local <dump>` command will output the angle,
-cosine(angle), cosine\^2(angle) for every dihedral in the system.  The
-:doc:`thermo_style <thermo_style>` command will print the average of
+The :doc:`dump local <dump>` command will output the angle (:math:`\phi`),
+:math:`\cos(\phi)`, and :math:`\cos^2(\phi)` for every dihedral in the system.
+The :doc:`thermo_style <thermo_style>` command will print the average of
 those quantities via the :doc:`compute reduce <compute_reduce>` command
 with thermo output.  And the :doc:`fix ave/histo <fix_ave_histo>`
-command will histogram the cosine(angle) values and write them to a
-file.
+command will histogram the cosine(angle) values and write them to a file.
 
 ----------
 
 The local data stored by this command is generated by looping over all
 the atoms owned on a processor and their dihedrals.  A dihedral will
-only be included if all 4 atoms in the dihedral are in the specified
+only be included if all four atoms in the dihedral are in the specified
 compute group.
 
 Note that as atoms migrate from processor to processor, there will be
@@ -101,7 +100,8 @@ no consistent ordering of the entries within the local vector or array
 from one timestep to the next.  The only consistency that is
 guaranteed is that the ordering on a particular timestep will be the
 same for local vectors or arrays generated by other compute commands.
-For example, dihedral output from the :doc:`compute property/local <compute_property_local>` command can be combined
+For example, dihedral output from the
+:doc:`compute property/local <compute_property_local>` command can be combined
 with data from this command and output by the :doc:`dump local <dump>`
 command in a consistent way.
 
@@ -120,9 +120,10 @@ This compute calculates a local vector or local array depending on the
 number of values.  The length of the vector or number of rows in the
 array is the number of dihedrals.  If a single value is specified, a
 local vector is produced.  If two or more values are specified, a
-local array is produced where the number of columns = the number of
+local array is produced where the number of columns is equal to the number of
 values.  The vector or array can be accessed by any command that uses
-local values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
+local values from a compute as input.  See the
+:doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
 options.
 
 The output for *phi* will be in degrees.

doc/src/compute_dilatation_atom.rst

@@ -6,12 +6,12 @@ compute dilatation/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID dilatation/atom
 
 * ID, group-ID are documented in compute command
-* dilation/atom = style name of this compute command
+* dilatation/atom = style name of this compute command
 
 Examples
 """"""""
@@ -30,13 +30,13 @@ for an overview of LAMMPS commands for Peridynamics modeling.
 For small deformation, dilatation of is the measure of the volumetric
 strain.
 
-The dilatation "theta" for each peridynamic particle I is calculated
-as a sum over its neighbors with unbroken bonds, where the
-contribution of the IJ pair is a function of the change in bond length
+The dilatation :math:`\theta` for each peridynamic particle :math:`i` is
+calculated as a sum over its neighbors with unbroken bonds, where the
+contribution of the :math:`ij` pair is a function of the change in bond length
 (versus the initial length in the reference state), the volume
 fraction of the particles and an influence function.  See the
-`PDLAMMPS user guide <http://www.sandia.gov/~mlparks/papers/PDLAMMPS.pdf>`_ for a formal
-definition of dilatation.
+`PDLAMMPS user guide <http://www.sandia.gov/~mlparks/papers/PDLAMMPS.pdf>`_ for
+a formal definition of dilatation.
 
 This command can only be used with a subset of the Peridynamic :doc:`pair styles <pair_peri>`: peri/lps, peri/ves and peri/eps.
 
@@ -51,13 +51,14 @@ any command that uses per-atom values from a compute as input.  See
 the :doc:`Howto output <Howto_output>` page for an overview of
 LAMMPS output options.
 
-The per-atom vector values are unitless numbers (theta) >= 0.0.
+The per-atom vector values are unitless numbers :math:`(\theta \ge 0.0)`.
 
 Restrictions
 """"""""""""
 
 This compute is part of the PERI package.  It is only enabled if
-LAMMPS was built with that package.  See the :doc:`Build package <Build_package>` page for more info.
+LAMMPS was built with that package.  See the
+:doc:`Build package <Build_package>` page for more info.
 
 Related commands
 """"""""""""""""

doc/src/compute_dipole.rst

@@ -6,13 +6,13 @@ compute dipole command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
-   compute ID group-ID dipole charge-correction
+   compute ID group-ID dipole arg
 
 * ID, group-ID are documented in :doc:`compute <compute>` command
 * dipole = style name of this compute command
-* charge-correction = *mass* or *geometry*, use COM or geometric center for charged chunk correction (optional)
+* arg = *mass* or *geometry* = use COM or geometric center for charged chunk correction (optional)
 
 Examples
 """"""""
@@ -43,7 +43,7 @@ and per-atom dipole moments, if present, contribute to the computed dipole.
    :doc:`dump custom <dump>` command for a discussion of "unwrapped"
    coordinates.  See the Atoms section of the :doc:`read_data
    <read_data>` command for a discussion of image flags and how they are
-   set for each atom.  You can reset the image flags (e.g. to 0) before
+   set for each atom.  You can reset the image flags (e.g., to 0) before
    invoking this compute by using the :doc:`set image <set>` command.
 
 Output info
@@ -55,7 +55,8 @@ dipole vector.  See the :doc:`Howto output <Howto_output>` page for
 an overview of LAMMPS output options.
 
 The computed values are "intensive".  The array values will be in
-dipole units, i.e. charge units times distance :doc:`units <units>`.
+dipole units (i.e., charge :doc:`units <units>` times distance
+:doc:`units <units>`).
 
 Restrictions
 """"""""""""

doc/src/compute_dipole_chunk.rst

@@ -6,14 +6,14 @@ compute dipole/chunk command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
-   compute ID group-ID dipole/chunk chunkID charge-correction
+   compute ID group-ID dipole/chunk chunkID arg
 
 * ID, group-ID are documented in :doc:`compute <compute>` command
 * dipole/chunk = style name of this compute command
 * chunkID = ID of :doc:`compute chunk/atom <compute_chunk_atom>` command
-* charge-correction = *mass* or *geometry*, use COM or geometric center for charged chunk correction (optional)
+* arg = *mass* or *geometry* = use COM or geometric center for charged chunk correction (optional)
 
 Examples
 """"""""
@@ -38,8 +38,8 @@ or atoms in a spatial bin.  See the :doc:`compute chunk/atom
 details of how chunks can be defined and examples of how they can be
 used to measure properties of a system.
 
-This compute calculates the x,y,z coordinates of the dipole vector and
-the total dipole moment for each chunk, which includes all effects due
+This compute calculates the :math:`(x,y,z)` coordinates of the dipole vector
+and the total dipole moment for each chunk, which includes all effects due
 to atoms passing through periodic boundaries. For chunks with a net
 charge the resulting dipole is made position independent by subtracting
 the position vector of the center of mass or geometric center times the
@@ -62,7 +62,7 @@ chunk IDs.
    "unwrapped" coordinates.  See the Atoms section of the
    :doc:`read_data <read_data>` command for a discussion of image flags
    and how they are set for each atom.  You can reset the image flags
-   (e.g. to 0) before invoking this compute by using the :doc:`set image
+   (e.g., to 0) before invoking this compute by using the :doc:`set image
    <set>` command.
 
 The simplest way to output the results of the compute com/chunk
@@ -80,14 +80,15 @@ Output info
 
 This compute calculates a global array where the number of rows = the
 number of chunks *Nchunk* as calculated by the specified :doc:`compute
-chunk/atom <compute_chunk_atom>` command.  The number of columns = 4 for
-the x,y,z dipole vector components and the total dipole of each
+chunk/atom <compute_chunk_atom>` command.  The number of columns is 4 for
+the :math:`(x,y,z)` dipole vector components and the total dipole of each
 chunk. These values can be accessed by any command that uses global
 array values from a compute as input.  See the :doc:`Howto output
 <Howto_output>` page for an overview of LAMMPS output options.
 
 The array values are "intensive".  The array values will be in
-dipole units, i.e. charge units times distance :doc:`units <units>`.
+dipole units (i.e., charge :doc:`units <units>` times distance
+:doc:`units <units>`).
 
 Restrictions
 """"""""""""

doc/src/compute_displace_atom.rst

@@ -6,7 +6,7 @@ compute displace/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID displace/atom
 
@@ -35,9 +35,9 @@ atom in the group from its original (reference) coordinates, including
 all effects due to atoms passing through periodic boundaries.
 
 A vector of four quantities per atom is calculated by this compute.
-The first 3 elements of the vector are the dx,dy,dz displacements.
-The fourth component is the total displacement, i.e. sqrt(dx\*dx + dy\*dy +
-dz\*dz).
+The first three elements of the vector are the :math:`(dx,dy,dz)`
+displacements.  The fourth component is the total displacement
+(i.e., :math:`\sqrt{dx^2 + dy^2 + dz^2}`).
 
 The displacement of an atom is from its original position at the time
 the compute command was issued.  The value of the displacement will be
@@ -50,7 +50,7 @@ the compute command was issued.  The value of the displacement will be
    <dump>` command for a discussion of "unwrapped" coordinates.  See
    the Atoms section of the :doc:`read_data <read_data>` command for a
    discussion of image flags and how they are set for each atom.  You
-   can reset the image flags (e.g. to 0) before invoking this compute
+   can reset the image flags (e.g., to 0) before invoking this compute
    by using the :doc:`set image <set>` command.
 
 .. note::
@@ -60,7 +60,7 @@ the compute command was issued.  The value of the displacement will be
    you should use the same ID for this compute, as in the original run.
    This is so that the fix this compute creates to store per-atom
    quantities will also have the same ID, and thus be initialized
-   correctly with time=0 atom coordinates from the restart file.
+   correctly with time = 0 atom coordinates from the restart file.
 
 ----------
 
@@ -95,14 +95,15 @@ something like the following commands:
                    refresh c_dsp delay 100
 
 The :doc:`dump_modify thresh <dump_modify>` command will only output
-atoms that have displaced more than 0.6 Angstroms on each snapshot
-(assuming metal units).  The dump_modify *refresh* option triggers a
+atoms that have displaced more than :math:`0.6~\mathrm{\mathring A}` on each
+snapshot (assuming metal units).  The dump_modify *refresh* option triggers a
 call to this compute at the end of every dump.
 
-The *refresh* argument for this compute is the ID of an :doc:`atom-style variable <variable>` which calculates a Boolean value (0 or 1)
+The *refresh* argument for this compute is the ID of an
+:doc:`atom-style variable <variable>` which calculates a Boolean value (0 or 1)
 based on the same criterion used by dump_modify thresh.  This compute
-evaluates the atom-style variable.  For each atom that returns 1
-(true), the original (reference) coordinates of the atom (stored by
+evaluates the atom-style variable.  For each atom that returns 1 (true),
+the original (reference) coordinates of the atom (stored by
 this compute) are updated.
 
 The effect of these commands is that a particular atom will only be
@@ -125,8 +126,8 @@ would be empty.
 Output info
 """""""""""
 
-This compute calculates a per-atom array with 4 columns, which can be
-accessed by indices 1-4 by any command that uses per-atom values from
+This compute calculates a per-atom array with four columns, which can be
+accessed by indices 1--4 by any command that uses per-atom values from
 a compute as input.  See the :doc:`Howto output <Howto_output>` doc page
 for an overview of LAMMPS output options.
 

doc/src/compute_dpd.rst

@@ -6,7 +6,7 @@ compute dpd command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID dpd
 
@@ -24,9 +24,9 @@ Description
 """""""""""
 
 Define a computation that accumulates the total internal conductive
-energy (:math:`U^{cond}`), the total internal mechanical energy
-(:math:`U^{mech}`), the total chemical energy (:math:`U^{chem}`)
-and the *harmonic* average of the internal temperature (:math:`\theta_{avg}`)
+energy (:math:`U^{\text{cond}}`), the total internal mechanical energy
+(:math:`U^{\text{mech}}`), the total chemical energy (:math:`U^\text{chem}`)
+and the *harmonic* average of the internal temperature (:math:`\theta_\text{avg}`)
 for the entire system of particles.  See the
 :doc:`compute dpd/atom <compute_dpd_atom>` command if you want
 per-particle internal energies and internal temperatures.
@@ -36,22 +36,24 @@ relations:
 
 .. math::
 
-   U^{cond} = & \displaystyle\sum_{i=1}^{N} u_{i}^{cond} \\
-   U^{mech} = & \displaystyle\sum_{i=1}^{N} u_{i}^{mech} \\
-   U^{chem} = & \displaystyle\sum_{i=1}^{N} u_{i}^{chem} \\
-          U = & \displaystyle\sum_{i=1}^{N} (u_{i}^{cond} + u_{i}^{mech} + u_{i}^{chem}) \\
-   \theta_{avg} = & (\frac{1}{N}\displaystyle\sum_{i=1}^{N} \frac{1}{\theta_{i}})^{-1} \\
+   U^\text{cond} = & \sum_{i=1}^{N} u_{i}^\text{cond} \\
+   U^\text{mech} = & \sum_{i=1}^{N} u_{i}^\text{mech} \\
+   U^\text{chem} = & \sum_{i=1}^{N} u_{i}^\text{chem} \\
+               U = & \sum_{i=1}^{N} (u_{i}^\text{cond}
+                     + u_{i}^\text{mech} + u_{i}^\text{chem}) \\
+   \theta_{avg} = & \biggl(\frac{1}{N}\sum_{i=1}^{N}
+                          \frac{1}{\theta_{i}}\biggr)^{-1} \\
 
-where :math:`N` is the number of particles in the system
+where :math:`N` is the number of particles in the system.
 
 ----------
 
 Output info
 """""""""""
 
-This compute calculates a global vector of length 5 (:math:`U^{cond}`,
-:math:`U^{mech}`, :math:`U^{chem}`, :math:`\theta_{avg}`, :math:`N`),
-which can be accessed by indices 1-5.
+This compute calculates a global vector of length 5 (:math:`U^\text{cond}`,
+:math:`U^\text{mech}`, :math:`U^\text{chem}`, :math:`\theta_\text{avg}`,
+:math:`N`), which can be accessed by indices 1 through 5.
 See the :doc:`Howto output <Howto_output>` page for an overview of
 LAMMPS output options.
 
@@ -61,7 +63,8 @@ Restrictions
 """"""""""""
 
 This command is part of the DPD-REACT package.  It is only enabled if
-LAMMPS was built with that package.  See the :doc:`Build package <Build_package>` page for more info.
+LAMMPS was built with that package.
+See the :doc:`Build package <Build_package>` page for more info.
 
 This command also requires use of the :doc:`atom_style dpd <atom_style>`
 command.

doc/src/compute_dpd_atom.rst

@@ -6,7 +6,7 @@ compute dpd/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID dpd/atom
 
@@ -23,29 +23,28 @@ Examples
 Description
 """""""""""
 
-Define a computation that accesses the per-particle internal
-conductive energy (:math:`u^{cond}`), internal mechanical
-energy (:math:`u^{mech}`), internal chemical energy (:math:`u^{chem}`)
-and internal temperatures (:math:`\theta`) for each particle in a group.
+Define a computation that accesses the per-particle internal conductive energy
+(:math:`u^\text{cond}`), internal mechanical energy (:math:`u^\text{mech}`),
+internal chemical energy (:math:`u^\text{chem}`) and internal temperatures
+(:math:`\theta`) for each particle in a group.
 See the :doc:`compute dpd <compute_dpd>` command if you want the total
 internal conductive energy, the total internal mechanical energy, the
-total chemical energy and
-average internal temperature of the entire system or group of dpd
-particles.
+total chemical energy and average internal temperature of the entire system or
+group of dpd particles.
 
 Output info
 """""""""""
 
-This compute calculates a per-particle array with 4 columns (:math:`u^{cond}`,
-:math:`u^{mech}`, :math:`u^{chem}`, :math:`\theta`), which can be accessed
-by indices 1-4 by any
+This compute calculates a per-particle array with four columns
+(:math:`u^\text{cond}`, :math:`u^\text{mech}`, :math:`u^\text{chem}`,
+:math:`\theta`), which can be accessed by indices 1--4 by any
 command that uses per-particle values from a compute as input.  See
 the :doc:`Howto output <Howto_output>` page for an overview of
 LAMMPS output options.
 
-The per-particle array values will be in energy (:math:`u^{cond}`,
-:math:`u^{mech}`, :math:`u^{chem}`)
-and temperature (:math:`theta`) :doc:`units <units>`.
+The per-particle array values will be in energy (:math:`u^\text{cond}`,
+:math:`u^\text{mech}`, :math:`u^\text{chem}`)
+and temperature (:math:`\theta`) :doc:`units <units>`.
 
 Restrictions
 """"""""""""

doc/src/compute_edpd_temp_atom.rst

@@ -6,7 +6,7 @@ compute edpd/temp/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID edpd/temp/atom
 

doc/src/compute_efield_atom.rst

@@ -6,12 +6,19 @@ compute efield/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
-   compute ID group-ID efield/atom
+   compute ID group-ID efield/atom keyword val
 
 * ID, group-ID are documented in :doc:`compute <compute>` command
 * efield/atom = style name of this compute command
+* zero or more keyword/value pairs may be appended
+* keyword = *pair* or *kspace*
+
+  .. parsed-literal::
+
+     *pair* args = *yes* or *no*
+     *kspace* args = *yes* or *no*
 
 Examples
 """"""""
@@ -23,10 +30,10 @@ Examples
 
 Used in input scripts:
 
-   .. parsed-literal::
+.. parsed-literal::
 
-      examples/PACKAGES/dielectric/in.confined
-      examples/PACKAGES/dielectric/in.nopbc
+   examples/PACKAGES/dielectric/in.confined
+   examples/PACKAGES/dielectric/in.nopbc
 
 Description
 """""""""""

doc/src/compute_entropy_atom.rst

@@ -6,24 +6,23 @@ compute entropy/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID entropy/atom sigma cutoff keyword value ...
 
 * ID, group-ID are documented in :doc:`compute <compute>` command
 * entropy/atom = style name of this compute command
-* sigma = width of gaussians used in the g(r) smoothing
-* cutoff = cutoff for the g(r) calculation
+* sigma = width of Gaussians used in the :math:`g(r)` smoothing
+* cutoff = cutoff for the :math:`g(r)` calculation
 * one or more keyword/value pairs may be appended
 
 .. parsed-literal::
 
    keyword = *avg* or *local*
-     *avg* values = *yes* or *no* cutoff2
-       *yes* = average the pair entropy over neighbors
-       *no* = do not average the pair entropy over neighbors
+     *avg* args = neigh cutoff2
+       neigh value = *yes* or *no* = whether to average the pair entropy over neighbors
        cutoff2 = cutoff for the averaging over neighbors
-     *local* values = *yes* or *no* = use the local density around each atom to normalize the g(r)
+     *local* arg = *yes* or *no* = use the local density around each atom to normalize the g(r)
 
 Examples
 """"""""
@@ -53,31 +52,32 @@ This parameter for atom i is computed using the following formula from
 
    s_S^i=-2\pi\rho k_B \int\limits_0^{r_m} \left [ g(r) \ln g(r) - g(r) + 1 \right ] r^2 dr
 
-where r is a distance, g(r) is the radial distribution function of atom
-i and rho is the density of the system. The g(r) computed for each
-atom i can be noisy and therefore it is smoothed using:
+where :math:`r` is a distance, :math:`g(r)` is the radial distribution function
+of atom :math:`i`, and :math:`\rho` is the density of the system.
+The :math:`g(r)` computed for each atom :math:`i` can be noisy and therefore it
+is smoothed using
 
 .. math::
 
    g_m^i(r) = \frac{1}{4 \pi \rho r^2} \sum\limits_{j} \frac{1}{\sqrt{2 \pi \sigma^2}} e^{-(r-r_{ij})^2/(2\sigma^2)}
 
-where the sum in j goes through the neighbors of atom i, and :math:`\sigma`
-is a parameter to control the smoothing.
+where the sum over :math:`j` goes through the neighbors of atom :math:`i` and
+:math:`\sigma` is a parameter to control the smoothing.
 
 The input parameters are *sigma* the smoothing parameter :math:`\sigma`,
-and the *cutoff* for the calculation of g(r).
+and the *cutoff* for the calculation of :math:`g(r)`.
 
 If the keyword *avg* has the setting *yes*, then this compute also
-averages the parameter over the neighbors  of atom i according to:
+averages the parameter over the neighbors  of atom :math:`i` according to
 
 .. math::
 
-  \left< s_S^i \right>  = \frac{\sum_j s_S^j + s_S^i}{N + 1}
+  \left< s_S^i \right>  = \frac{\sum_j s_S^j + s_S^i}{N + 1},
 
-where the sum j goes over the neighbors of atom i and N is the number
-of neighbors. This procedure provides a sharper distinction between
-order and disorder environments. In this case the input parameter
-*cutoff2* is the cutoff for the averaging over the neighbors and
+where the sum over :math:`j` goes over the neighbors of atom :math:`i` and
+:math:`N` is the number of neighbors. This procedure provides a sharper
+distinction between order and disorder environments. In this case the input
+parameter *cutoff2* is the cutoff for the averaging over the neighbors and
 must also be specified.
 
 If the *avg yes* option is used, the effective cutoff of the neighbor
@@ -90,14 +90,14 @@ to increase the skin of the neighbor list with:
 
 See :doc:`neighbor <neighbor>` for details.
 
-If the *local yes* option is used, the g(r) is normalized by the
+If the *local yes* option is used, the :math:`g(r)` is normalized by the
 local density around each atom, that is to say the density around each
 atom  is the number of neighbors within the neighbor list cutoff divided
 by the corresponding volume. This option can be useful when dealing with
 inhomogeneous systems such as those that have surfaces.
 
 Here are typical input parameters for fcc aluminum (lattice
-constant 4.05 Angstroms),
+constant :math:`4.05~\mathrm{\mathring A}`),
 
 .. parsed-literal::
 
@@ -114,7 +114,8 @@ Output info
 
 By default, this compute calculates the pair entropy value for each
 atom as a per-atom vector, which can be accessed by any command that
-uses per-atom values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
+uses per-atom values from a compute as input.  See the
+:doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
 options.
 
 The pair entropy values have units of the Boltzmann constant. They are

doc/src/compute_erotate_asphere.rst

@@ -6,7 +6,7 @@ compute erotate/asphere command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID erotate/asphere
 
@@ -30,9 +30,9 @@ ellipsoids, or line segments, or triangles.  See the
 for descriptions of these options.
 
 For all 3 types of particles, the rotational kinetic energy is
-computed as 1/2 I w\^2, where I is the inertia tensor for the
-aspherical particle and w is its angular velocity, which is computed
-from its angular momentum if needed.
+computed as :math:`\frac12 I \omega^2`, where :math:`I` is the inertia tensor
+for the aspherical particle and :math:`\omega` is its angular velocity, which
+is computed from its angular momentum if needed.
 
 .. note::
 
@@ -65,7 +65,7 @@ This compute requires that triangular particles atoms store a size and
 shape and quaternion orientation and angular momentum as defined by
 the :doc:`atom_style tri <atom_style>` command.
 
-All particles in the group must be finite-size.  They cannot be point
+All particles in the group must be of finite size.  They cannot be point
 particles.
 
 Related commands

doc/src/compute_erotate_rigid.rst

@@ -6,7 +6,7 @@ compute erotate/rigid command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID erotate/rigid fix-ID
 
@@ -25,18 +25,20 @@ Description
 """""""""""
 
 Define a computation that calculates the rotational kinetic energy of
-a collection of rigid bodies, as defined by one of the :doc:`fix rigid <fix_rigid>` command variants.
+a collection of rigid bodies, as defined by one of the
+:doc:`fix rigid <fix_rigid>` command variants.
 
-The rotational energy of each rigid body is computed as 1/2 I Wbody\^2,
-where I is the inertia tensor for the rigid body, and Wbody is its
-angular velocity vector.  Both I and Wbody are in the frame of
-reference of the rigid body, i.e. I is diagonalized.
+The rotational energy of each rigid body is computed as
+:math:`\frac12 I \omega_\text{body}^2`,
+where :math:`I` is the inertia tensor for the rigid body and
+:math:`\omega_\text{body}` is its angular velocity vector.
+Both :math:`I` and :math:`\omega_\text{body}` are in the frame of
+reference of the rigid body (i.e., :math:`I` is diagonal).
 
 The *fix-ID* should be the ID of one of the :doc:`fix rigid <fix_rigid>`
 commands which defines the rigid bodies.  The group specified in the
 compute command is ignored.  The rotational energy of all the rigid
-bodies defined by the fix rigid command in included in the
-calculation.
+bodies defined by the fix rigid command in included in the calculation.
 
 Output info
 """""""""""
@@ -53,7 +55,8 @@ Restrictions
 """"""""""""
 
 This compute is part of the RIGID package.  It is only enabled if
-LAMMPS was built with that package.  See the :doc:`Build package <Build_package>` page for more info.
+LAMMPS was built with that package.  See the
+:doc:`Build package <Build_package>` page for more info.
 
 Related commands
 """"""""""""""""

doc/src/compute_erotate_sphere.rst

@@ -6,7 +6,7 @@ compute erotate/sphere command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID erotate/sphere
 
@@ -26,8 +26,9 @@ Description
 Define a computation that calculates the rotational kinetic energy of
 a group of spherical particles.
 
-The rotational energy is computed as 1/2 I w\^2, where I is the moment
-of inertia for a sphere and w is the particle's angular velocity.
+The rotational energy is computed as :math:`\frac12 I \omega^2`,
+where :math:`I` is the moment of inertia for a sphere and :math:`\omega`
+is the particle's angular velocity.
 
 .. note::
 

doc/src/compute_erotate_sphere_atom.rst

@@ -6,7 +6,7 @@ compute erotate/sphere/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID erotate/sphere/atom
 
@@ -26,8 +26,9 @@ Description
 Define a computation that calculates the rotational kinetic energy for
 each particle in a group.
 
-The rotational energy is computed as 1/2 I w\^2, where I is the moment
-of inertia for a sphere and w is the particle's angular velocity.
+The rotational energy is computed as :math:`\frac12 I \omega^2`, where
+:math:`I` is the moment of inertia for a sphere and :math:`\omega` is the
+particle's angular velocity.
 
 .. note::
 
@@ -36,8 +37,7 @@ of inertia for a sphere and w is the particle's angular velocity.
    as in 3d.
 
 The value of the rotational kinetic energy will be 0.0 for atoms not
-in the specified compute group or for point particles with a radius =
-0.0.
+in the specified compute group or for point particles with a radius of 0.0.
 
 Output info
 """""""""""

doc/src/compute_event_displace.rst

@@ -6,7 +6,7 @@ compute event/displace command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID event/displace threshold
 
@@ -27,10 +27,9 @@ Description
 Define a computation that flags an "event" if any particle in the
 group has moved a distance greater than the specified threshold
 distance when compared to a previously stored reference state
-(i.e. the previous event).  This compute is typically used in
+(i.e., the previous event).  This compute is typically used in
 conjunction with the :doc:`prd <prd>` and :doc:`tad <tad>` commands,
-to detect if a transition
-to a new minimum energy basin has occurred.
+to detect if a transition to a new minimum energy basin has occurred.
 
 This value calculated by the compute is equal to 0 if no particle has
 moved far enough, and equal to 1 if one or more particles have moved
@@ -41,7 +40,7 @@ further than the threshold distance.
    If the system is undergoing significant center-of-mass motion,
    due to thermal motion, an external force, or an initial net momentum,
    then this compute will not be able to distinguish that motion from
-   local atom displacements and may generate "false positives."
+   local atom displacements and may generate "false positives".
 
 Output info
 """""""""""

doc/src/compute_fabric.rst

@@ -6,9 +6,9 @@ compute fabric command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
-   compute ID group-ID fabric cutoff attribute1 attribute2 ... keyword values ...
+   compute ID group-ID fabric cutoff attribute ... keyword values ...
 
 * ID, group-ID are documented in :doc:`compute <compute>` command
 * fabric = style name of this compute command
@@ -20,6 +20,7 @@ Syntax
        *radius* = cutoffs determined based on atom diameters (atom style sphere)
 
 * one or more attributes may be appended
+* attribute = *contact* or *branch* or *force/normal* or *force/tangential*
 
   .. parsed-literal::
 
@@ -63,7 +64,7 @@ tangential force tensor. The contact tensor is calculated as
 
 .. math::
 
-   C_{ab}  =  \frac{15}{2} (\phi_{ab} - \mathrm{tr}(\phi) \delta_{ab})
+   C_{ab}  =  \frac{15}{2} (\phi_{ab} - \mathrm{Tr}(\phi) \delta_{ab})
 
 where :math:`a` and :math:`b` are the :math:`x`, :math:`y`, :math:`z`
 directions, :math:`\delta_{ab}` is the Kronecker delta function, and
@@ -75,13 +76,14 @@ the tensor :math:`\phi` is defined as
 
 where :math:`n` loops over the :math:`N_p` pair interactions in the simulation,
 :math:`r_{a}` is the :math:`a` component of the radial vector between the
-two pairwise interacting particles, and :math:`r` is the magnitude of the radial vector.
+two pairwise interacting particles, and :math:`r` is the magnitude of the
+radial vector.
 
 The branch tensor is calculated as
 
 .. math::
 
-   B_{ab}  =  \frac{15}{6 \mathrm{tr}(D)} (D_{ab} - \mathrm{tr}(D) \delta_{ab})
+   B_{ab}  =  \frac{15}{6 \mathrm{Tr}(D)} (D_{ab} - \mathrm{Tr}(D) \delta_{ab})
 
 where the tensor :math:`D` is defined as
 
@@ -91,14 +93,15 @@ where the tensor :math:`D` is defined as
                 \frac{1}{N_c (r^2 + C_{cd} r_c r_d)}
                 \frac{r_{a} r_{b}}{r}
 
-where :math:`N_c` is the total number of contacts in the system and the subscripts
-:math:`c` and :math:`d` indices are summed according to Einstein notation.
+where :math:`N_c` is the total number of contacts in the system and the
+subscripts :math:`c` and :math:`d` indices are summed according to Einstein
+notation.
 
 The normal force fabric tensor is calculated as
 
 .. math::
 
-   F^n_{ab}  =  \frac{15}{6 \mathrm{tr}(N)} (N_{ab} - \mathrm{tr}(N) \delta_{ab})
+   F^n_{ab}  =  \frac{15}{6\, \mathrm{Tr}(N)} (N_{ab} - \mathrm{Tr}(N) \delta_{ab})
 
 where the tensor :math:`N` is defined as
 
@@ -116,7 +119,7 @@ as
 
 .. math::
 
-   F^t_{ab}  =  \frac{15}{9 \mathrm{tr}(N)} (T_{ab} - \mathrm{tr}(T) \delta_{ab})
+   F^t_{ab}  =  \frac{15}{9\, \mathrm{Tr}(N)} (T_{ab} - \mathrm{Tr}(T) \delta_{ab})
 
 where the tensor :math:`T` is defined as
 
@@ -133,21 +136,23 @@ Interactions between two atoms are only included in calculations if the atom typ
 are in the two lists. Each list consists of a series of type
 ranges separated by commas. The range can be specified as a
 single numeric value, or a wildcard asterisk can be used to specify a range
-of values.  This takes the form "\*" or "\*n" or "n\*" or "m\*n".  For
-example, if M = the number of atom types, then an asterisk with no numeric
-values means all types from 1 to M.  A leading asterisk means all types
-from 1 to n (inclusive).  A trailing asterisk means all types from n to M
-(inclusive).  A middle asterisk means all types from m to n (inclusive).
-Multiple *type/include* keywords may be added.
+of values.  This takes the form "\*" or "\*n" or "m\*" or "m\*n".  For
+example, if :math:`M` is the number of atom types, then an asterisk with no
+numeric values means all types from 1 to :math:`M`.  A leading asterisk means
+all types from 1 to n (inclusive).  A trailing asterisk means all types from
+m to :math:`M` (inclusive).  A middle asterisk means all types from m to n
+(inclusive).  Multiple *type/include* keywords may be added.
 
 Output info
 """""""""""
 
-This compute calculates a local vector of doubles and a scalar. The vector stores the
-unique components of the first requested tensor in the order xx, yy, zz, xy, xz, yz
-followed by the same components for all subsequent tensors. The length of the vector
-is therefore six times the number of requested tensors. The scalar output is the
-number of pairwise interactions included in the calculation of the fabric tensor.
+This compute calculates a local vector of doubles and a scalar. The vector
+stores the unique components of the first requested tensor in the order
+:math:`xx`, :math:`yy`, :math:`zz`, :math:`xy`, :math:`xz`, :math:`yz`
+followed by the same components for all subsequent tensors.
+The length of the vector is therefore six times the number of requested
+tensors. The scalar output is the number of pairwise interactions included in
+the calculation of the fabric tensor.
 
 Restrictions
 """"""""""""
@@ -164,7 +169,7 @@ following fixes which add rigid-body constraints: :doc:`fix shake
 <fix_shake>`, :doc:`fix rattle <fix_shake>`, :doc:`fix rigid
 <fix_rigid>`, :doc:`fix rigid/small <fix_rigid>`. It does not support
 granular pair styles that extend beyond the contact of atomic radii
-(e.g. JKR and DMT).
+(e.g., JKR and DMT).
 
 Related commands
 """"""""""""""""

doc/src/compute_fep.rst

@@ -6,7 +6,7 @@ compute fep command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID fep temp attribute args ... keyword value ...
 
@@ -19,12 +19,12 @@ Syntax
   .. parsed-literal::
 
        *pair* args = pstyle pparam I J v_delta
-         pstyle = pair style name, e.g. lj/cut
+         pstyle = pair style name (e.g., *lj/cut*)
          pparam = parameter to perturb
          I,J = type pair(s) to set parameter for
          v_delta = variable with perturbation to apply (in the units of the parameter)
        *atom* args = aparam I v_delta
-         aparam = parameter to perturb
+         aparam = *charge* = parameter to perturb
          I = type to set parameter for
          v_delta = variable with perturbation to apply (in the units of the parameter)
 
@@ -37,8 +37,8 @@ Syntax
          *no* = ignore tail correction to pair energies (usually small in fep)
          *yes* = include tail correction to pair energies
        *volume* value = *no* or *yes*
-         *no* = ignore volume changes (e.g. in *NVE* or *NVT* trajectories)
-         *yes* = include volume changes (e.g. in *NpT* trajectories)
+         *no* = ignore volume changes (e.g., in *NVE* or *NVT* trajectories)
+         *yes* = include volume changes (e.g., in *NPT* trajectories)
 
 Examples
 """"""""
@@ -84,7 +84,7 @@ It is possible but not necessary that the coupling parameter (or a
 function thereof) appears as a multiplication factor of the potential
 energy. Therefore, this compute can apply perturbations to interaction
 parameters that are not directly proportional to the potential energy
-(e.g. :math:`\sigma` in Lennard-Jones potentials).
+(e.g., :math:`\sigma` in Lennard-Jones potentials).
 
 This command can be combined with :doc:`fix adapt <fix_adapt>` to
 perform multistage free-energy perturbation calculations along
@@ -92,9 +92,9 @@ stepwise alchemical transformations during a simulation run:
 
 .. math::
 
-   \Delta_0^1 A = \sum_{i=0}^{n-1} \Delta_{\lambda_i}^{\lambda_{i+1}} A = - kT
+   \Delta_0^1 A = \sum_{i=0}^{n-1} \Delta_{\lambda_i}^{\lambda_{i+1}} A = - k_B T
    \sum_{i=0}^{n-1} \ln \left< \exp \left( - \frac{U(\lambda_{i+1}) -
-   U(\lambda_i)}{kT} \right) \right>_{\lambda_i}
+   U(\lambda_i)}{k_B T} \right) \right>_{\lambda_i}
 
 This compute is suitable for the finite-difference thermodynamic
 integration (FDTI) method :ref:`(Mezei) <Mezei>`, which is based on an
@@ -107,7 +107,8 @@ perturbation method using a very small :math:`\delta`:
    A(\lambda)}{\partial\lambda} \right)_\lambda \mathrm{d}\lambda \approx
    \sum_{i=0}^{n-1} w_i \frac{A(\lambda_{i} + \delta) - A(\lambda_i)}{\delta}
 
-where :math:`w_i` are weights of a numerical quadrature. The :doc:`fix adapt <fix_adapt>` command can be used to define the stages of
+where :math:`w_i` are weights of a numerical quadrature. The
+:doc:`fix adapt <fix_adapt>` command can be used to define the stages of
 :math:`\lambda` at which the derivative is calculated and averaged.
 
 The compute fep calculates the exponential Boltzmann term and also the
@@ -125,14 +126,14 @@ the derivative of the potential energy with respect to :math:`\lambda`:
 
 Another technique to calculate free energy differences is the
 acceptance ratio method :ref:`(Bennet) <Bennet>`, which can be implemented
-by calculating the potential energy differences with :math:`\delta` = 1.0 on
+by calculating the potential energy differences with :math:`\delta = 1.0` on
 both the forward and reverse routes:
 
 .. math::
 
-   \left< \frac{1}{1 + \exp\left[\left(U_1 - U_0 - \Delta_0^1A \right) /kT
+   \left< \frac{1}{1 + \exp\left[\left(U_1 - U_0 - \Delta_0^1A \right) /k_B T
    \right]} \right>_0 = \left< \frac{1}{1 + \exp\left[\left(U_0 - U_1 +
-   \Delta_0^1A \right) /kT \right]} \right>_1
+   \Delta_0^1A \right) /k_B T \right]} \right>_1
 
 The value of the free energy difference is determined by numerical
 root finding to establish the equality.
@@ -226,17 +227,17 @@ the pair\_\*.cpp file associated with the potential.
 
 Similar to the :doc:`pair_coeff <pair_coeff>` command, I and J can be
 specified in one of two ways.  Explicit numeric values can be used for
-each, as in the first example above.  I <= J is required.  LAMMPS sets
+each, as in the first example above.  I :math:`\le` J is required.  LAMMPS sets
 the coefficients for the symmetric J,I interaction to the same
 values. A wild-card asterisk can be used in place of or in conjunction
 with the I,J arguments to set the coefficients for multiple pairs of
-atom types.  This takes the form "\*" or "\*n" or "n\*" or "m\*n".  If N =
-the number of atom types, then an asterisk with no numeric values
-means all types from 1 to N.  A leading asterisk means all types from
-1 to n (inclusive).  A trailing asterisk means all types from n to N
+atom types.  This takes the form "\*" or "\*n" or "m\*" or "m\*n".  If
+:math:`N` is the number of atom types, then an asterisk with no numeric values
+means all types from 1 to :math:`N`.   A leading asterisk means all types from
+1 to n (inclusive).  A trailing asterisk means all types from m to N
 (inclusive).  A middle asterisk means all types from m to n
-(inclusive).  Note that only type pairs with I <= J are considered; if
-asterisks imply type pairs where J < I, they are ignored.
+(inclusive).  Note that only type pairs with I :math:`\le` J are considered; if
+asterisks imply type pairs where J :math:`<` I, they are ignored.
 
 If :doc:`pair_style hybrid or hybrid/overlay <pair_hybrid>` is being
 used, then the *pstyle* will be a sub-style name.  You must specify
@@ -275,8 +276,8 @@ trajectories during which the volume fluctuates or changes :ref:`(Allen and Tild
 
 .. math::
 
-   \Delta_0^1 A = - kT \sum_{i=0}^{n-1} \ln \frac{\left< V \exp \left( -
-   \frac{U(\lambda_{i+1}) - U(\lambda_i)}{kT} \right)
+   \Delta_0^1 A = - k_B T \sum_{i=0}^{n-1} \ln \frac{\left< V \exp \left( -
+   \frac{U(\lambda_{i+1}) - U(\lambda_i)}{k_B T} \right)
    \right>_{\lambda_i}}{\left< V \right>_{\lambda_i}}
 
 ----------
@@ -286,8 +287,8 @@ Output info
 
 This compute calculates a global vector of length 3 which contains the
 energy difference ( :math:`U_1-U_0` ) as c_ID[1], the
-Boltzmann factor :math:`\exp(-(U_1-U_0)/kT)`, or
-:math:`V \exp(-(U_1-U_0)/kT)`, as c_ID[2] and the
+Boltzmann factor :math:`\exp(-(U_1-U_0)/k_B T)`, or
+:math:`V \exp(-(U_1-U_0)/k_B T)`, as c_ID[2] and the
 volume of the simulation box :math:`V` as c_ID[3]. :math:`U_1` is the
 pair potential energy obtained with the perturbed parameters and
 :math:`U_0` is the pair potential energy obtained with the

doc/src/compute_fep_ta.rst

@@ -6,7 +6,7 @@ compute fep/ta command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID fep/ta temp plane scale_factor keyword value ...
 
@@ -20,9 +20,9 @@ Syntax
 
   .. parsed-literal::
 
-       *tail* value = *no* or *yes*
-         *no* = ignore tail correction to pair energies (usually small in fep)
-         *yes* = include tail correction to pair energies
+     *tail* value = *no* or *yes*
+       *no* = ignore tail correction to pair energies (usually small in fep)
+       *yes* = include tail correction to pair energies
 
 Examples
 """"""""
@@ -42,11 +42,12 @@ in a single simulation:
 .. math::
 
    \gamma = \lim_{\Delta \mathcal{A} \to 0} \left( \frac{\Delta A_{0 \to 1 }}{\Delta \mathcal{A}}\right)_{N,V,T}
-   = - \frac{kT}{\Delta \mathcal{A}} \ln \left< \exp(-(U_1 - U_0)/kT) \right>_0
+   = - \frac{k_B T}{\Delta \mathcal{A}} \ln \left\langle \exp\left(\frac{-(U_1 - U_0)}{k_B T}\right) \right\rangle_0
 
 During the perturbation, both axes of *plane* are scaled by multiplying
-:math:`\sqrt{scale\_factor}`, while the other axis divided by
-*scale_factor* such that the overall volume of the system is maintained.
+:math:`\sqrt{\mathrm{scale\_factor}}`, while the other axis divided by
+:math:`\mathrm{scale\_factor}` such that the overall volume of the system is
+maintained.
 
 The *tail* keyword controls the calculation of the tail correction to
 "van der Waals" pair energies beyond the cutoff, if this has been
@@ -60,8 +61,8 @@ Output info
 """""""""""
 
 This compute calculates a global vector of length 3 which contains the
-energy difference ( :math:`U_1-U_0` ) as c_ID[1], the Boltzmann factor
-:math:`\exp(-(U_1-U_0)/kT)`, as c_ID[2] and the change in the *plane*
+energy difference :math:`(U_1-U_0)` as c_ID[1], the Boltzmann factor
+:math:`\exp\bigl(-(U_1-U_0)/k_B T\bigr)`, as c_ID[2] and the change in the *plane*
 area :math:`\Delta \mathcal{A}` as c_ID[3]. :math:`U_1` is the potential
 energy of the perturbed state and :math:`U_0` is the potential energy of
 the reference state.  The energies include kspace terms if these are

doc/src/compute_global_atom.rst

@@ -6,7 +6,7 @@ compute global/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID style index input1 input2 ...
 
@@ -55,18 +55,20 @@ reference a global vector or array from a :doc:`compute <compute>` or
 :doc:`fix <fix>` or the evaluation of an vector-style
 :doc:`variable <variable>`.  Details are given below.
 
-The *index* value for an atom is used as a index I (from 1 to N) into
-the vector associated with each of the input values.  The Ith value
+The *index* value for an atom is used as an index :math:`I` (from 1 to
+:math:`N`, where :math:`N` is the number of atoms) into the vector
+associated with each of the input values.  The :math:`I`\ th value
 from the input vector becomes one output value for that atom.  If the
-atom is not in the specified group, or the index I < 1 or I > M, where
-M is the actual length of the input vector, then an output value of
-0.0 is assigned to the atom.
+atom is not in the specified group, or the index :math:`I < 1` or
+:math:`I > M`, where :math:`M` is the actual length of the input vector,
+then an output value of 0.0 is assigned to the atom.
 
 An example of how this command is useful, is in the context of
 "chunks" which are static or dynamic subsets of atoms.  The :doc:`compute chunk/atom <compute_chunk_atom>` command assigns unique chunk IDs
-to each atom.  It's output can be used as the *index* parameter for
+to each atom.  Its output can be used as the *index* parameter for
 this command.  Various other computes with "chunk" in their style
-name, such as :doc:`compute com/chunk <compute_com_chunk>` or :doc:`compute msd/chunk <compute_msd_chunk>`, calculate properties for each
+name, such as :doc:`compute com/chunk <compute_com_chunk>` or
+:doc:`compute msd/chunk <compute_msd_chunk>`, calculate properties for each
 chunk.  The output of these commands are global vectors or arrays,
 with one or more values per chunk, and can be used as input values for
 this command.  This command will then assign the global chunk value to
@@ -102,17 +104,18 @@ they work.
 Note that for input values from a compute or fix, the bracketed index
 I can be specified using a wildcard asterisk with the index to
 effectively specify multiple values.  This takes the form "\*" or "\*n"
-or "n\*" or "m\*n".  If N = the size of the vector (for *mode* = scalar)
+or "m\*" or "m\*n".  If :math:`N` is the size of the vector
+(for *mode* = scalar)
 or the number of columns in the array (for *mode* = vector), then an
-asterisk with no numeric values means all indices from 1 to N.  A
-leading asterisk means all indices from 1 to n (inclusive).  A
-trailing asterisk means all indices from n to N (inclusive).  A middle
-asterisk means all indices from m to n (inclusive).
+asterisk with no numeric values means all indices from 1 to :math:`N`.
+A leading asterisk means all indices from 1 to n (inclusive).  A
+trailing asterisk means all indices from m to :math:`N` (inclusive).
+A middle asterisk means all indices from m to n (inclusive).
 
 Using a wildcard is the same as if the individual columns of the array
-had been listed one by one.  E.g. these 2 compute global/atom commands
-are equivalent, since the :doc:`compute com/chunk <compute_com_chunk>`
-command creates a global array with 3 columns:
+had been listed one by one. For example, the following two compute global/atom
+commands are equivalent, since the :doc:`compute com/chunk <compute_com_chunk>`
+command creates a global array with three columns:
 
 .. code-block:: LAMMPS
 
@@ -124,14 +127,14 @@ command creates a global array with 3 columns:
 ----------
 
 This section explains the *index* parameter.  Note that it must
-reference per-atom values, as contrasted with the *input* values which
+reference per-atom values, as contrasted with the *input* values, which
 must reference global values.
 
 Note that all of these options generate floating point values.  When
 they are used as an index into the specified input vectors, they
 simple rounded down to convert the value to integer indices.  The
-final values should range from 1 to N (inclusive), since they are used
-to access values from N-length vectors.
+final values should range from 1 to :math:`N` (inclusive), since they are used
+to access values from :math:`N`-length vectors.
 
 If *index* begins with "c\_", a compute ID must follow which has been
 previously defined in the input script.  The compute must generate
@@ -177,7 +180,8 @@ global vector or array.  See the individual :doc:`compute <compute>` doc
 page for details.  If no bracketed integer is appended, the vector
 calculated by the compute is used.  If a bracketed integer is
 appended, the Ith column of the array calculated by the compute is
-used.  Users can also write code for their own compute styles and :doc:`add them to LAMMPS <Modify>`.  See the discussion above for how
+used.  Users can also write code for their own compute styles and
+:doc:`add them to LAMMPS <Modify>`.  See the discussion above for how
 I can be specified with a wildcard asterisk to effectively specify
 multiple values.
 

doc/src/compute_group_group.rst

@@ -6,7 +6,7 @@ compute group/group command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID group/group group2-ID keyword value ...
 
@@ -102,19 +102,20 @@ frequently.
 
    If you have a bonded system, then the settings of
    :doc:`special_bonds <special_bonds>` command can remove pairwise
-   interactions between atoms in the same bond, angle, or dihedral.  This
-   is the default setting for the :doc:`special_bonds <special_bonds>`
-   command, and means those pairwise interactions do not appear in the
-   neighbor list.  Because this compute uses a neighbor list, it also
-   means those pairs will not be included in the group/group interaction.
-   This does not apply when using long-range coulomb interactions
-   (\ *coul/long*, *coul/msm*, *coul/wolf* or similar.  One way to get
-   around this would be to set special_bond scaling factors to very tiny
-   numbers that are not exactly zero (e.g. 1.0e-50). Another workaround
-   is to write a dump file, and use the :doc:`rerun <rerun>` command to
-   compute the group/group interactions for snapshots in the dump file.
-   The rerun script can use a :doc:`special_bonds <special_bonds>` command
-   that includes all pairs in the neighbor list.
+   interactions between atoms in the same bond, angle, or dihedral.  This is
+   the default setting for the :doc:`special_bonds <special_bonds>` command,
+   and means those pairwise interactions do not appear in the neighbor list.
+   Because this compute uses a neighbor list, it also means those pairs will
+   not be included in the group/group interaction.  This does not apply when
+   using long-range Coulomb interactions
+   (\ *coul/long*, *coul/msm*, *coul/wolf* or similar).  One way to get
+   around this would be to set *special_bond* scaling factors to very tiny
+   numbers that are not exactly zero (e.g., :math:`1.0 \times 10^{-50}`).
+   Another workaround would be to write a dump file and use the
+   :doc:`rerun <rerun>` command to compute the group/group interactions for
+   snapshots in the dump file. The rerun script can use a
+   :doc:`special_bonds <special_bonds>` command that includes all pairs in the
+   neighbor list.
 
 If you desire a breakdown of the interactions into a pairwise and
 Kspace component, simply invoke the compute twice with the appropriate
@@ -132,9 +133,10 @@ Output info
 """""""""""
 
 This compute calculates a global scalar (the energy) and a global
-vector of length 3 (force), which can be accessed by indices 1-3.
+vector of length 3 (force), which can be accessed by indices 1--3.
 These values can be used by any command that uses global scalar or
-vector values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
+vector values from a compute as input.  See the
+:doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
 options.
 
 Both the scalar and vector values calculated by this compute are
@@ -145,7 +147,7 @@ Restrictions
 """"""""""""
 
 Not all pair styles can be evaluated in a pairwise mode as required by
-this compute.  For example, 3-body and other many-body potentials,
+this compute.  For example, three-body and other many-body potentials,
 such as :doc:`Tersoff <pair_tersoff>` and
 :doc:`Stillinger-Weber <pair_sw>` cannot be used.  :doc:`EAM <pair_eam>`
 potentials will re-use previously computed embedding term contributions,

doc/src/compute_gyration.rst

@@ -6,7 +6,7 @@ compute gyration command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID gyration
 
@@ -23,51 +23,54 @@ Examples
 Description
 """""""""""
 
-Define a computation that calculates the radius of gyration Rg of the
+Define a computation that calculates the radius of gyration :math:`R_g` of the
 group of atoms, including all effects due to atoms passing through
 periodic boundaries.
 
-Rg is a measure of the size of the group of atoms, and is computed as
-the square root of the Rg\^2 value in this formula
+:math:`R_g` is a measure of the size of the group of atoms, and is computed as
+the square root of the :math:`R_g^2` value in this formula
 
 .. math::
 
- {R_g}^2 = \frac{1}{M} \sum_i m_i (r_i - r_{cm})^2
+   R_g^2 = \frac{1}{M} \sum_i m_i (r_i - r_{\text{cm}})^2
 
-where :math:`M` is the total mass of the group, :math:`r_{cm}` is the
+where :math:`M` is the total mass of the group, :math:`r_{\text{cm}}` is the
 center-of-mass position of the group, and the sum is over all atoms in
 the group.
 
-A :math:`{R_g}^2` tensor, stored as a 6-element vector, is also calculated
+A :math:`R_g^2` tensor, stored as a 6-element vector, is also calculated
 by this compute.  The formula for the components of the tensor is the
-same as the above formula, except that :math:`(r_i - r_{cm})^2` is replaced
-by :math:`(r_{i,x} - r_{cm,x}) \cdot (r_{i,y} - r_{cm,y})` for the xy component,
-and so on.  The 6 components of the vector are ordered xx, yy, zz, xy, xz, yz.
-Note that unlike the scalar :math:`R_g`, each of the 6 values of the tensor
+same as the above formula, except that :math:`(r_i - r_{\text{cm}})^2` is
+replaced by
+:math:`(r_{i,x} - r_{\text{cm},x}) \cdot (r_{i,y} - r_{\text{cm},y})` for the
+:math:`xy` component, and so on.  The six components of the vector are ordered
+:math:`xx`, :math:`yy`, :math:`zz`, :math:`xy`, :math:`xz`, :math:`yz`.
+Note that unlike the scalar :math:`R_g`, each of the six values of the tensor
 is effectively a "squared" value, since the cross-terms may be negative
-and taking a sqrt() would be invalid.
+and taking a square root would be invalid.
 
 .. note::
 
    The coordinates of an atom contribute to :math:`R_g` in "unwrapped" form,
-   by using the image flags associated with each atom.  See the :doc:`dump custom <dump>` command for a discussion of "unwrapped" coordinates.
+   by using the image flags associated with each atom.  See the
+   :doc:`dump custom <dump>` command for a discussion of "unwrapped" coordinates.
    See the Atoms section of the :doc:`read_data <read_data>` command for a
    discussion of image flags and how they are set for each atom.  You can
-   reset the image flags (e.g. to 0) before invoking this compute by
+   reset the image flags (e.g., to 0) before invoking this compute by
    using the :doc:`set image <set>` command.
 
 Output info
 """""""""""
 
 This compute calculates a global scalar (:math:`R_g`) and a global vector of
-length 6 (:math:`{R_g}^2` tensor), which can be accessed by indices 1-6.  These
+length 6 (:math:`R_g^2` tensor), which can be accessed by indices 1--6.  These
 values can be used by any command that uses a global scalar value or
 vector values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
 options.
 
 The scalar and vector values calculated by this compute are
 "intensive".  The scalar and vector values will be in distance and
-distance\^2 :doc:`units <units>` respectively.
+distance\ :math:`^2` :doc:`units <units>`, respectively.
 
 Restrictions
 """"""""""""

doc/src/compute_gyration_chunk.rst

@@ -6,7 +6,7 @@ compute gyration/chunk command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID gyration/chunk chunkID keyword value ...
 
@@ -31,28 +31,31 @@ Examples
 Description
 """""""""""
 
-Define a computation that calculates the radius of gyration Rg for
+Define a computation that calculates the radius of gyration :math:`R_g` for
 multiple chunks of atoms.
 
-In LAMMPS, chunks are collections of atoms defined by a :doc:`compute chunk/atom <compute_chunk_atom>` command, which assigns each atom
+In LAMMPS, chunks are collections of atoms defined by a
+:doc:`compute chunk/atom <compute_chunk_atom>` command, which assigns each atom
 to a single chunk (or no chunk).  The ID for this command is specified
 as chunkID.  For example, a single chunk could be the atoms in a
-molecule or atoms in a spatial bin.  See the :doc:`compute chunk/atom <compute_chunk_atom>` and :doc:`Howto chunk <Howto_chunk>`
+molecule or atoms in a spatial bin.
+See the :doc:`compute chunk/atom <compute_chunk_atom>` and
+:doc:`Howto chunk <Howto_chunk>`
 doc pages for details of how chunks can be defined and examples of how
 they can be used to measure properties of a system.
 
-This compute calculates the radius of gyration Rg for each chunk,
+This compute calculates the radius of gyration :math:`R_g` for each chunk,
 which includes all effects due to atoms passing through periodic
 boundaries.
 
-Rg is a measure of the size of a chunk, and is computed by this
+:math:`R_g` is a measure of the size of a chunk, and is computed by the
 formula
 
 .. math::
 
- {R_g}^2 = \frac{1}{M} \sum_i m_i (r_i - r_{cm})^2
+   R_g^2 = \frac{1}{M} \sum_i m_i (r_i - r_{\text{cm}})^2
 
-where :math:`M` is the total mass of the chunk, :math:`r_{cm}` is
+where :math:`M` is the total mass of the chunk, :math:`r_{\text{cm}}` is
 the center-of-mass position of the chunk, and the sum is over all atoms in the
 chunk.
 
@@ -64,13 +67,13 @@ thus also not contribute to this calculation.  You can specify the
 "all" group for this command if you simply want to include atoms with
 non-zero chunk IDs.
 
-If the *tensor* keyword is specified, then the scalar Rg value is not
-calculated, but an Rg tensor is instead calculated for each chunk.
+If the *tensor* keyword is specified, then the scalar :math:`R_g` value is not
+calculated, but an :math:`R_g` tensor is instead calculated for each chunk.
 The formula for the components of the tensor is the same as the above
-formula, except that :math:`(r_i - r_{cm})^2` is replaced by
-:math:`(r_{i,x} - r_{cm,x}) \cdot (r_{i,y} - r_{cm,y})` for the xy
-component, and so on.  The 6 components of the tensor are
-ordered xx, yy, zz, xy, xz, yz.
+formula, except that :math:`(r_i - r_{\text{cm}})^2` is replaced by
+:math:`(r_{i,x} - r_{\text{cm},x}) \cdot (r_{i,y} - r_{\text{cm},y})` for the
+:math:`xy` component, and so on.  The six components of the tensor are
+ordered :math:`xx`, :math:`yy`, :math:`zz`, :math:`xy`, :math:`xz`, :math:`yz`.
 
 .. note::
 
@@ -79,7 +82,7 @@ ordered xx, yy, zz, xy, xz, yz.
    command for a discussion of "unwrapped" coordinates.
    See the Atoms section of the :doc:`read_data <read_data>` command for a
    discussion of image flags and how they are set for each atom.  You can
-   reset the image flags (e.g. to 0) before invoking this compute by
+   reset the image flags (e.g., to 0) before invoking this compute by
    using the :doc:`set image <set>` command.
 
 The simplest way to output the results of the compute gyration/chunk
@@ -98,8 +101,9 @@ Output info
 This compute calculates a global vector if the *tensor* keyword is not
 specified and a global array if it is.  The length of the vector or
 number of rows in the array = the number of chunks *Nchunk* as
-calculated by the specified :doc:`compute chunk/atom <compute_chunk_atom>` command.  If the *tensor* keyword
-is specified, the global array has 6 columns.  The vector or array can
+calculated by the specified :doc:`compute chunk/atom <compute_chunk_atom>`
+command.  If the *tensor* keyword is specified, the global array has six
+columns.  The vector or array can
 be accessed by any command that uses global values from a compute as
 input.  See the :doc:`Howto output <Howto_output>` page for an
 overview of LAMMPS output options.

doc/src/compute_gyration_shape.rst

@@ -6,7 +6,7 @@ compute gyration/shape command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID gyration/shape compute-ID
 
@@ -28,30 +28,33 @@ Define a computation that calculates the eigenvalues of the gyration tensor of a
 group of atoms and three shape parameters. The computation includes all effects
 due to atoms passing through periodic boundaries.
 
-The three computed shape parameters are the asphericity, b, the acylindricity, c,
-and the relative shape anisotropy, k:
+The three computed shape parameters are the asphericity, :math:`b`,
+the acylindricity, :math:`c`, and the relative shape anisotropy, :math:`k`,
+viz.,
 
 .. math::
 
- c = & l_z - 0.5(l_y+l_x) \\
- b = & l_y - l_x \\
- k = & \frac{3}{2} \frac{l_x^2+l_y^2+l_z^2}{(l_x+l_y+l_z)^2} - \frac{1}{2}
+ b &= l_z - \frac12(l_y+l_x) \\
+ c &= l_y - l_x \\
+ k &= \frac{3}{2} \frac{l_x^2+l_y^2+l_z^2}{(l_x+l_y+l_z)^2} - \frac{1}{2}
 
-where :math:`l_x` <= :math:`l_y` <= :math:`l_z` are the three eigenvalues of the gyration tensor. A general description
-of these parameters is provided in :ref:`(Mattice) <Mattice1>` while an application to polymer systems
+where :math:`l_x \le l_y \le l_z` are the three eigenvalues of the gyration
+tensor. A general description of these parameters is provided in
+:ref:`(Mattice) <Mattice1>` while an application to polymer systems
 can be found in :ref:`(Theodorou) <Theodorou1>`.
-The asphericity  is always non-negative and zero only when the three principal
-moments are equal. This zero condition is met when the distribution of particles
-is spherically symmetric (hence the name asphericity) but also whenever the particle
-distribution is symmetric with respect to the three coordinate axes, e.g.,
-when the particles are distributed uniformly on a cube, tetrahedron or other Platonic
-solid. The acylindricity is always non-negative and zero only when the two principal
-moments are equal. This zero condition is met when the distribution of particles is
-cylindrically symmetric (hence the name, acylindricity), but also whenever the particle
-distribution is symmetric with respect to the two coordinate axes, e.g., when the
-particles are distributed uniformly on a regular prism. the relative shape anisotropy
-is bounded between zero (if all points are spherically symmetric) and one
-(if all points lie on a line).
+The asphericity is always non-negative and zero only when the three principal
+moments are equal. This zero condition is met when the distribution of
+particles is spherically symmetric (hence the name asphericity) but also
+whenever the particle distribution is symmetric with respect to the three
+coordinate axes (e.g., when the particles are distributed uniformly on a cube,
+tetrahedron or other Platonic solid). The acylindricity is always non-negative
+and zero only when the two principal moments are equal. This zero condition is
+met when the distribution of particles is cylindrically symmetric (hence the
+name, acylindricity), but also whenever the particle distribution is symmetric
+with respect to the two coordinate axes (e.g., when the
+particles are distributed uniformly on a regular prism).
+The relative shape anisotropy is bounded between zero (if all points are
+spherically symmetric) and one (if all points lie on a line).
 
 .. note::
 
@@ -60,22 +63,23 @@ is bounded between zero (if all points are spherically symmetric) and one
    See the :doc:`dump custom <dump>` command for a discussion of "unwrapped"
    coordinates. See the Atoms section of the :doc:`read_data <read_data>`
    command for a discussion of image flags and how they are set for each
-   atom.  You can reset the image flags (e.g. to 0) before invoking this
+   atom.  You can reset the image flags (e.g., to 0) before invoking this
    compute by using the :doc:`set image <set>` command.
 
 Output info
 """""""""""
 
-This compute calculates a global vector of
-length 6, which can be accessed by indices 1-6. The first three values are the
-eigenvalues of the gyration tensor followed by the asphericity, the acylindricity
-and the relative shape anisotropy.  The computed values can be used by any command
-that uses global  vector values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
+This compute calculates a global vector of length 6, which can be accessed by
+indices 1--6. The first three values are the eigenvalues of the gyration tensor
+followed by the asphericity, the acylindricity and the relative shape
+anisotropy.  The computed values can be used by any command that uses global
+vector values from a compute as input.  See the
+:doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
 options.
 
 The vector values calculated by this compute are
 "intensive".  The first five vector values will be in
-distance\^2 :doc:`units <units>` while the sixth one is dimensionless.
+distance\ :math:`2` :doc:`units <units>` while the sixth one is dimensionless.
 
 Restrictions
 """"""""""""

doc/src/compute_gyration_shape_chunk.rst

@@ -6,7 +6,7 @@ compute gyration/shape/chunk command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID gyration/shape/chunk compute-ID
 
@@ -28,28 +28,32 @@ Define a computation that calculates the eigenvalues of the gyration tensor and
 three shape parameters of multiple chunks of atoms. The computation includes
 all effects due to atoms passing through periodic boundaries.
 
-The three computed shape parameters are the asphericity, b, the acylindricity, c,
-and the relative shape anisotropy, k:
+The three computed shape parameters are the asphericity, :math:`b`,
+the acylindricity, :math:`c`, and the relative shape anisotropy, :math:`k`,
+viz.,
 
 .. math::
 
- c = & l_z - 0.5(l_y+l_x) \\
- b = & l_y - l_x \\
- k = & \frac{3}{2} \frac{l_x^2+l_y^2+l_z^2}{(l_x+l_y+l_z)^2} - \frac{1}{2}
+ b &= l_z - \frac12(l_y+l_x) \\
+ c &= l_y - l_x \\
+ k &= \frac{3}{2} \frac{l_x^2+l_y^2+l_z^2}{(l_x+l_y+l_z)^2} - \frac{1}{2}
 
-where :math:`l_x` <= :math:`l_y` <= :math:`l_z` are the three eigenvalues of the gyration tensor. A general description
-of these parameters is provided in :ref:`(Mattice) <Mattice2>` while an application to polymer systems
-can be found in :ref:`(Theodorou) <Theodorou2>`. The asphericity  is always non-negative and zero
-only when the three principal moments are equal. This zero condition is met when the distribution
-of particles is spherically symmetric (hence the name asphericity) but also whenever the particle
-distribution is symmetric with respect to the three coordinate axes, e.g.,
-when the particles are distributed uniformly on a cube, tetrahedron or other Platonic
-solid. The acylindricity is always non-negative and zero only when the two principal
-moments are equal. This zero condition is met when the distribution of particles is
-cylindrically symmetric (hence the name, acylindricity), but also whenever the particle
-distribution is symmetric with respect to the two coordinate axes, e.g., when the
-particles are distributed uniformly on a regular prism. the relative shape anisotropy
-is bounded between zero (if all points are spherically symmetric) and one
+where :math:`l_x \le l_y \le l_z` are the three eigenvalues of the gyration
+tensor. A general description of these parameters is provided in
+:ref:`(Mattice) <Mattice2>` while an application to polymer systems
+can be found in :ref:`(Theodorou) <Theodorou2>`. The asphericity is always
+non-negative and zero only when the three principal moments are equal.
+This zero condition is met when the distribution of particles is spherically
+symmetric (hence the name asphericity) but also whenever the particle
+distribution is symmetric with respect to the three coordinate axes (e.g.,
+when the particles are distributed uniformly on a cube, tetrahedron, or other
+Platonic solid). The acylindricity is always non-negative and zero only when
+the two principal moments are equal. This zero condition is met when the
+distribution of particles is cylindrically symmetric (hence the name,
+acylindricity), but also whenever the particle distribution is symmetric with
+respect to the two coordinate axes (e.g., when the particles are distributed
+uniformly on a regular prism). The relative shape anisotropy
+is bounded between 0 (if all points are spherically symmetric) and 1
 (if all points lie on a line).
 
 The tensor keyword must be specified in the compute gyration/chunk command.
@@ -61,22 +65,23 @@ The tensor keyword must be specified in the compute gyration/chunk command.
    See the :doc:`dump custom <dump>` command for a discussion of "unwrapped"
    coordinates. See the Atoms section of the :doc:`read_data <read_data>`
    command for a discussion of image flags and how they are set for each
-   atom.  You can reset the image flags (e.g. to 0) before invoking this
+   atom.  You can reset the image flags (e.g., to 0) before invoking this
    compute by using the :doc:`set image <set>` command.
 
 Output info
 """""""""""
 
 This compute calculates a global array with six columns,
-which can be accessed by indices 1-6. The first three columns are the
-eigenvalues of the gyration tensor followed by the asphericity, the acylindricity
-and the relative shape anisotropy.  The computed values can be used by any command
-that uses global array values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
-options.
+which can be accessed by indices 1--6. The first three columns are the
+eigenvalues of the gyration tensor followed by the asphericity, the
+acylindricity and the relative shape anisotropy.  The computed values can be
+used by any command that uses global array values from a compute as input.
+See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS
+output options.
 
 The array calculated by this compute is
 "intensive".  The first five columns will be in
-distance\^2 :doc:`units <units>` while the sixth one is dimensionless.
+distance\ :math:`^2` :doc:`units <units>` while the sixth one is dimensionless.
 
 Restrictions
 """"""""""""

doc/src/compute_heat_flux.rst

@@ -6,7 +6,7 @@ compute heat/flux command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID heat/flux ke-ID pe-ID stress-ID
 
@@ -28,13 +28,13 @@ Description
 
 Define a computation that calculates the heat flux vector based on
 contributions from atoms in the specified group.  This can be used by
-itself to measure the heat flux through a set of atoms (e.g. a region
+itself to measure the heat flux through a set of atoms (e.g., a region
 between two thermostatted reservoirs held at different temperatures),
 or to calculate a thermal conductivity using the equilibrium
 Green-Kubo formalism.
 
 For other non-equilibrium ways to compute a thermal conductivity, see
-the :doc:`Howto kappa <Howto_kappa>` doc page..  These include use of
+the :doc:`Howto kappa <Howto_kappa>` doc page.  These include use of
 the :doc:`fix thermal/conductivity <fix_thermal_conductivity>` command
 for the Muller-Plathe method.  Or the :doc:`fix heat <fix_heat>` command
 which can add or subtract heat from groups of atoms.
@@ -52,12 +52,12 @@ third calculates per-atom stress (\ *stress-ID*\ ).
    (or any group whose atoms are superset of the atoms in this compute's
    group).  LAMMPS does not check for this.
 
-In case of two-body interactions, the heat flux is defined as:
+In case of two-body interactions, the heat flux :math:`\mathbf{J}` is defined as
 
 .. math::
    \mathbf{J} &= \frac{1}{V} \left[ \sum_i e_i \mathbf{v}_i - \sum_{i} \mathbf{S}_{i} \mathbf{v}_i \right] \\
    &= \frac{1}{V} \left[ \sum_i e_i \mathbf{v}_i + \sum_{i<j} \left( \mathbf{F}_{ij} \cdot \mathbf{v}_j \right) \mathbf{r}_{ij} \right] \\
-   &= \frac{1}{V} \left[ \sum_i e_i \mathbf{v}_i + \frac{1}{2} \sum_{i<j} \left( \mathbf{F}_{ij} \cdot \left(\mathbf{v}_i + \mathbf{v}_j \right)  \right) \mathbf{r}_{ij} \right]
+   &= \frac{1}{V} \left[ \sum_i e_i \mathbf{v}_i + \frac{1}{2} \sum_{i<j} \bigl( \mathbf{F}_{ij} \cdot \left(\mathbf{v}_i + \mathbf{v}_j \right) \bigr) \mathbf{r}_{ij} \right]
 
 :math:`e_i` in the first term of the equation
 is the per-atom energy (potential and kinetic).
@@ -68,12 +68,12 @@ See :doc:`compute stress/atom <compute_stress_atom>`
 and :doc:`compute centroid/stress/atom <compute_stress_atom>`
 for possible definitions of atomic stress :math:`\mathbf{S}_i`
 in the case of bonded and many-body interactions.
-The tensor multiplies :math:`\mathbf{v}_i` as a 3x3 matrix-vector multiply
+The tensor multiplies :math:`\mathbf{v}_i` by a :math:`3\times3` matrix
 to yield a vector.
-Note that as discussed below, the 1/:math:`{V}` scaling factor in the
-equation for :math:`\mathbf{J}` is NOT included in the calculation performed by
-these computes; you need to add it for a volume appropriate to the atoms
-included in the calculation.
+Note that as discussed below, the :math:`1/V` scaling factor in the
+equation for :math:`\mathbf{J}` is **not** included in the calculation
+performed by these computes; you need to add it for a volume appropriate to the
+atoms included in the calculation.
 
 .. note::
 
@@ -103,7 +103,7 @@ included in the calculation.
    contribution when computed via :doc:`compute stress/atom <compute_stress_atom>`
    are highly unphysical and should not be used.
 
-The Green-Kubo formulas relate the ensemble average of the
+The Green--Kubo formulas relate the ensemble average of the
 auto-correlation of the heat flux :math:`\mathbf{J}`
 to the thermal conductivity :math:`\kappa`:
 
@@ -112,17 +112,18 @@ to the thermal conductivity :math:`\kappa`:
 
 ----------
 
-The heat flux can be output every so many timesteps (e.g. via the
+The heat flux can be output every so many timesteps (e.g., via the
 :doc:`thermo_style custom <thermo_style>` command).  Then as a
 post-processing operation, an auto-correlation can be performed, its
-integral estimated, and the Green-Kubo formula above evaluated.
+integral estimated, and the Green--Kubo formula above evaluated.
 
 The :doc:`fix ave/correlate <fix_ave_correlate>` command can calculate
 the auto-correlation.  The trap() function in the
 :doc:`variable <variable>` command can calculate the integral.
 
-An example LAMMPS input script for solid Ar is appended below.  The
-result should be: average conductivity ~0.29 in W/mK.
+An example LAMMPS input script for solid argon is appended below.  The
+result should be an average conductivity
+:math:`\approx 0.29~\mathrm{W/m \cdot K}`.
 
 ----------
 
@@ -130,25 +131,25 @@ Output info
 """""""""""
 
 This compute calculates a global vector of length 6.
-The first 3 components are the :math:`x`, :math:`y`, :math:`z`
-components of the full heat flux vector,
-i.e. (:math:`J_x`, :math:`J_y`, :math:`J_z`).
-The next 3 components are the :math:`x`, :math:`y`, :math:`z` components
-of just the convective portion of the flux, i.e. the
-first term in the equation for :math:`\mathbf{J}`.
-Each component can be
-accessed by indices 1-6. These values can be used by any command that
-uses global vector values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
-options.
+The first three components are the :math:`x`, :math:`y`, and :math:`z`
+components of the full heat flux vector
+(i.e., :math:`J_x`, :math:`J_y`, and :math:`J_z`).
+The next three components are the :math:`x`, :math:`y`, and :math:`z`
+components of just the convective portion of the flux (i.e., the
+first term in the equation for :math:`\mathbf{J}`).
+Each component can be accessed by indices 1--6. These values can be used by any
+command that uses global vector values from a compute as input.
+See the :doc:`Howto output <Howto_output>` documentation for an overview of
+LAMMPS output options.
 
 The vector values calculated by this compute are "extensive", meaning
 they scale with the number of atoms in the simulation.  They can be
-divided by the appropriate volume to get a flux, which would then be
-an "intensive" value, meaning independent of the number of atoms in
-the simulation.  Note that if the compute is "all", then the
-appropriate volume to divide by is the simulation box volume.
-However, if a sub-group is used, it should be the volume containing
-those atoms.
+divided by the appropriate volume to get a flux, which would then be an
+"intensive" value, meaning independent of the number of atoms in the
+simulation.  Note that if the compute group is "all", then the
+appropriate volume to divide by is the simulation box volume.  However,
+if a group with a subset of atoms is used, it should be the volume
+containing those atoms.
 
 The vector values will be in energy\*velocity :doc:`units <units>`.  Once
 divided by a volume the units will be that of flux, namely
@@ -172,6 +173,9 @@ none
 
 ----------
 
+Example Input File
+------------------
+
 .. code-block:: LAMMPS
 
    # Sample LAMMPS input script for thermal conductivity of solid Ar

doc/src/compute_hexorder_atom.rst

@@ -6,7 +6,7 @@ compute hexorder/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID hexorder/atom keyword values ...
 
@@ -102,7 +102,7 @@ Output info
 
 This compute calculates a per-atom array with 2 columns, giving the
 real and imaginary parts :math:`q_n`, a complex number restricted to the
-unit disk of the complex plane i.e. :math:`Re(q_n)^2 + Im(q_n)^2 <= 1`.
+unit disk of the complex plane (i.e., :math:`\Re(q_n)^2 + \Im(q_n)^2 \le 1`).
 
 These values can be accessed by any command that uses per-atom values
 from a compute as input.  See the :doc:`Howto output <Howto_output>` doc

doc/src/compute_hma.rst

@@ -6,20 +6,23 @@ compute hma command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID hma temp-ID keyword ...
 
 * ID, group-ID are documented in :doc:`compute <compute>` command
 * hma = style name of this compute command
 * temp-ID = ID of fix that specifies the set temperature during canonical simulation
-* keyword = *anharmonic* *u* *p Pharm* *cv*
+* one or more keywords or keyword/argument pairs must be appended
+* keyword = *anharmonic* or *u* or *p* or *cv*
 
 .. parsed-literal::
 
      *anharmonic* = compute will return anharmonic property values
      *u* = compute will return potential energy
-     *p* = compute will return pressure.  the following keyword must be the difference between the harmonic pressure and lattice pressure as described below
+     *p* value = Pharm = compute will return pressure
+        Pharm = difference between the harmonic pressure and lattice pressure
+                as described below
      *cv* = compute will return the heat capacity
 
 Examples
@@ -74,44 +77,48 @@ A detailed description of this method can be found in (:ref:`Moustafa <hma-Moust
 
 .. math::
 
-   \left< U\right>_{HMA} = \frac{d}{2} (N-1) k_B T  + \left< U + \frac{1}{2} F\bullet\Delta r \right>
+   \left< U\right>_\text{HMA} = \frac{d}{2} (N-1) k_B T  + \left< U + \frac{1}{2} \vec F\cdot\Delta \vec r \right>
 
 where :math:`N` is the number of atoms in the system, :math:`k_B` is Boltzmann's
-constant, :math:`T` is the temperature, :math:`d` is the
-dimensionality of the system (2 or 3 for 2d/3d), :math:`F\bullet\Delta r` is the sum of dot products of the
-atomic force vectors and displacement (from lattice sites) vectors, and :math:`U` is the sum of
-pair, bond, angle, dihedral, improper, kspace (long-range), and fix energies.
+constant, :math:`T` is the temperature, :math:`d` is the dimensionality of the
+system (2 or 3 for 2d/3d), :math:`\vec F\cdot\Delta\vec r` is the sum of dot
+products of the atomic force vectors and displacement (from lattice sites)
+vectors, and :math:`U` is the sum of pair, bond, angle, dihedral, improper,
+kspace (long-range), and fix energies.
 
 The pressure is computed by the formula:
 
 .. math::
 
-   \left< P\right>_{HMA} = \Delta \hat P + \left< P_{vir} + \frac{\beta \Delta \hat P - \rho}{d(N-1)} F\bullet\Delta r \right>
+   \left< P\right>_{HMA} = \Delta \hat P + \left< P_\text{vir}
+   + \frac{\beta \Delta \hat P - \rho}{d(N-1)} \vec F\cdot\Delta \vec r \right>
 
-where :math:`\rho` is the number density of the system, :math:`\Delta \hat P` is the
-difference between the harmonic and lattice pressure, :math:`P_{vir}` is
-the virial pressure computed as the sum of pair, bond, angle, dihedral,
-improper, kspace (long-range), and fix contributions to the force on each
-atom, and :math:`k_B=1/k_B T`.  Although the method will work for any value of :math:`\Delta \hat P`
+where :math:`\rho` is the number density of the system, :math:`\Delta \hat P`
+is the difference between the harmonic and lattice pressure,
+:math:`P_\text{vir}` is the virial pressure computed as the sum of pair, bond,
+angle, dihedral, improper, kspace (long-range), and fix contributions to the
+force on each atom, and :math:`k_B=1/k_B T`.  Although the method will work for
+any value of :math:`\Delta \hat P`
 specified (use pressure :doc:`units <units>`), the precision of the resultant
 pressure is sensitive to :math:`\Delta \hat P`; the precision tends to be
-best when :math:`\Delta \hat P` is the actual the difference between the lattice
-pressure and harmonic pressure.
+best when :math:`\Delta \hat P` is the actual the difference between the
+lattice pressure and harmonic pressure.
 
 .. math::
 
-   \left<C_V \right>_{HMA} = \frac{d}{2} (N-1) k_B + \frac{1}{k_B T^2} \left( \left<
-   U_{HMA}^2 \right> - \left<U_{HMA}\right>^2 \right) + \frac{1}{4 T}
-   \left< F\bullet\Delta r + \Delta r \bullet \Phi \bullet \Delta r \right>
+   \left<C_V \right>_\text{HMA} = \frac{d}{2} (N-1) k_B
+    + \frac{1}{k_B T^2} \left( \left<U_\text{HMA}^2 \right>
+                         - \left<U_\text{HMA}\right>^2 \right) + \frac{1}{4 T}
+   \left<\vec F\cdot\Delta\vec r + \Delta r \cdot\Phi\cdot \Delta\vec r\right>
 
 where :math:`\Phi` is the Hessian matrix. The compute hma command
 computes the full expression for :math:`C_V` except for the
-:math:`\left<U_{HMA}^2\right>^2` in the variance term, which can be obtained by
-passing the *u* keyword; you must add this extra contribution to the :math:`C_V`
-value reported by this compute.  The variance term can cause significant
-round-off error when computing :math:`C_V`.  To address this, the *anharmonic*
-keyword can be passed and/or the output format can be specified with more
-digits.
+:math:`\left<U_\text{HMA}\right>^2` in the variance term, which can be obtained
+by passing the *u* keyword; you must add this extra contribution to the
+:math:`C_V` value reported by this compute.  The variance term can cause
+significant round-off error when computing :math:`C_V`.  To address this, the
+*anharmonic* keyword can be passed and/or the output format can be specified
+with more digits.
 
 .. code-block:: LAMMPS
 
@@ -124,8 +131,10 @@ When using this keyword, the compute must be first active (it must be included
 via a :doc:`thermo_style custom <thermo_style>` command) while the atoms are
 still at their lattice sites (before equilibration).
 
-The temp-ID specified with compute hma command should be same as the fix-ID of Nose-Hoover (:doc:`fix nvt <fix_nh>`) or
-Berendsen (:doc:`fix temp/berendsen <fix_temp_berendsen>`) thermostat used for the simulation. While using this command, Langevin thermostat
+The temp-ID specified with compute hma command should be same as the fix-ID of
+the Nose--Hoover (:doc:`fix nvt <fix_nh>`) or
+Berendsen (:doc:`fix temp/berendsen <fix_temp_berendsen>`) thermostat used for
+the simulation. While using this command, the Langevin thermostat
 (:doc:`fix langevin <fix_langevin>`)
 should be avoided as its extra forces interfere with the HMA implementation.
 
@@ -160,7 +169,7 @@ Output info
 
 This compute calculates a global vector that includes the n properties
 requested as arguments to the command (the potential energy, pressure and/or heat
-capacity).  The elements of the vector can be accessed by indices 1-n by any
+capacity).  The elements of the vector can be accessed by indices 1--n by any
 command that uses global vector values as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output options.
 
 The vector values calculated by this compute are "extensive".  The
@@ -180,7 +189,7 @@ Related commands
 :doc:`compute pe <compute_pe>`, :doc:`compute pressure <compute_pressure>`
 
 :doc:`dynamical matrix <dynamical_matrix>` provides a finite difference
-formulation of the hessian provided by Pair's single_hessian, which is used by
+formulation of the Hessian provided by Pair's single_hessian, which is used by
 this compute.
 
 Default

doc/src/compute_improper.rst

@@ -6,7 +6,7 @@ compute improper command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID improper
 
@@ -34,11 +34,13 @@ total energy contributed by one or more of the hybrid sub-styles.
 Output info
 """""""""""
 
-This compute calculates a global vector of length N where N is the
-number of sub_styles defined by the :doc:`improper_style hybrid <improper_style>` command.  which can be accessed by indices
-1-N.  These values can be used by any command that uses global scalar
-or vector values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
-options.
+This compute calculates a global vector of length :math:`N`, where :math:`N` is
+the number of sub_styles defined by the
+:doc:`improper_style hybrid <improper_style>` command.
+These styles can be accessed by the indices 1 through :math:`N`.
+These values can be used by any command that uses global scalar or vector
+values from a compute as input.  See the :doc:`Howto output <Howto_output>`
+page for an overview of LAMMPS output options.
 
 The vector values are "extensive" and will be in energy
 :doc:`units <units>`.

doc/src/compute_improper_local.rst

@@ -6,7 +6,7 @@ compute improper/local command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID improper/local value1 value2 ...
 
@@ -40,7 +40,7 @@ the individual improper styles listed on
 
 The local data stored by this command is generated by looping over all
 the atoms owned on a processor and their impropers.  An improper will
-only be included if all 4 atoms in the improper are in the specified
+only be included if all four atoms in the improper are in the specified
 compute group.
 
 Note that as atoms migrate from processor to processor, there will be
@@ -69,7 +69,8 @@ array is the number of impropers.  If a single keyword is specified, a
 local vector is produced.  If two or more keywords are specified, a
 local array is produced where the number of columns = the number of
 keywords.  The vector or array can be accessed by any command that
-uses local values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
+uses local values from a compute as input.  See the
+:doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
 options.
 
 The output for *chi* will be in degrees.

doc/src/compute_inertia_chunk.rst

@@ -6,7 +6,7 @@ compute inertia/chunk command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID inertia/chunk chunkID
 
@@ -27,16 +27,20 @@ Description
 Define a computation that calculates the inertia tensor for multiple
 chunks of atoms.
 
-In LAMMPS, chunks are collections of atoms defined by a :doc:`compute chunk/atom <compute_chunk_atom>` command, which assigns each atom
+In LAMMPS, chunks are collections of atoms defined by a
+:doc:`compute chunk/atom <compute_chunk_atom>` command, which assigns each atom
 to a single chunk (or no chunk).  The ID for this command is specified
 as chunkID.  For example, a single chunk could be the atoms in a
-molecule or atoms in a spatial bin.  See the :doc:`compute chunk/atom <compute_chunk_atom>` and :doc:`Howto chunk <Howto_chunk>`
+molecule or atoms in a spatial bin.  See the
+:doc:`compute chunk/atom <compute_chunk_atom>` and
+:doc:`Howto chunk <Howto_chunk>`
 doc pages for details of how chunks can be defined and examples of how
 they can be used to measure properties of a system.
 
-This compute calculates the 6 components of the symmetric inertia
-tensor for each chunk, ordered Ixx,Iyy,Izz,Ixy,Iyz,Ixz.  The
-calculation includes all effects due to atoms passing through periodic
+This compute calculates the six components of the symmetric inertia
+tensor for each chunk, ordered
+:math:`I_{xx},I_{yy},I_{zz},I_{xy},I_{yz},I_{xz}`.
+The calculation includes all effects due to atoms passing through periodic
 boundaries.
 
 Note that only atoms in the specified group contribute to the
@@ -55,7 +59,8 @@ non-zero chunk IDs.
    of "unwrapped" coordinates.  See the Atoms section of the
    :doc:`read_data <read_data>` command for a discussion of image flags and
    how they are set for each atom.  You can reset the image flags
-   (e.g. to 0) before invoking this compute by using the :doc:`set image <set>` command.
+   (e.g., to 0) before invoking this compute by using the
+   :doc:`set image <set>` command.
 
 The simplest way to output the results of the compute inertia/chunk
 calculation to a file is to use the :doc:`fix ave/time <fix_ave_time>`
@@ -71,14 +76,16 @@ Output info
 """""""""""
 
 This compute calculates a global array where the number of rows = the
-number of chunks *Nchunk* as calculated by the specified :doc:`compute chunk/atom <compute_chunk_atom>` command.  The number of columns =
-6 for the 6 components of the inertia tensor for each chunk, ordered
-as listed above.  These values can be accessed by any command that
-uses global array values from a compute as input.  See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
+number of chunks *Nchunk* as calculated by the specified
+:doc:`compute chunk/atom <compute_chunk_atom>` command.
+The number of columns is 6, one for each of the 6 components of the inertia
+tensor for each chunk, ordered as listed above.  These values can be accessed
+by any command that uses global array values from a compute as input.  See the
+:doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
 options.
 
 The array values are "intensive".  The array values will be in
-mass\*distance\^2 :doc:`units <units>`.
+mass\*distance\ :math:`^2` :doc:`units <units>`.
 
 Restrictions
 """"""""""""

doc/src/compute_ke.rst

@@ -6,7 +6,7 @@ compute ke command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID ke
 
@@ -27,7 +27,8 @@ Define a computation that calculates the translational kinetic energy
 of a group of particles.
 
 The kinetic energy of each particle is computed as :math:`\frac{1}{2} m
-v^2`, where *m* and *v* are the mass and velocity of the particle.
+v^2`, where *m* and *v* are the mass and velocity of the particle,
+respectively.
 
 There is a subtle difference between the quantity calculated by this
 compute and the kinetic energy calculated by the *ke* or *etotal*
@@ -38,10 +39,10 @@ formula above.  For thermodynamic output, the *ke* keyword infers
 kinetic energy from the temperature of the system with
 :math:`\frac{1}{2} k_B T` of energy for each degree of freedom.  For the
 default temperature computation via the :doc:`compute temp
-<compute_temp>` command, these are the same.  But different computes
-that calculate temperature can subtract out different non-thermal
-components of velocity and/or include different degrees of freedom
-(translational, rotational, etc).
+<compute_temp>` command, these are the same.
+However, different computes that calculate temperature can subtract out
+different non-thermal components of velocity and/or include different degrees
+of freedom (translational, rotational, etc.).
 
 Output info
 """""""""""

doc/src/compute_ke_atom.rst

@@ -6,7 +6,7 @@ compute ke/atom command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID ke/atom
 
@@ -26,8 +26,8 @@ Description
 Define a computation that calculates the per-atom translational
 kinetic energy for each atom in a group.
 
-The kinetic energy is simply 1/2 m v\^2, where m is the mass and v is
-the velocity of each atom.
+The kinetic energy is simply :math:`\frac12 m v^2`, where :math:`m` is the mass
+and :math:`v` is the velocity of each atom.
 
 The value of the kinetic energy will be 0.0 for atoms not in the
 specified compute group.

doc/src/compute_ke_atom_eff.rst

@@ -6,7 +6,7 @@ compute ke/atom/eff command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID ke/atom/eff
 

doc/src/compute_ke_eff.rst

@@ -6,7 +6,7 @@ compute ke/eff command
 Syntax
 """"""
 
-.. parsed-literal::
+.. code-block:: LAMMPS
 
    compute ID group-ID ke/eff
 
@@ -29,9 +29,9 @@ group of eFF particles (nuclei and electrons), as modeled with the
 
 The kinetic energy for each nucleus is computed as :math:`\frac{1}{2} m
 v^2` and the kinetic energy for each electron is computed as
-:math:`\frac{1}{2}(m_e v^2 + \frac{3}{4} m_e s^2)`, where *m*
-corresponds to the nuclear mass, :math:`m_e` to the electron mass, *v*
-to the translational velocity of each particle, and *s* to the radial
+:math:`\frac{1}{2}(m_e v^2 + \frac{3}{4} m_e s^2)`, where :math:`m`
+corresponds to the nuclear mass, :math:`m_e` to the electron mass, :math:`v`
+to the translational velocity of each particle, and :math:`s` to the radial
 velocity of the electron, respectively.
 
 There is a subtle difference between the quantity calculated by this