ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

More math and code-block edits

Browse Source
This commit is contained in:
Karl Hammond
2022-08-15 23:48:30 -05:00
parent 288dd03ee2
commit 953f63bb8f
27 changed files with 262 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
doc/src/compute.rst
View File

@ -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

14
doc/src/compute_cluster_atom.rst
View File

@ -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.

3
doc/src/compute_com.rst
View File

@ -38,7 +38,8 @@ are the :math:`(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
"""""""""""

13
doc/src/compute_com_chunk.rst
View File

@ -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,13 +71,13 @@ 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.
The array values are "intensive". The array values will be in
The array values are "intensive." The array values will be in
distance :doc:`units <units>`.
Restrictions

6
doc/src/compute_contact_atom.rst
View File

@ -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
""""""""""""

36
doc/src/compute_coord_atom.rst
View File

@ -9,7 +9,7 @@ Accelerator Variants: *coord/atom/kk*
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID coord/atom cstyle args ...
@ -19,13 +19,13 @@ Syntax
.. 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

4
doc/src/compute_damage_atom.rst
View File

@ -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
""""""""""""

12
doc/src/compute_dihedral.rst
View File

@ -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

43
doc/src/compute_dihedral_local.rst
View File

@ -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.

19
doc/src/compute_dilatation_atom.rst
View File

@ -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
""""""""""""""""

9
doc/src/compute_dipole.rst
View File

@ -6,7 +6,7 @@ compute dipole command
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID dipole charge-correction
@ -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
@ -54,8 +54,9 @@ the computed dipole moment and a global vector of length 3 with the
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>`.
The computed values are "intensive." The array values will be in
dipole units (i.e., charge :doc:`units <units>` times distance
:doc:`units <units>`).
Restrictions
""""""""""""

17
doc/src/compute_dipole_chunk.rst
View File

@ -6,7 +6,7 @@ compute dipole/chunk command
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID dipole/chunk chunkID charge-correction
@ -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>`.
The array values are "intensive." The array values will be in
dipole units (i.e., charge :doc:`units <units>` times distance
:doc:`units <units>`).
Restrictions
""""""""""""

20
doc/src/compute_displace_atom.rst
View File

@ -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.
----------
@ -101,8 +101,8 @@ 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)
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 +125,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.

31
doc/src/compute_dpd.rst
View File

@ -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.

27
doc/src/compute_dpd_atom.rst
View File

@ -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
""""""""""""

2
doc/src/compute_edpd_temp_atom.rst
View File

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

17
doc/src/compute_efield_atom.rst
View File

@ -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
"""""""""""

40
doc/src/compute_entropy_atom.rst
View File

@ -6,14 +6,14 @@ 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::
@ -53,31 +53,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,20 +91,20 @@ 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 4.05 Ångströms),
.. parsed-literal::
compute 1 all entropy/atom 0.25 5.7 avg yes 3.7
and for bcc sodium (lattice constant 4.23 Angstroms),
and for bcc sodium (lattice constant 4.23 Ångströms),
.. parsed-literal::
@ -114,7 +115,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

12
doc/src/compute_erotate_asphere.rst
View File

@ -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::
@ -48,7 +48,7 @@ used by any command that uses a global scalar value from a compute as
input. See the :doc:`Howto output <Howto_output>` page for an
overview of LAMMPS output options.
The scalar value calculated by this compute is "extensive". The
The scalar value calculated by this compute is "extensive." The
scalar value will be in energy :doc:`units <units>`.
Restrictions
@ -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

23
doc/src/compute_erotate_rigid.rst
View File

@ -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
"""""""""""
@ -46,14 +48,15 @@ of all the rigid bodies). This value can be used by any command that
uses a global scalar value from a compute as input. See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
options.
The scalar value calculated by this compute is "extensive". The
The scalar value calculated by this compute is "extensive." The
scalar value will be in energy :doc:`units <units>`.
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
""""""""""""""""

9
doc/src/compute_erotate_sphere.rst
View File

@ -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::
@ -43,7 +44,7 @@ used by any command that uses a global scalar value from a compute as
input. See the :doc:`Howto output <Howto_output>` page for an
overview of LAMMPS output options.
The scalar value calculated by this compute is "extensive". The
The scalar value calculated by this compute is "extensive." The
scalar value will be in energy :doc:`units <units>`.
Restrictions

10
doc/src/compute_erotate_sphere_atom.rst
View File

@ -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
"""""""""""

9
doc/src/compute_event_displace.rst
View File

@ -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
@ -51,7 +50,7 @@ used by any command that uses a global scalar value from a compute as
input. See the :doc:`Howto output <Howto_output>` page for an
overview of LAMMPS output options.
The scalar value calculated by this compute is "intensive". The
The scalar value calculated by this compute is "intensive." The
scalar value will be a 0 or 1 as explained above.
Restrictions

44
doc/src/compute_fabric.rst
View File

@ -6,7 +6,7 @@ compute fabric command
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID fabric cutoff attribute1 attribute2 ... keyword values ...
@ -63,7 +63,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 +75,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 +92,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 +118,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 +135,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 +168,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
""""""""""""""""

31
doc/src/compute_fep.rst
View File

@ -6,7 +6,7 @@ compute fep command
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID fep temp attribute args ... keyword value ...
@ -19,7 +19,7 @@ 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)
@ -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
@ -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,7 +126,7 @@ 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::
@ -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
@ -298,7 +299,7 @@ These output results can be used by any command that uses a global
scalar or vector from a compute as input. See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS output
options. For example, the computed values can be averaged using :doc:`fix ave/time <fix_ave_time>`.
The values calculated by this compute are "extensive".
The values calculated by this compute are "extensive."
Restrictions
""""""""""""

19
doc/src/compute_fep_ta.rst
View File

@ -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{kT}{\Delta \mathcal{A}} \ln \left\langle \exp\left(\frac{-(U_1 - U_0)}{kT}\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)/kT\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

24
doc/src/compute_tally.rst
View File

@ -26,7 +26,7 @@ compute stress/tally command
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID style group2-ID
@ -57,8 +57,8 @@ accumulated directly during the non-bonded force computation. The
computes *force/tally*, *pe/tally*, *stress/tally*, and
*heat/flux/tally* are primarily provided as example how to program
additional, more sophisticated computes using the tally callback
mechanism. Compute *pe/mol/tally* is one such style, that can
- through using this mechanism - separately tally intermolecular
mechanism. Compute *pe/mol/tally* is one such style, that can---through using
this mechanism---separately tally intermolecular
and intramolecular energies. Something that would otherwise be
impossible without integrating this as a core functionality into
the base classes of LAMMPS.
@ -92,7 +92,7 @@ Although, the *heat/flux/virial/tally* compute
does not include the convective term,
it can be used to obtain the total heat flux over control surfaces,
when there are no particles crossing over,
such as is often in solid-solid and solid-liquid interfaces.
such as is often in solid--solid and solid--liquid interfaces.
This would be identical to the method of planes method.
Note that the *heat/flux/virial/tally* compute is distinctly different
from the *heat/flux* and *heat/flux/tally* computes,
@ -152,7 +152,7 @@ Output info
atom scalar (the contributions of the single atom to the global
scalar).
- Compute *pe/mol/tally* calculates a global 4-element vector containing
- Compute *pe/mol/tally* calculates a global four-element vector containing
(in this order): *evdwl* and *ecoul* for intramolecular pairs and
*evdwl* and *ecoul* for intermolecular pairs. Since molecules are
identified by their molecule IDs, the partitioning does not have to be
@ -165,24 +165,24 @@ Output info
- Compute *stress/tally* calculates a global scalar
(average of the diagonal elements of the stress tensor) and a per atom
vector (the 6 elements of stress tensor contributions from the
vector (the six elements of stress tensor contributions from the
individual atom).
- As in :doc:`compute heat/flux <compute_heat_flux>`,
compute *heat/flux/tally* calculates a global vector of length 6,
where the first 3 components are the :math:`x`, :math:`y`, :math:`z`
where the first three components are the :math:`x`, :math:`y`, :math:`z`
components of the full heat flow vector,
and the next 3 components are the corresponding components
of just the convective portion of the flow, i.e. the
first term in the equation for :math:`\mathbf{Q}`.
and the next three components are the corresponding components
of just the convective portion of the flow (i.e., the
first term in the equation for :math:`\mathbf{Q}`).
- Compute *heat/flux/virial/tally* calculates a global scalar (heat flow)
and a per atom 3-element vector
and a per atom three-element vector
(contribution to the force acting over atoms in the first group
from individual atoms in both groups).
Both the scalar and vector values calculated by this compute are
"extensive".
"extensive."
Restrictions
""""""""""""