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

More cosmetic edits to documentation

Browse Source
This commit is contained in:
Karl Hammond
2022-08-18 19:25:06 -05:00
parent 8a9cd4b2b5
commit d03f0a6716
8 changed files with 211 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
doc/src/compute_stress_mop.rst
View File

@ -10,7 +10,7 @@ compute stress/mop/profile command
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID style dir args keywords ...
@ -28,6 +28,9 @@ Syntax
origin = *lower* or *center* or *upper* or coordinate value (distance units) is the position of the first plane
delta = value (distance units) is the distance between planes
Examples
""""""""
.. code-block:: LAMMPS
compute 1 all stress/mop x lower total
@ -49,7 +52,7 @@ components are computed in directions *dir*,\ *x*\ ; *dir*,\ *y*\ ; and
*dir*,\ *z*\ ; where *dir* is the direction normal to the plane, while
in compute *stress/mop/profile* the profile of the stress is computed.
Contrary to methods based on histograms of atomic stress (i.e. using
Contrary to methods based on histograms of atomic stress (i.e., using
:doc:`compute stress/atom <compute_stress_atom>`), the method of planes is
compatible with mechanical balance in heterogeneous systems and at
interfaces :ref:`(Todd) <mop-todd>`.
@ -57,9 +60,9 @@ interfaces :ref:`(Todd) <mop-todd>`.
The stress tensor is the sum of a kinetic term and a configurational
term, which are given respectively by Eq. (21) and Eq. (16) in
:ref:`(Todd) <mop-todd>`. For the kinetic part, the algorithm considers that
atoms have crossed the plane if their positions at times t-dt and t are
one on either side of the plane, and uses the velocity at time t-dt/2
given by the velocity-Verlet algorithm.
atoms have crossed the plane if their positions at times :math:`t-\Delta t`
and :math:`t` are one on either side of the plane, and uses the velocity at
time :math:`t-\Delta t/2` given by the velocity Verlet algorithm.
Between one and three keywords can be used to indicate which
contributions to the stress must be computed: kinetic stress (kin),
@ -74,11 +77,9 @@ command, since those are contributions to the global system pressure.
NOTE 3: The local stress profile generated by compute *stress/mop/profile*
is similar to that obtained by compute
:doc:`stress/cartesian <compute_stress_profile>`.
A key difference
is that compute *stress/mop/profile* considers particles
crossing a set of planes,
while compute *stress/cartesian* computes averages for a set of
small volumes. More information
A key difference is that compute *stress/mop/profile* considers particles
crossing a set of planes, while compute *stress/cartesian* computes averages
for a set of small volumes. More information
on the similarities and differences can be found in
:ref:`(Ikeshoji)<Ikeshoji2>`.

42
doc/src/compute_stress_profile.rst
View File

@ -15,7 +15,7 @@ compute stress/spherical command
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID style args
@ -64,7 +64,7 @@ gives the total stress tensor :math:`P = P^k+P^v`. These computes can
for example be used to calculate the diagonal components of the local
stress tensor of interfaces with flat, cylindrical, or spherical
symmetry. These computes obeys momentum balance through fluid
interfaces. They use the Irving-Kirkwood contour, which is the straight
interfaces. They use the Irving--Kirkwood contour, which is the straight
line between particle pairs.
The *stress/cartesian* computes the stress profile along one or two
@ -84,27 +84,28 @@ center of the local volume in the first and second dimensions, number
density, :math:`P^k_{xx}`, :math:`P^k_{yy}`, :math:`P^k_{zz}`,
:math:`P^v_{xx}`, :math:`P^v_{yy}`, and :math:`P^v_{zz}`. There are 8
columns when one dimension is specified and 9 columns when two
dimensions are specified. The number of bins/rows are
(L1/bin_width1)*(L2/bin_width2), L1 and L2 are the sizes of the
simulation box in the specified dimensions, and bin_width1 and
bin_width2 are the specified bin widths. When only one dimension is
specified the number of bins/rows are L1/bin_width.
dimensions are specified. The number of bins (rows) is
:math:`(L_1/b_1)(L_2/b_2)`, where :math:`L_1` and :math:`L_2` are the lengths
of the simulation box in the specified dimensions and :math:`b_1` and
:math:`b_2` are the specified bin widths. When only one dimension is
specified, the number of bins (rows) is :math:`L_1/b_1`.
The default output columns for *stress/cylinder* are the radius to the
center of the cylindrical shell, number density, :math:`P^k_{rr}`,
:math:`P^k_{\phi\phi}`, :math:`P^k_{zz}`, :math:`P^v_{rr}`,
:math:`P^v_{\phi\phi}`, and :math:`P^v_{zz}`. When the keyword *ke* is
set to no, the kinetic contributions are not calculated, and
consequently there are only 5 columns the radius to the center of the
cylindrical shell, number density, :math:`P^v_{rr}`,
:math:`P^v_{\phi\phi}`, :math:`P^v_{zz}`. The number of bins/rows are
Rmax/bin_width.
set to *no*, the kinetic contributions are not calculated, and
consequently there are only 5 columns: the position of the center of the
cylindrical shell, the number density, :math:`P^v_{rr}`,
:math:`P^v_{\phi\phi}`, and :math:`P^v_{zz}`. The number of bins (rows) is
:math:`R_\text{max}/b`, where :math:`b` is the specified bin width.
The output columns for *stress/spherical* are the radius to the center
of the spherical shell, number density, :math:`P^k_{rr}`,
The output columns for *stress/spherical* are the position of the center
of the spherical shell, the number density, :math:`P^k_{rr}`,
:math:`P^k_{\theta\theta}`, :math:`P^k_{\phi\phi}`, :math:`P^v_{rr}`,
:math:`P^v_{\theta\theta}`, and :math:`P^v_{\phi\phi}`. There are 8
columns and the number of bins/rows are Rmax/bin_width.
columns and the number of bins (rows) is :math:`R_\text{max}/b`, where
:math:`b` is the specified bin width.
This array can be output with :doc:`fix ave/time <fix_ave_time>`,
@ -113,12 +114,13 @@ This array can be output with :doc:`fix ave/time <fix_ave_time>`,
compute p all stress/cartesian x 0.1
fix 2 all ave/time 100 1 100 c_p[*] file dump_p.out mode vector
The values calculated by this compute are "intensive". The stress
The values calculated by this compute are "intensive." The stress
values will be in pressure :doc:`units <units>`. The number density
values are in inverse volume :doc:`units <units>`.
NOTE 1: The local stress does not include any Lennard-Jones tail
corrections to the stress added by the :doc:`pair_modify tail yes <pair_modify>`
corrections to the stress added by the
:doc:`pair_modify tail yes <pair_modify>`
command, since those are contributions to the global system pressure.
NOTE 2: The local stress profiles generated by these computes are
@ -135,11 +137,11 @@ Restrictions
""""""""""""
These computes calculate the stress tensor contributions for pair
styles only (i.e. no bond, angle, dihedral, etc. contributions, and in
styles only (i.e., no bond, angle, dihedral, etc. contributions, and in
the presence of bonded interactions, the result will be incorrect due to
exclusions for special bonds) and requires pairwise force calculations
not available for most many-body pair styles. K-space calculations are
also excluded.
not available for most many-body pair styles.
Note that :math:`k`-space calculations are also excluded.
These computes are part of the EXTRA-COMPUTE package. They are only
enabled if LAMMPS was built with that package. See the :doc:`Build

2
doc/src/compute_tdpd_cc_atom.rst
View File

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

35
doc/src/compute_temp.rst
View File

@ -9,7 +9,7 @@ Accelerator Variants: *temp/kk*
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID temp
@ -29,19 +29,27 @@ Description
Define a computation that calculates the temperature of a group of
atoms. A compute of this style can be used by any command that
computes a temperature, e.g. :doc:`thermo_modify <thermo_modify>`, :doc:`fix temp/rescale <fix_temp_rescale>`, :doc:`fix npt <fix_nh>`, etc.
computes a temperature (e.g., :doc:`thermo_modify <thermo_modify>`,
:doc:`fix temp/rescale <fix_temp_rescale>`, :doc:`fix npt <fix_nh>`)
The temperature is calculated by the formula KE = dim/2 N k T, where
KE = total kinetic energy of the group of atoms (sum of 1/2 m v\^2),
dim = 2 or 3 = dimensionality of the simulation, N = number of atoms
in the group, k = Boltzmann constant, and T = temperature.
The temperature is calculated by the formula
A kinetic energy tensor, stored as a 6-element vector, is also
.. math::
\mathrm{KE} = \frac{\text{dim}}{2} N k T,
where KE = total kinetic energy of the group of atoms (sum of
:math:`\frac12 m v^2`), dim = 2 or 3 is the dimensionality of the simulation,
:math:`N` is the number of atoms in the group, :math:`k` is the Boltzmann
constant, and :math:`T` is the absolute temperature.
A kinetic energy tensor, stored as a six-element vector, is also
calculated by this compute for use in the computation of a pressure
tensor. The formula for the components of the tensor is the same as
the above formula, except that v\^2 is replaced by vx\*vy for the xy
component, etc. The 6 components of the vector are ordered xx, yy,
zz, xy, xz, yz.
the above formula, except that :math:`v^2` is replaced by
:math:`v_x v_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`.
The number of atoms contributing to the temperature is assumed to be
constant for the duration of the run; use the *dynamic* option of the
@ -77,12 +85,13 @@ Output info
"""""""""""
This compute calculates a global scalar (the temperature) and a global
vector of length 6 (KE tensor), which can be accessed by indices 1-6.
vector of length six (KE tensor), which can be accessed by indices 1--6.
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 scalar value calculated by this compute is "intensive". The
The scalar value calculated by this compute is "intensive." The
vector values are "extensive".
The scalar value will be in temperature :doc:`units <units>`. The

50
doc/src/compute_temp_asphere.rst
View File

@ -6,7 +6,7 @@ compute temp/asphere command
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID temp/asphere keyword value ...
@ -42,9 +42,9 @@ usual :doc:`compute temp <compute_temp>` command, which assumes point
particles with only translational kinetic energy.
Only finite-size particles (aspherical or spherical) can be included
in the group. For 3d finite-size particles, each has 6 degrees of
freedom (3 translational, 3 rotational). For 2d finite-size
particles, each has 3 degrees of freedom (2 translational, 1
in the group. For 3d finite-size particles, each has six degrees of
freedom (three translational, three rotational). For 2d finite-size
particles, each has three degrees of freedom (two translational, one
rotational).
.. note::
@ -54,26 +54,26 @@ rotational).
freely rotate, sampling all their rotational dof. It is possible to
use a combination of interaction potentials and fixes that induce no
torque or otherwise constrain some of all of your particles so that
this is not the case. Then there are less dof and you should use the
this is not the case. Then there are fewer dof and you should use the
:doc:`compute_modify extra <compute_modify>` command to adjust the dof
accordingly.
For example, an aspherical particle with all three of its shape
parameters the same is a sphere. If it does not rotate, then it
should have 3 dof instead of 6 in 3d (or 2 instead of 3 in 2d). A
uniaxial aspherical particle has two of its three shape parameters the
should have 3 dof instead of 6 in 3d (or two instead of three in 2d).
A uniaxial aspherical particle has two of its three shape parameters the
same. If it does not rotate around the axis perpendicular to its
circular cross section, then it should have 5 dof instead of 6 in 3d.
The latter is the case for uniaxial ellipsoids in a :doc:`GayBerne model <pair_gayberne>` since there is no induced torque around the
optical axis. It will also be the case for bi-axial ellipsoids when
optical axis. It will also be the case for biaxial ellipsoids when
exactly two of the semiaxes have the same length and the corresponding
relative well depths are equal.
The translational kinetic energy is computed the same as is described
by the :doc:`compute temp <compute_temp>` command. 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.
kinetic energy is 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.
.. note::
@ -81,12 +81,13 @@ computed from its angular momentum.
ellipsoids, not ellipses, meaning their moments of inertia will be the
same as in 3d.
A kinetic energy tensor, stored as a 6-element vector, is also
A kinetic energy tensor, stored as a six-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 v\^2 and w\^2 are
replaced by vx\*vy and wx\*wy for the xy component, and the appropriate
elements of the inertia tensor are used. The 6 components of the
vector are ordered xx, yy, zz, xy, xz, yz.
tensor is the same as the above formula, except that :math:`v^2` and
:math:`\omega^2` are replaced by :math:`v_x v_y` and :math:`\omega_x \omega_y`
for the :math:`xy` component, and the appropriate elements of the moment of
inertia tensor are used. The six components of the vector are ordered
:math:`xx`, :math:`yy`, :math:`zz`, :math:`xy`, :math:`xz`, :math:`yz`.
The number of atoms contributing to the temperature is assumed to be
constant for the duration of the run; use the *dynamic* option of the
@ -111,14 +112,14 @@ For the *bias* keyword, *bias-ID* refers to the ID of a temperature
compute that removes a "bias" velocity from each atom. This allows
compute temp/sphere to compute its thermal temperature after the
translational kinetic energy components have been altered in a
prescribed way, e.g. to remove a flow velocity profile. Thermostats
prescribed way (e.g., to remove a flow velocity profile). Thermostats
that use this compute will work with this bias term. See the doc
pages for individual computes that calculate a temperature and the doc
pages for fixes that perform thermostatting for more details.
For the *dof* keyword, a setting of *all* calculates a temperature
that includes both translational and rotational degrees of freedom. A
setting of *rotate* calculates a temperature that includes only
that includes both translational and rotational degrees of freedom.
A setting of *rotate* calculates a temperature that includes only
rotational degrees of freedom.
----------
@ -127,13 +128,14 @@ Output info
"""""""""""
This compute calculates a global scalar (the temperature) and a global
vector of length 6 (KE tensor), which can be accessed by indices 1-6.
vector of length 6 (KE tensor), which can be accessed by indices 1--6.
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.
vector values 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
vector values are "extensive".
The scalar value calculated by this compute is "intensive." The
vector values are "extensive."
The scalar value will be in temperature :doc:`units <units>`. The
vector values will be in energy :doc:`units <units>`.

44
doc/src/compute_temp_body.rst
View File

@ -6,7 +6,7 @@ compute temp/body command
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID temp/body keyword value ...
@ -57,23 +57,25 @@ rotational).
The translational kinetic energy is computed the same as is described
by the :doc:`compute temp <compute_temp>` command. 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.
kinetic energy is computed as :math:`\frac12 I \omega^2`, where :math:`I`
is the moment of inertia tensor for the aspherical particle and :math:`\omega`
is its angular velocity, which is computed from its angular momentum.
A kinetic energy 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 v\^2 and w\^2 are
replaced by vx\*vy and wx\*wy for the xy component, and the appropriate
elements of the inertia tensor are used. The 6 components of the
vector are ordered xx, yy, zz, xy, xz, yz.
A kinetic energy 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:`v^2` and :math:`\omega^2` are
replaced by :math:`v_x v_y` and :math:`\omega_x \omega_y` for the
math:`xy` component, and the appropriate elements of the inertia tensor are
used. The six components of the vector are ordered :math:`xx`, :math:`yy`,
:math:`zz`, :math:`xy`, :math:`xz`, :math:`yz`.
The number of atoms contributing to the temperature is assumed to be
constant for the duration of the run; use the *dynamic* option of the
:doc:`compute_modify <compute_modify>` command if this is not the case.
This compute subtracts out translational degrees-of-freedom due to
fixes that constrain molecular motion, such as :doc:`fix shake <fix_shake>` and :doc:`fix rigid <fix_rigid>`. This means the
fixes that constrain molecular motion, such as :doc:`fix shake <fix_shake>`
and :doc:`fix rigid <fix_rigid>`. This means the
temperature of groups of atoms that include these constraints will be
computed correctly. If needed, the subtracted degrees-of-freedom can
be altered using the *extra* option of the
@ -91,7 +93,7 @@ For the *bias* keyword, *bias-ID* refers to the ID of a temperature
compute that removes a "bias" velocity from each atom. This allows
compute temp/sphere to compute its thermal temperature after the
translational kinetic energy components have been altered in a
prescribed way, e.g. to remove a flow velocity profile. Thermostats
prescribed way (e.g., to remove a flow velocity profile). Thermostats
that use this compute will work with this bias term. See the doc
pages for individual computes that calculate a temperature and the doc
pages for fixes that perform thermostatting for more details.
@ -107,22 +109,24 @@ Output info
"""""""""""
This compute calculates a global scalar (the temperature) and a global
vector of length 6 (KE tensor), which can be accessed by indices 1-6.
vector of length 6 (KE tensor), which can be accessed by indices 1--6.
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.
vector values 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
vector values are "extensive".
The scalar value calculated by this compute is "intensive." The
vector values are "extensive."
The scalar value will be in temperature :doc:`units <units>`. The
vector values will be in energy :doc:`units <units>`.
The scalar value will be in temperature :doc:`units <units>`.
The vector values will be in energy :doc:`units <units>`.
Restrictions
""""""""""""
This compute is part of the BODY 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 compute requires that atoms store angular momentum and a
quaternion as defined by the :doc:`atom_style body <atom_style>`

127
doc/src/compute_temp_chunk.rst
View File

@ -6,14 +6,14 @@ compute temp/chunk command
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID temp/chunk chunkID value1 value2 ... keyword value ...
* ID, group-ID are documented in :doc:`compute <compute>` command
* temp/chunk = style name of this compute command
* chunkID = ID of :doc:`compute chunk/atom <compute_chunk_atom>` command
* zero or more values can be listed as value1,value2,etc
* zero or more values can be listed as value1,value2,etc.
* value = *temp* or *kecom* or *internal*
.. parsed-literal::
@ -55,31 +55,43 @@ center-of-mass velocity of each chunk. By specifying optional values,
it can also calculate the per-chunk temperature or energies of the
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.
The temperature is calculated by the formula KE = DOF/2 k T, where KE =
total kinetic energy of all atoms assigned to chunks (sum of 1/2 m
v\^2), DOF = the total number of degrees of freedom for those atoms, k
= Boltzmann constant, and T = temperature.
The temperature is calculated by the formula
The DOF is calculated as N\*adof + Nchunk\*cdof, where N = number of
atoms contributing to the KE, adof = degrees of freedom per atom, and
cdof = degrees of freedom per chunk. By default adof = 2 or 3 =
dimensionality of system, as set via the :doc:`dimension <dimension>`
command, and cdof = 0.0. This gives the usual formula for
temperature.
.. math::
A kinetic energy tensor, stored as a 6-element vector, is also
\text{KE} = \frac{\text{dof}}{2} k T,
where KE is the total kinetic energy of all atoms assigned to chunks
(sum of :math:`\frac12 m v^2`), dof is the the total number of degrees of
freedom for those atoms, :math:`k` is Boltzmann constant, and :math:`T` is the
absolute temperature.
The DOF is calculated as :math:`N\times`\ *adof*
+ :math:`N_\text{chunk}\times`\ *cdof*,
where :math:`N` is the number of atoms contributing to the kinetic energy,
*adof* is the number of degrees of freedom per atom, and
*cdof* is the number of degrees of freedom per chunk.
By default, *adof* = 2 or 3 = dimensionality of system, as set via the
:doc:`dimension <dimension>` command, and *cdof* = 0.0.
This gives the usual formula for temperature.
A kinetic energy tensor, stored as a six-element vector, is also
calculated by this compute for use in the computation of a pressure
tensor. The formula for the components of the tensor is the same as
the above formula, except that v\^2 is replaced by vx\*vy for the xy
component, etc. The 6 components of the vector are ordered xx, yy,
zz, xy, xz, yz.
the above formula, except that :math:`v^2` is replaced by
:math:`v_x v_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 the number of atoms contributing to the temperature is
calculated each time the temperature is evaluated since it is assumed
@ -91,17 +103,24 @@ If any optional values are specified, then per-chunk quantities are
also calculated and stored in a global array, as described below.
The *temp* value calculates the temperature for each chunk by the
formula KE = DOF/2 k T, where KE = total kinetic energy of the chunk
of atoms (sum of 1/2 m v\^2), DOF = the total number of degrees of
freedom for all atoms in the chunk, k = Boltzmann constant, and T =
temperature.
formula
The DOF in this case is calculated as N\*adof + cdof, where N = number
of atoms in the chunk, adof = degrees of freedom per atom, and cdof =
degrees of freedom per chunk. By default adof = 2 or 3 =
dimensionality of system, as set via the :doc:`dimension <dimension>`
command, and cdof = 0.0. This gives the usual formula for
temperature.
.. math::
\text{KE} = \frac{\text{dof}}{2} k T,
where KE is the total kinetic energy of the chunk of atoms (sum of
:math:`\frac12 m v^2`), dof is the total number of degrees of freedom for all
atoms in the chunk, :math:`k` is the Boltzmann constant, and :math:`T` is the
absolute temperature.
The number of degrees of freedom (dof) in this case is calculated as
:math:`N\times`\ *adof* + *cdof*, where :math:`N` is the number
of atoms in the chunk, *adof* is the number of degrees of freedom
per atom, and *cdof* is the number of degrees of freedom per
chunk. By default, *cdof* = 2 or 3 = dimensionality of system, as set
via the :doc:`dimension <dimension>` command, and *cdof* = 0.0.
This gives the usual formula for temperature.
The *kecom* value calculates the kinetic energy of each chunk as if
all its atoms were moving with the velocity of the center-of-mass of
@ -118,9 +137,11 @@ Note that currently the global and per-chunk temperatures calculated
by this compute only include translational degrees of freedom for each
atom. No rotational degrees of freedom are included for finite-size
particles. Also no degrees of freedom are subtracted for any velocity
bias or constraints that are applied, such as :doc:`compute temp/partial <compute_temp_partial>`, or :doc:`fix shake <fix_shake>`
or :doc:`fix rigid <fix_rigid>`. This is because those degrees of
freedom (e.g. a constrained bond) could apply to sets of atoms that
bias or constraints that are applied, such as
:doc:`compute temp/partial <compute_temp_partial>`, or
:doc:`fix shake <fix_shake>` or :doc:`fix rigid <fix_rigid>`.
This is because those degrees of
freedom (e.g., a constrained bond) could apply to sets of atoms that
are both included and excluded from a specific chunk, and hence the
concept is somewhat ill-defined. In some cases, you can use the
*adof* and *cdof* keywords to adjust the calculated degrees of freedom
@ -138,16 +159,17 @@ calculating the temperature; fix ave/chunk does not.
.. note::
Only atoms in the specified group contribute to the calculations
performed by this compute. The :doc:`compute chunk/atom <compute_chunk_atom>` command defines its own group;
atoms will have a chunk ID = 0 if they are not in that group,
signifying they are not assigned to a chunk, and will 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.
Only atoms in the specified group contribute to the calculations performed
by this compute. The :doc:`compute chunk/atom <compute_chunk_atom>`
command defines its own group; atoms will have a chunk ID = 0 if they are
not in that group, signifying they are not assigned to a chunk, and will
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.
The simplest way to output the per-chunk results of the compute
temp/chunk calculation to a file is to use the :doc:`fix ave/time <fix_ave_time>` command, for example:
temp/chunk calculation to a file is to use the
:doc:`fix ave/time <fix_ave_time>` command, for example:
.. code-block:: LAMMPS
@ -170,8 +192,8 @@ For the *bias* keyword, *bias-ID* refers to the ID of a temperature
compute that removes a "bias" velocity from each atom. This also
allows calculation of the global or per-chunk temperature using only
the thermal temperature of atoms in each chunk after the translational
kinetic energy components have been altered in a prescribed way,
e.g. to remove a velocity profile. It also applies to the calculation
kinetic energy components have been altered in a prescribed way
(e.g., to remove a velocity profile). It also applies to the calculation
of the other per-chunk values, such as *kecom* or *internal*, which
involve the center-of-mass velocity of each chunk, which is calculated
after the velocity bias is removed from each atom. Note that the
@ -181,12 +203,12 @@ not on a per-chunk basis.
The *adof* and *cdof* keywords define the values used in the degree of
freedom (DOF) formulas used for the global or per-chunk temperature,
as described above. They can be used to calculate a more appropriate
temperature for some kinds of chunks. Here are 3 examples:
temperature for some kinds of chunks. Here are three examples:
If spatially binned chunks contain some number of water molecules and
:doc:`fix shake <fix_shake>` is used to make each molecule rigid, then
you could calculate a temperature with 6 degrees of freedom (DOF) (3
translational, 3 rotational) per molecule by setting *adof* to 2.0.
you could calculate a temperature with six degrees of freedom (DOF) (three
translational, three rotational) per molecule by setting *adof* to 2.0.
If :doc:`compute temp/partial <compute_temp_partial>` is used with the
*bias* keyword to only allow the x component of velocity to contribute
@ -196,8 +218,8 @@ If each chunk consists of a large molecule, with some number of its
bonds constrained by :doc:`fix shake <fix_shake>` or the entire molecule
by :doc:`fix rigid/small <fix_rigid>`, *adof* = 0.0 and *cdof* could be
set to the remaining degrees of freedom for the entire molecule
(entire chunk in this case), e.g. 6 for 3d, or 3 for 2d, for a rigid
molecule.
(entire chunk in this case; i.e., 6 for 3d, or 3 for 2d, for a rigid
molecule).
----------
@ -205,22 +227,23 @@ Output info
"""""""""""
This compute calculates a global scalar (the temperature) and a global
vector of length 6 (KE tensor), which can be accessed by indices 1-6.
vector of length 6 (KE tensor), which can be accessed by indices 1--6.
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.
vector values from a compute as input.
See the :doc:`Howto output <Howto_output>` page for an overview of LAMMPS
output options.
This compute also optionally calculates a global array, if one or more
of the optional values are specified. The number of rows in the array
= the number of chunks *Nchunk* as calculated by the specified
is the number of chunks *Nchunk* as calculated by the specified
:doc:`compute chunk/atom <compute_chunk_atom>` command. The number of
columns is the number of specified values (1 or more). These values
can be accessed by any command that uses global array values from a
compute as input. Again, see the :doc:`Howto output <Howto_output>` doc
page for an overview of LAMMPS output options.
The scalar value calculated by this compute is "intensive". The
vector values are "extensive". The array values are "intensive".
The scalar value calculated by this compute is "intensive." The
vector values are "extensive." The array values are "intensive."
The scalar value will be in temperature :doc:`units <units>`. The
vector values will be in energy :doc:`units <units>`. The array values

49
doc/src/compute_temp_com.rst
View File

@ -6,7 +6,7 @@ compute temp/com command
Syntax
""""""
.. parsed-literal::
.. code-block:: LAMMPS
compute ID group-ID temp/com
@ -29,20 +29,27 @@ atoms, after subtracting out the center-of-mass velocity of the group.
This is useful if the group is expected to have a non-zero net
velocity for some reason. A compute of this style can be used by any
command that computes a temperature,
e.g. :doc:`thermo_modify <thermo_modify>`, :doc:`fix temp/rescale <fix_temp_rescale>`, :doc:`fix npt <fix_nh>`, etc.
(e.g., :doc:`thermo_modify <thermo_modify>`,
:doc:`fix temp/rescale <fix_temp_rescale>`, :doc:`fix npt <fix_nh>`).
After the center-of-mass velocity has been subtracted from each atom,
the temperature is calculated by the formula KE = dim/2 N k T, where
KE = total kinetic energy of the group of atoms (sum of 1/2 m v\^2),
dim = 2 or 3 = dimensionality of the simulation, N = number of atoms
in the group, k = Boltzmann constant, and T = temperature.
the temperature is calculated by the formula
A kinetic energy tensor, stored as a 6-element vector, is also
.. math::
\text{KE} = \frac{\text{dim}}{2} N k T,
where KE is the total kinetic energy of the group of atoms (sum of
:math:`\frac12 m v^2`), dim = 2 or 3 is the dimensionality of the simulation,
:math:`N` is number of atoms in the group, :math:`k` is the Boltzmann constant,
and :math:`T` is the absolute temperature.
A kinetic energy tensor, stored as a six-element vector, is also
calculated by this compute for use in the computation of a pressure
tensor. The formula for the components of the tensor is the same as
the above formula, except that v\^2 is replaced by vx\*vy for the xy
component, etc. The 6 components of the vector are ordered xx, yy,
zz, xy, xz, yz.
the above formula, except that :math:`v^2` is replaced by :math:`v_x v_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`.
The number of atoms contributing to the temperature is assumed to be
constant for the duration of the run; use the *dynamic* option of the
@ -54,13 +61,16 @@ velocity of the atoms. If this compute is used with a fix command
that performs thermostatting then this bias will be subtracted from
each atom, thermostatting of the remaining thermal velocity will be
performed, and the bias will be added back in. Thermostatting fixes
that work in this way include :doc:`fix nvt <fix_nh>`, :doc:`fix temp/rescale <fix_temp_rescale>`, :doc:`fix temp/berendsen <fix_temp_berendsen>`, and :doc:`fix langevin <fix_langevin>`.
that work in this way include :doc:`fix nvt <fix_nh>`,
:doc:`fix temp/rescale <fix_temp_rescale>`,
:doc:`fix temp/berendsen <fix_temp_berendsen>`, and
:doc:`fix langevin <fix_langevin>`.
This compute subtracts out degrees-of-freedom due to fixes that
constrain molecular motion, such as :doc:`fix shake <fix_shake>` and
:doc:`fix rigid <fix_rigid>`. This means the temperature of groups of
atoms that include these constraints will be computed correctly. If
needed, the subtracted degrees-of-freedom can be altered using the
atoms that include these constraints will be computed correctly.
If needed, the subtracted degrees-of-freedom can be altered using the
*extra* option of the :doc:`compute_modify <compute_modify>` command.
See the :doc:`Howto thermostat <Howto_thermostat>` page for a
@ -71,16 +81,17 @@ Output info
"""""""""""
This compute calculates a global scalar (the temperature) and a global
vector of length 6 (KE tensor), which can be accessed by indices 1-6.
vector of length 6 (KE tensor), which can be accessed by indices 1--6.
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 scalar value calculated by this compute is "intensive". The
vector values are "extensive".
The scalar value calculated by this compute is "intensive." The
vector values are "extensive."
The scalar value will be in temperature :doc:`units <units>`. The
vector values will be in energy :doc:`units <units>`.
The scalar value will be in temperature :doc:`units <units>`.
The vector values will be in energy :doc:`units <units>`.
Restrictions
""""""""""""