lijiext
/
lammps
mirror of https://github.com/lammps/lammps.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

git-svn-id: svn://svn.icms.temple.edu/lammps-ro/trunk@15352 f3b2605a-c512-4ea7-a41b-209d697bcdaa

This commit is contained in:
sjplimp 2016-07-22 22:46:14 +00:00
parent 0659a1fc5a
commit 5abac962ed
21 changed files with 357 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
doc/html/_sources/compute_angle_local.txt
View File

@ -8,12 +8,12 @@ Syntax
.. parsed-literal::
compute ID group-ID angle/local input1 input2 ...
compute ID group-ID angle/local value1 value2 ...
* ID, group-ID are documented in :doc:`compute <compute>` command
* angle/local = style name of this compute command
* one or more keywords may be appended
* keyword = *theta* or *eng*
* one or more values may be appended
* value = *theta* or *eng*
.. parsed-literal::
*theta* = tabulate angles
@ -37,6 +37,10 @@ interactions. The number of datums generated, aggregated across all
processors, equals the number of angles in the system, modified by the
group parameter as explained below.
The value *theta* is the angle for the 3 atoms in the interaction.
The value *eng* is the interaction energy for the angle.
The local data stored by this command is generated by looping over all
the atoms owned on a processor and their angles. An angle will only
be included if all 3 atoms in the angle are in the specified compute
@ -55,6 +59,14 @@ For example, angle output from the :doc:`compute property/local <compute_propert
with data from this command and output by the :doc:`dump local <dump>`
command in a consistent way.
Here is an example of how to do this:
.. parsed-literal::
compute 1 all property/local atype aatom1 aatom2 aatom3
compute 2 all angle/local theta eng
dump 1 all local 1000 tmp.dump index c_1[1] c_1[2] c_1[3] c_1[4] c_2[1] c_2[2]
**Output info:**
This compute calculates a local vector or local array depending on the

15
doc/html/_sources/compute_bond_local.txt
View File

@ -8,12 +8,12 @@ Syntax
.. parsed-literal::
compute ID group-ID bond/local input1 input2 ...
compute ID group-ID bond/local value1 value2 ...
* ID, group-ID are documented in :doc:`compute <compute>` command
* bond/local = style name of this compute command
* one or more keywords may be appended
* keyword = *dist* or *eng*
* one or more values may be appended
* value = *dist* or *eng* or *force*
.. parsed-literal::
*dist* = bond distance
@ -38,6 +38,13 @@ interactions. The number of datums generated, aggregated across all
processors, equals the number of bonds in the system, modified
by the group parameter as explained below.
The value *dist* is the length of the bond.
The value *eng* is the interaction energy for the bond.
The value *force* is the force acting between the pair of atoms in the
bond.
The local data stored by this command is generated by looping over all
the atoms owned on a processor and their bonds. A bond will only be
included if both atoms in the bond are in the specified compute group.
@ -60,7 +67,7 @@ Here is an example of how to do this:
.. parsed-literal::
compute 1 all property/local batom1 batom2 btype
compute 1 all property/local btype batom1 batom2
compute 2 all bond/local dist eng
dump 1 all local 1000 tmp.dump index c_1[1] c_1[2] c_1[3] c_2[1] c_2[2]

17
doc/html/_sources/compute_dihedral_local.txt
View File

@ -8,12 +8,12 @@ Syntax
.. parsed-literal::
compute ID group-ID dihedral/local input1 input2 ...
compute ID group-ID dihedral/local value1 value2 ...
* ID, group-ID are documented in :doc:`compute <compute>` command
* dihedral/local = style name of this compute command
* one or more keywords may be appended
* keyword = *phi*
* one or more values may be appended
* value = *phi*
.. parsed-literal::
*phi* = tabulate dihedral angles
@ -35,6 +35,9 @@ interactions. The number of datums generated, aggregated across all
processors, equals the number of angles in the system, modified by the
group parameter as explained below.
The value *phi* is the dihedral angle, as defined in the diagram on
the :doc:`dihedral_style <dihedral_style>` doc page.
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
@ -49,6 +52,14 @@ For example, dihedral output from the :doc:`compute property/local <compute_prop
with data from this command and output by the :doc:`dump local <dump>`
command in a consistent way.
Here is an example of how to do this:
.. parsed-literal::
compute 1 all property/local dtype datom1 datom2 datom3 datom4
compute 2 all dihedral/local phi
dump 1 all local 1000 tmp.dump index c_1[1] c_1[2] c_1[3] c_1[4] c_1[5] c_2[1]
**Output info:**
This compute calculates a local vector or local array depending on the

18
doc/html/_sources/compute_improper_local.txt
View File

@ -8,12 +8,12 @@ Syntax
.. parsed-literal::
compute ID group-ID improper/local input1 input2 ...
compute ID group-ID improper/local value1 value2 ...
* ID, group-ID are documented in :doc:`compute <compute>` command
* improper/local = style name of this compute command
* one or more keywords may be appended
* keyword = *chi*
* one or more values may be appended
* value = *chi*
.. parsed-literal::
*chi* = tabulate improper angles
@ -35,6 +35,10 @@ interactions. The number of datums generated, aggregated across all
processors, equals the number of impropers in the system, modified by
the group parameter as explained below.
The value *chi* is the improper angle, as defined in the doc pages for
the individual improper styles listed on
:doc:`improper_style <improper_style>` doc page.
The local data stored by this command is generated by looping over all
the atoms owned on a processor and their impropers. An improper will
only be included if all 4 atoms in the improper are in the specified
@ -49,6 +53,14 @@ For example, improper output from the :doc:`compute property/local <compute_prop
with data from this command and output by the :doc:`dump local <dump>`
command in a consistent way.
Here is an example of how to do this:
.. parsed-literal::
compute 1 all property/local itype iatom1 iatom2 iatom3 iatom4
compute 2 all improper/local chi
dump 1 all local 1000 tmp.dump index c_1[1] c_1[2] c_1[3] c_1[4] c_1[5] c_2[1]
**Output info:**
This compute calculates a local vector or local array depending on the

54
doc/html/_sources/compute_pair_local.txt
View File

@ -8,12 +8,12 @@ Syntax
.. parsed-literal::
compute ID group-ID pair/local input1 input2 ...
compute ID group-ID pair/local value1 value2 ... keyword args ...
* ID, group-ID are documented in :doc:`compute <compute>` command
* pair/local = style name of this compute command
* zero or more keywords may be appended
* keyword = *dist* or *eng* or *force* or *fx* or *fy* or *fz* or *pN*
* one or more values may be appended
* value = *dist* or *eng* or *force* or *fx* or *fy* or *fz* or *pN*
.. parsed-literal::
*dist* = pairwise distance
@ -22,6 +22,12 @@ Syntax
*fx*\ ,\ *fy*\ ,\ *fz* = components of pairwise force
*pN* = pair style specific quantities for allowed N values
* zero or more keyword/arg pairs may be appended
* keyword = *cutoff*
.. parsed-literal::
*cutoff* arg = *type* or *radius*
Examples
@ -49,13 +55,13 @@ force cutoff distance for that interaction, as defined by the
:doc:`pair_style <pair_style>` and :doc:`pair_coeff <pair_coeff>`
commands.
The output *dist* is the distance bewteen the pair of atoms.
The value *dist* is the distance bewteen the pair of atoms.
The output *eng* is the interaction energy for the pair of atoms.
The value *eng* is the interaction energy for the pair of atoms.
The output *force* is the force acting between the pair of atoms,
which is positive for a repulsive force and negative for an attractive
force. The outputs *fx*\ , *fy*\ , and *fz* are the xyz components of
The value *force* is the force acting between the pair of atoms, which
is positive for a repulsive force and negative for an attractive
force. The values *fx*\ , *fy*\ , and *fz* are the xyz components of
*force* on atom I.
A pair style may define additional pairwise quantities which can be
@ -66,10 +72,18 @@ which calculate the tangential force between two particles and return
its components and magnitude acting on atom I for N = 1,2,3,4. See
individual pair styles for detils.
The output *dist* will be in distance :doc:`units <units>`. The output
*eng* will be in energy :doc:`units <units>`. The outputs *force*\ ,
*fx*\ , *fy*\ , and *fz* will be in force :doc:`units <units>`. The output
*pN* will be in whatever units the pair style defines.
The value *dist* will be in distance :doc:`units <units>`. The value
*eng* will be in energy :doc:`units <units>`. The values *force*\ , *fx*\ ,
*fy*\ , and *fz* will be in force :doc:`units <units>`. The values *pN*
will be in whatever units the pair style defines.
The optional *cutoff* keyword determines how the force cutoff distance
for an interaction is determined. For the default setting of *type*\ ,
the pairwise cutoff defined by the :doc:`pair_style <pair_style>`
command for the types of the two atoms is used. For the *radius*
setting, the sum of the radii of the two particles is used as a
cutoff. For example, this is appropriate for granular particles which
only interact when they are overlapping, as computed by `granular pair styles <pair_gran.txt>`_.
Note that as atoms migrate from processor to processor, there will be
no consistent ordering of the entries within the local vector or array
@ -80,6 +94,14 @@ For example, pair output from the :doc:`compute property/local <compute_property
with data from this command and output by the :doc:`dump local <dump>`
command in a consistent way.
Here is an example of how to do this:
.. parsed-literal::
compute 1 all property/local patom1 patom2
compute 2 all pair/local dist eng force
dump 1 all local 1000 tmp.dump index c_1[1] c_1[2] c_2[1] c_2[2] c_2[3]
.. note::
For pairs, if two atoms I,J are involved in 1-2, 1-3, 1-4
@ -110,7 +132,8 @@ options.
The output for *dist* will be in distance :doc:`units <units>`. The
output for *eng* will be in energy :doc:`units <units>`. The output for
*force* will be in force :doc:`units <units>`.
*force*\ , *fx*\ , *fy*\ , and *fz* will be in force :doc:`units <units>`.
The outpur for *pN* will be in whatever units the pair style defines.
Restrictions
""""""""""""
@ -121,7 +144,10 @@ Related commands
:doc:`dump local <dump>`, :doc:`compute property/local <compute_property_local>`
**Default:** none
Default
"""""""
The keyword default is cutoff = type.
.. _lws: http://lammps.sandia.gov

44
doc/html/_sources/compute_property_local.txt
View File

@ -8,19 +8,19 @@ Syntax
.. parsed-literal::
compute ID group-ID property/local input1 input2 ...
compute ID group-ID property/local attribute1 attribute2 ... keyword args ...
* ID, group-ID are documented in :doc:`compute <compute>` command
* property/local = style name of this compute command
* input = one or more attributes
* one or more attributes may be appended
.. parsed-literal::
possible attributes = natom1 natom2 ntype1 ntype2
patom1 patom2 ptype1 ptype2
batom1 batom2 btype
aatom1 aatom2 aatom3 atype
datom1 datom2 datom3 dtype
iatom1 iatom2 iatom3 itype
possible attributes = natom1 natom2 ntype1 ntype2
patom1 patom2 ptype1 ptype2
batom1 batom2 btype
aatom1 aatom2 aatom3 atype
datom1 datom2 datom3 dtype
iatom1 iatom2 iatom3 itype
.. parsed-literal::
@ -37,6 +37,12 @@ Syntax
iatom1, iatom2, iatom3, iatom4 = IDs of 4 atoms in each improper
itype = improper type of each improper
* zero or more keyword/arg pairs may be appended
* keyword = *cutoff*
.. parsed-literal::
*cutoff* arg = *type* or *radius*
Examples
@ -56,9 +62,9 @@ to bond information, then the number of datums generated, aggregated
across all processors, equals the number of bonds in the system.
Ditto for pairs, angles, etc.
If multiple input attributes are specified then they must all generate
the same amount of information, so that the resulting local array has
the same number of rows for each column. This means that only bond
If multiple attributes are specified then they must all generate the
same amount of information, so that the resulting local array has the
same number of rows for each column. This means that only bond
attributes can be specified together, or angle attributes, etc. Bond
and angle attributes can not be mixed in the same compute
property/local command.
@ -74,6 +80,15 @@ force cutoff distance for that pair to be included, as defined by the
:doc:`pair_style <pair_style>` and :doc:`pair_coeff <pair_coeff>`
commands.
The optional *cutoff* keyword determines how the force cutoff distance
for an interaction is determined for the *patom1* and *patom2*
attributes. For the default setting of *type*\ , the pairwise cutoff
defined by the :doc:`pair_style <pair_style>` command for the types of
the two atoms is used. For the *radius* setting, the sum of the radii
of the two particles is used as a cutoff. For example, this is
appropriate for granular particles which only interact when they are
overlapping, as computed by `granular pair styles <pair_gran.txt>`_.
If the inputs are bond, angle, etc attributes, the local data is
generated by looping over all the atoms owned on a processor and
extracting bond, angle, etc info. For bonds, info about an individual
@ -122,6 +137,8 @@ The attributes that start with "a", "d", "i", refer to similar values
for :doc:`angles <angle_style>`, :doc:`dihedrals <dihedral_style>`, and
:doc:`impropers <improper_style>`.
The optional *cutoff* keyword
**Output info:**
This compute calculates a local vector or local array depending on the
@ -145,7 +162,10 @@ Related commands
:doc:`dump local <dump>`, :doc:`compute reduce <compute_reduce>`
**Default:** none
Default
"""""""
The keyword default is cutoff = type.
.. _lws: http://lammps.sandia.gov

6
doc/html/_sources/compute_sna_atom.txt
View File

@ -14,9 +14,9 @@ Syntax
.. parsed-literal::
compute ID group-ID sna/atom ntypes rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ...
compute ID group-ID snad/atom ntypes rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ...
compute ID group-ID snav/atom ntypes rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ...
compute ID group-ID sna/atom rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ...
compute ID group-ID snad/atom rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ...
compute ID group-ID snav/atom rcutfac rfac0 twojmax R_1 R_2 ... w_1 w_2 ... keyword values ...
* ID, group-ID are documented in :doc:`compute <compute>` command
* sna/atom = style name of this compute command

14
doc/html/compute_angle_local.html
View File

@ -128,14 +128,14 @@
<span id="index-0"></span><h1>compute angle/local command</h1>
<div class="section" id="syntax">
<h2>Syntax</h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">angle</span><span class="o">/</span><span class="n">local</span> <span class="n">input1</span> <span class="n">input2</span> <span class="o">...</span>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">angle</span><span class="o">/</span><span class="n">local</span> <span class="n">value1</span> <span class="n">value2</span> <span class="o">...</span>
</pre></div>
</div>
<ul class="simple">
<li>ID, group-ID are documented in <a class="reference internal" href="compute.html"><span class="doc">compute</span></a> command</li>
<li>angle/local = style name of this compute command</li>
<li>one or more keywords may be appended</li>
<li>keyword = <em>theta</em> or <em>eng</em></li>
<li>one or more values may be appended</li>
<li>value = <em>theta</em> or <em>eng</em></li>
</ul>
<pre class="literal-block">
<em>theta</em> = tabulate angles
@ -155,6 +155,8 @@
interactions. The number of datums generated, aggregated across all
processors, equals the number of angles in the system, modified by the
group parameter as explained below.</p>
<p>The value <em>theta</em> is the angle for the 3 atoms in the interaction.</p>
<p>The value <em>eng</em> is the interaction energy for the angle.</p>
<p>The local data stored by this command is generated by looping over all
the atoms owned on a processor and their angles. An angle will only
be included if all 3 atoms in the angle are in the specified compute
@ -171,6 +173,12 @@ same for local vectors or arrays generated by other compute commands.
For example, angle output from the <a class="reference internal" href="compute_property_local.html"><span class="doc">compute property/local</span></a> command can be combined
with data from this command and output by the <a class="reference internal" href="dump.html"><span class="doc">dump local</span></a>
command in a consistent way.</p>
<p>Here is an example of how to do this:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="mi">1</span> <span class="nb">all</span> <span class="nb">property</span><span class="o">/</span><span class="n">local</span> <span class="n">atype</span> <span class="n">aatom1</span> <span class="n">aatom2</span> <span class="n">aatom3</span>
<span class="n">compute</span> <span class="mi">2</span> <span class="nb">all</span> <span class="n">angle</span><span class="o">/</span><span class="n">local</span> <span class="n">theta</span> <span class="n">eng</span>
<span class="n">dump</span> <span class="mi">1</span> <span class="nb">all</span> <span class="n">local</span> <span class="mi">1000</span> <span class="n">tmp</span><span class="o">.</span><span class="n">dump</span> <span class="n">index</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span> <span class="n">c_2</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="n">c_2</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
</pre></div>
</div>
<p><strong>Output info:</strong></p>
<p>This compute calculates a local vector or local array depending on the
number of keywords. The length of the vector or number of rows in the

12
doc/html/compute_bond_local.html
View File

@ -128,14 +128,14 @@
<span id="index-0"></span><h1>compute bond/local command</h1>
<div class="section" id="syntax">
<h2>Syntax</h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">bond</span><span class="o">/</span><span class="n">local</span> <span class="n">input1</span> <span class="n">input2</span> <span class="o">...</span>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">bond</span><span class="o">/</span><span class="n">local</span> <span class="n">value1</span> <span class="n">value2</span> <span class="o">...</span>
</pre></div>
</div>
<ul class="simple">
<li>ID, group-ID are documented in <a class="reference internal" href="compute.html"><span class="doc">compute</span></a> command</li>
<li>bond/local = style name of this compute command</li>
<li>one or more keywords may be appended</li>
<li>keyword = <em>dist</em> or <em>eng</em></li>
<li>one or more values may be appended</li>
<li>value = <em>dist</em> or <em>eng</em> or <em>force</em></li>
</ul>
<pre class="literal-block">
<em>dist</em> = bond distance
@ -156,6 +156,10 @@
interactions. The number of datums generated, aggregated across all
processors, equals the number of bonds in the system, modified
by the group parameter as explained below.</p>
<p>The value <em>dist</em> is the length of the bond.</p>
<p>The value <em>eng</em> is the interaction energy for the bond.</p>
<p>The value <em>force</em> is the force acting between the pair of atoms in the
bond.</p>
<p>The local data stored by this command is generated by looping over all
the atoms owned on a processor and their bonds. A bond will only be
included if both atoms in the bond are in the specified compute group.
@ -173,7 +177,7 @@ For example, bond output from the <a class="reference internal" href="compute_pr
with data from this command and output by the <a class="reference internal" href="dump.html"><span class="doc">dump local</span></a>
command in a consistent way.</p>
<p>Here is an example of how to do this:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="mi">1</span> <span class="nb">all</span> <span class="nb">property</span><span class="o">/</span><span class="n">local</span> <span class="n">batom1</span> <span class="n">batom2</span> <span class="n">btype</span>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="mi">1</span> <span class="nb">all</span> <span class="nb">property</span><span class="o">/</span><span class="n">local</span> <span class="n">btype</span> <span class="n">batom1</span> <span class="n">batom2</span>
<span class="n">compute</span> <span class="mi">2</span> <span class="nb">all</span> <span class="n">bond</span><span class="o">/</span><span class="n">local</span> <span class="n">dist</span> <span class="n">eng</span>
<span class="n">dump</span> <span class="mi">1</span> <span class="nb">all</span> <span class="n">local</span> <span class="mi">1000</span> <span class="n">tmp</span><span class="o">.</span><span class="n">dump</span> <span class="n">index</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="n">c_2</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="n">c_2</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
</pre></div>

14
doc/html/compute_dihedral_local.html
View File

@ -128,14 +128,14 @@
<span id="index-0"></span><h1>compute dihedral/local command</h1>
<div class="section" id="syntax">
<h2>Syntax</h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">dihedral</span><span class="o">/</span><span class="n">local</span> <span class="n">input1</span> <span class="n">input2</span> <span class="o">...</span>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">dihedral</span><span class="o">/</span><span class="n">local</span> <span class="n">value1</span> <span class="n">value2</span> <span class="o">...</span>
</pre></div>
</div>
<ul class="simple">
<li>ID, group-ID are documented in <a class="reference internal" href="compute.html"><span class="doc">compute</span></a> command</li>
<li>dihedral/local = style name of this compute command</li>
<li>one or more keywords may be appended</li>
<li>keyword = <em>phi</em></li>
<li>one or more values may be appended</li>
<li>value = <em>phi</em></li>
</ul>
<pre class="literal-block">
<em>phi</em> = tabulate dihedral angles
@ -153,6 +153,8 @@
interactions. The number of datums generated, aggregated across all
processors, equals the number of angles in the system, modified by the
group parameter as explained below.</p>
<p>The value <em>phi</em> is the dihedral angle, as defined in the diagram on
the <a class="reference internal" href="dihedral_style.html"><span class="doc">dihedral_style</span></a> doc page.</p>
<p>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
@ -165,6 +167,12 @@ same for local vectors or arrays generated by other compute commands.
For example, dihedral output from the <a class="reference internal" href="compute_property_local.html"><span class="doc">compute property/local</span></a> command can be combined
with data from this command and output by the <a class="reference internal" href="dump.html"><span class="doc">dump local</span></a>
command in a consistent way.</p>
<p>Here is an example of how to do this:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="mi">1</span> <span class="nb">all</span> <span class="nb">property</span><span class="o">/</span><span class="n">local</span> <span class="n">dtype</span> <span class="n">datom1</span> <span class="n">datom2</span> <span class="n">datom3</span> <span class="n">datom4</span>
<span class="n">compute</span> <span class="mi">2</span> <span class="nb">all</span> <span class="n">dihedral</span><span class="o">/</span><span class="n">local</span> <span class="n">phi</span>
<span class="n">dump</span> <span class="mi">1</span> <span class="nb">all</span> <span class="n">local</span> <span class="mi">1000</span> <span class="n">tmp</span><span class="o">.</span><span class="n">dump</span> <span class="n">index</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span> <span class="n">c_2</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
</pre></div>
</div>
<p><strong>Output info:</strong></p>
<p>This compute calculates a local vector or local array depending on the
number of keywords. The length of the vector or number of rows in the

15
doc/html/compute_improper_local.html
View File

@ -128,14 +128,14 @@
<span id="index-0"></span><h1>compute improper/local command</h1>
<div class="section" id="syntax">
<h2>Syntax</h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">improper</span><span class="o">/</span><span class="n">local</span> <span class="n">input1</span> <span class="n">input2</span> <span class="o">...</span>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">improper</span><span class="o">/</span><span class="n">local</span> <span class="n">value1</span> <span class="n">value2</span> <span class="o">...</span>
</pre></div>
</div>
<ul class="simple">
<li>ID, group-ID are documented in <a class="reference internal" href="compute.html"><span class="doc">compute</span></a> command</li>
<li>improper/local = style name of this compute command</li>
<li>one or more keywords may be appended</li>
<li>keyword = <em>chi</em></li>
<li>one or more values may be appended</li>
<li>value = <em>chi</em></li>
</ul>
<pre class="literal-block">
<em>chi</em> = tabulate improper angles
@ -153,6 +153,9 @@
interactions. The number of datums generated, aggregated across all
processors, equals the number of impropers in the system, modified by
the group parameter as explained below.</p>
<p>The value <em>chi</em> is the improper angle, as defined in the doc pages for
the individual improper styles listed on
<a class="reference internal" href="improper_style.html"><span class="doc">improper_style</span></a> doc page.</p>
<p>The local data stored by this command is generated by looping over all
the atoms owned on a processor and their impropers. An improper will
only be included if all 4 atoms in the improper are in the specified
@ -165,6 +168,12 @@ same for local vectors or arrays generated by other compute commands.
For example, improper output from the <a class="reference internal" href="compute_property_local.html"><span class="doc">compute property/local</span></a> command can be combined
with data from this command and output by the <a class="reference internal" href="dump.html"><span class="doc">dump local</span></a>
command in a consistent way.</p>
<p>Here is an example of how to do this:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="mi">1</span> <span class="nb">all</span> <span class="nb">property</span><span class="o">/</span><span class="n">local</span> <span class="n">itype</span> <span class="n">iatom1</span> <span class="n">iatom2</span> <span class="n">iatom3</span> <span class="n">iatom4</span>
<span class="n">compute</span> <span class="mi">2</span> <span class="nb">all</span> <span class="n">improper</span><span class="o">/</span><span class="n">local</span> <span class="n">chi</span>
<span class="n">dump</span> <span class="mi">1</span> <span class="nb">all</span> <span class="n">local</span> <span class="mi">1000</span> <span class="n">tmp</span><span class="o">.</span><span class="n">dump</span> <span class="n">index</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span> <span class="n">c_2</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
</pre></div>
</div>
<p><strong>Output info:</strong></p>
<p>This compute calculates a local vector or local array depending on the
number of keywords. The length of the vector or number of rows in the

52
doc/html/compute_pair_local.html
View File

@ -128,14 +128,14 @@
<span id="index-0"></span><h1>compute pair/local command</h1>
<div class="section" id="syntax">
<h2>Syntax</h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">pair</span><span class="o">/</span><span class="n">local</span> <span class="n">input1</span> <span class="n">input2</span> <span class="o">...</span>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">pair</span><span class="o">/</span><span class="n">local</span> <span class="n">value1</span> <span class="n">value2</span> <span class="o">...</span> <span class="n">keyword</span> <span class="n">args</span> <span class="o">...</span>
</pre></div>
</div>
<ul class="simple">
<li>ID, group-ID are documented in <a class="reference internal" href="compute.html"><span class="doc">compute</span></a> command</li>
<li>pair/local = style name of this compute command</li>
<li>zero or more keywords may be appended</li>
<li>keyword = <em>dist</em> or <em>eng</em> or <em>force</em> or <em>fx</em> or <em>fy</em> or <em>fz</em> or <em>pN</em></li>
<li>one or more values may be appended</li>
<li>value = <em>dist</em> or <em>eng</em> or <em>force</em> or <em>fx</em> or <em>fy</em> or <em>fz</em> or <em>pN</em></li>
</ul>
<pre class="literal-block">
<em>dist</em> = pairwise distance
@ -144,6 +144,13 @@
<em>fx</em>,<em>fy</em>,<em>fz</em> = components of pairwise force
<em>pN</em> = pair style specific quantities for allowed N values
</pre>
<ul class="simple">
<li>zero or more keyword/arg pairs may be appended</li>
<li>keyword = <em>cutoff</em></li>
</ul>
<pre class="literal-block">
<em>cutoff</em> arg = <em>type</em> or <em>radius</em>
</pre>
</div>
<div class="section" id="examples">
<h2>Examples</h2>
@ -166,11 +173,11 @@ compute group, and if the current pairwise distance is less than the
force cutoff distance for that interaction, as defined by the
<a class="reference internal" href="pair_style.html"><span class="doc">pair_style</span></a> and <a class="reference internal" href="pair_coeff.html"><span class="doc">pair_coeff</span></a>
commands.</p>
<p>The output <em>dist</em> is the distance bewteen the pair of atoms.</p>
<p>The output <em>eng</em> is the interaction energy for the pair of atoms.</p>
<p>The output <em>force</em> is the force acting between the pair of atoms,
which is positive for a repulsive force and negative for an attractive
force. The outputs <em>fx</em>, <em>fy</em>, and <em>fz</em> are the xyz components of
<p>The value <em>dist</em> is the distance bewteen the pair of atoms.</p>
<p>The value <em>eng</em> is the interaction energy for the pair of atoms.</p>
<p>The value <em>force</em> is the force acting between the pair of atoms, which
is positive for a repulsive force and negative for an attractive
force. The values <em>fx</em>, <em>fy</em>, and <em>fz</em> are the xyz components of
<em>force</em> on atom I.</p>
<p>A pair style may define additional pairwise quantities which can be
accessed as <em>p1</em> to <em>pN</em>, where N is defined by the pair style. Most
@ -179,10 +186,17 @@ example of ones that do are the <a class="reference internal" href="pair_gran.ht
which calculate the tangential force between two particles and return
its components and magnitude acting on atom I for N = 1,2,3,4. See
individual pair styles for detils.</p>
<p>The output <em>dist</em> will be in distance <a class="reference internal" href="units.html"><span class="doc">units</span></a>. The output
<em>eng</em> will be in energy <a class="reference internal" href="units.html"><span class="doc">units</span></a>. The outputs <em>force</em>,
<em>fx</em>, <em>fy</em>, and <em>fz</em> will be in force <a class="reference internal" href="units.html"><span class="doc">units</span></a>. The output
<em>pN</em> will be in whatever units the pair style defines.</p>
<p>The value <em>dist</em> will be in distance <a class="reference internal" href="units.html"><span class="doc">units</span></a>. The value
<em>eng</em> will be in energy <a class="reference internal" href="units.html"><span class="doc">units</span></a>. The values <em>force</em>, <em>fx</em>,
<em>fy</em>, and <em>fz</em> will be in force <a class="reference internal" href="units.html"><span class="doc">units</span></a>. The values <em>pN</em>
will be in whatever units the pair style defines.</p>
<p>The optional <em>cutoff</em> keyword determines how the force cutoff distance
for an interaction is determined. For the default setting of <em>type</em>,
the pairwise cutoff defined by the <a class="reference internal" href="pair_style.html"><span class="doc">pair_style</span></a>
command for the types of the two atoms is used. For the <em>radius</em>
setting, the sum of the radii of the two particles is used as a
cutoff. For example, this is appropriate for granular particles which
only interact when they are overlapping, as computed by <a class="reference external" href="pair_gran.txt">granular pair styles</a>.</p>
<p>Note that as atoms migrate from processor to processor, there will be
no consistent ordering of the entries within the local vector or array
from one timestep to the next. The only consistency that is
@ -191,6 +205,12 @@ same for local vectors or arrays generated by other compute commands.
For example, pair output from the <a class="reference internal" href="compute_property_local.html"><span class="doc">compute property/local</span></a> command can be combined
with data from this command and output by the <a class="reference internal" href="dump.html"><span class="doc">dump local</span></a>
command in a consistent way.</p>
<p>Here is an example of how to do this:</p>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="mi">1</span> <span class="nb">all</span> <span class="nb">property</span><span class="o">/</span><span class="n">local</span> <span class="n">patom1</span> <span class="n">patom2</span>
<span class="n">compute</span> <span class="mi">2</span> <span class="nb">all</span> <span class="n">pair</span><span class="o">/</span><span class="n">local</span> <span class="n">dist</span> <span class="n">eng</span> <span class="n">force</span>
<span class="n">dump</span> <span class="mi">1</span> <span class="nb">all</span> <span class="n">local</span> <span class="mi">1000</span> <span class="n">tmp</span><span class="o">.</span><span class="n">dump</span> <span class="n">index</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="n">c_1</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="n">c_2</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="n">c_2</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="n">c_2</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span>
</pre></div>
</div>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">For pairs, if two atoms I,J are involved in 1-2, 1-3, 1-4
@ -219,7 +239,8 @@ uses local values from a compute as input. See <a class="reference internal" hr
options.</p>
<p>The output for <em>dist</em> will be in distance <a class="reference internal" href="units.html"><span class="doc">units</span></a>. The
output for <em>eng</em> will be in energy <a class="reference internal" href="units.html"><span class="doc">units</span></a>. The output for
<em>force</em> will be in force <a class="reference internal" href="units.html"><span class="doc">units</span></a>.</p>
<em>force</em>, <em>fx</em>, <em>fy</em>, and <em>fz</em> will be in force <a class="reference internal" href="units.html"><span class="doc">units</span></a>.
The outpur for <em>pN</em> will be in whatever units the pair style defines.</p>
</div>
<div class="section" id="restrictions">
<h2>Restrictions</h2>
@ -229,7 +250,10 @@ output for <em>eng</em> will be in energy <a class="reference internal" href="un
<div class="section" id="related-commands">
<h2>Related commands</h2>
<p><a class="reference internal" href="dump.html"><span class="doc">dump local</span></a>, <a class="reference internal" href="compute_property_local.html"><span class="doc">compute property/local</span></a></p>
<p><strong>Default:</strong> none</p>
</div>
<div class="section" id="default">
<h2>Default</h2>
<p>The keyword default is cutoff = type.</p>
</div>
</div>

43
doc/html/compute_property_local.html
View File

@ -128,20 +128,20 @@
<span id="index-0"></span><h1>compute property/local command</h1>
<div class="section" id="syntax">
<h2>Syntax</h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="nb">property</span><span class="o">/</span><span class="n">local</span> <span class="n">input1</span> <span class="n">input2</span> <span class="o">...</span>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="nb">property</span><span class="o">/</span><span class="n">local</span> <span class="n">attribute1</span> <span class="n">attribute2</span> <span class="o">...</span> <span class="n">keyword</span> <span class="n">args</span> <span class="o">...</span>
</pre></div>
</div>
<ul class="simple">
<li>ID, group-ID are documented in <a class="reference internal" href="compute.html"><span class="doc">compute</span></a> command</li>
<li>property/local = style name of this compute command</li>
<li>input = one or more attributes</li>
<li>one or more attributes may be appended</li>
</ul>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">possible</span> <span class="n">attributes</span> <span class="o">=</span> <span class="n">natom1</span> <span class="n">natom2</span> <span class="n">ntype1</span> <span class="n">ntype2</span>
<span class="n">patom1</span> <span class="n">patom2</span> <span class="n">ptype1</span> <span class="n">ptype2</span>
<span class="n">batom1</span> <span class="n">batom2</span> <span class="n">btype</span>
<span class="n">aatom1</span> <span class="n">aatom2</span> <span class="n">aatom3</span> <span class="n">atype</span>
<span class="n">datom1</span> <span class="n">datom2</span> <span class="n">datom3</span> <span class="n">dtype</span>
<span class="n">iatom1</span> <span class="n">iatom2</span> <span class="n">iatom3</span> <span class="n">itype</span>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">possible</span> <span class="n">attributes</span> <span class="o">=</span> <span class="n">natom1</span> <span class="n">natom2</span> <span class="n">ntype1</span> <span class="n">ntype2</span>
<span class="n">patom1</span> <span class="n">patom2</span> <span class="n">ptype1</span> <span class="n">ptype2</span>
<span class="n">batom1</span> <span class="n">batom2</span> <span class="n">btype</span>
<span class="n">aatom1</span> <span class="n">aatom2</span> <span class="n">aatom3</span> <span class="n">atype</span>
<span class="n">datom1</span> <span class="n">datom2</span> <span class="n">datom3</span> <span class="n">dtype</span>
<span class="n">iatom1</span> <span class="n">iatom2</span> <span class="n">iatom3</span> <span class="n">itype</span>
</pre></div>
</div>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">natom1</span><span class="p">,</span> <span class="n">natom2</span> <span class="o">=</span> <span class="n">IDs</span> <span class="n">of</span> <span class="mi">2</span> <span class="n">atoms</span> <span class="ow">in</span> <span class="n">each</span> <span class="n">pair</span> <span class="p">(</span><span class="n">within</span> <span class="n">neighbor</span> <span class="n">cutoff</span><span class="p">)</span>
@ -158,6 +158,13 @@
<span class="n">itype</span> <span class="o">=</span> <span class="n">improper</span> <span class="nb">type</span> <span class="n">of</span> <span class="n">each</span> <span class="n">improper</span>
</pre></div>
</div>
<ul class="simple">
<li>zero or more keyword/arg pairs may be appended</li>
<li>keyword = <em>cutoff</em></li>
</ul>
<pre class="literal-block">
<em>cutoff</em> arg = <em>type</em> or <em>radius</em>
</pre>
</div>
<div class="section" id="examples">
<h2>Examples</h2>
@ -173,9 +180,9 @@ data so it can be accessed by other <a class="reference internal" href="Section_
to bond information, then the number of datums generated, aggregated
across all processors, equals the number of bonds in the system.
Ditto for pairs, angles, etc.</p>
<p>If multiple input attributes are specified then they must all generate
the same amount of information, so that the resulting local array has
the same number of rows for each column. This means that only bond
<p>If multiple attributes are specified then they must all generate the
same amount of information, so that the resulting local array has the
same number of rows for each column. This means that only bond
attributes can be specified together, or angle attributes, etc. Bond
and angle attributes can not be mixed in the same compute
property/local command.</p>
@ -189,6 +196,14 @@ and <em>patom2</em>, the distance between the atoms must be less than the
force cutoff distance for that pair to be included, as defined by the
<a class="reference internal" href="pair_style.html"><span class="doc">pair_style</span></a> and <a class="reference internal" href="pair_coeff.html"><span class="doc">pair_coeff</span></a>
commands.</p>
<p>The optional <em>cutoff</em> keyword determines how the force cutoff distance
for an interaction is determined for the <em>patom1</em> and <em>patom2</em>
attributes. For the default setting of <em>type</em>, the pairwise cutoff
defined by the <a class="reference internal" href="pair_style.html"><span class="doc">pair_style</span></a> command for the types of
the two atoms is used. For the <em>radius</em> setting, the sum of the radii
of the two particles is used as a cutoff. For example, this is
appropriate for granular particles which only interact when they are
overlapping, as computed by <a class="reference external" href="pair_gran.txt">granular pair styles</a>.</p>
<p>If the inputs are bond, angle, etc attributes, the local data is
generated by looping over all the atoms owned on a processor and
extracting bond, angle, etc info. For bonds, info about an individual
@ -231,6 +246,7 @@ of bond types is defined in the data file read by the
<p>The attributes that start with &#8220;a&#8221;, &#8220;d&#8221;, &#8220;i&#8221;, refer to similar values
for <a class="reference internal" href="angle_style.html"><span class="doc">angles</span></a>, <a class="reference internal" href="dihedral_style.html"><span class="doc">dihedrals</span></a>, and
<a class="reference internal" href="improper_style.html"><span class="doc">impropers</span></a>.</p>
<p>The optional <em>cutoff</em> keyword</p>
<p><strong>Output info:</strong></p>
<p>This compute calculates a local vector or local array depending on the
number of input values. The length of the vector or number of rows in
@ -251,7 +267,10 @@ specified attribute.</p>
<div class="section" id="related-commands">
<h2>Related commands</h2>
<p><a class="reference internal" href="dump.html"><span class="doc">dump local</span></a>, <a class="reference internal" href="compute_reduce.html"><span class="doc">compute reduce</span></a></p>
<p><strong>Default:</strong> none</p>
</div>
<div class="section" id="default">
<h2>Default</h2>
<p>The keyword default is cutoff = type.</p>
</div>
</div>

6
doc/html/compute_sna_atom.html
View File

@ -134,9 +134,9 @@
<h1>compute snav/atom command</h1>
<div class="section" id="syntax">
<h2>Syntax</h2>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">sna</span><span class="o">/</span><span class="n">atom</span> <span class="n">ntypes</span> <span class="n">rcutfac</span> <span class="n">rfac0</span> <span class="n">twojmax</span> <span class="n">R_1</span> <span class="n">R_2</span> <span class="o">...</span> <span class="n">w_1</span> <span class="n">w_2</span> <span class="o">...</span> <span class="n">keyword</span> <span class="n">values</span> <span class="o">...</span>
<span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">snad</span><span class="o">/</span><span class="n">atom</span> <span class="n">ntypes</span> <span class="n">rcutfac</span> <span class="n">rfac0</span> <span class="n">twojmax</span> <span class="n">R_1</span> <span class="n">R_2</span> <span class="o">...</span> <span class="n">w_1</span> <span class="n">w_2</span> <span class="o">...</span> <span class="n">keyword</span> <span class="n">values</span> <span class="o">...</span>
<span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">snav</span><span class="o">/</span><span class="n">atom</span> <span class="n">ntypes</span> <span class="n">rcutfac</span> <span class="n">rfac0</span> <span class="n">twojmax</span> <span class="n">R_1</span> <span class="n">R_2</span> <span class="o">...</span> <span class="n">w_1</span> <span class="n">w_2</span> <span class="o">...</span> <span class="n">keyword</span> <span class="n">values</span> <span class="o">...</span>
<div class="highlight-default"><div class="highlight"><pre><span></span><span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">sna</span><span class="o">/</span><span class="n">atom</span> <span class="n">rcutfac</span> <span class="n">rfac0</span> <span class="n">twojmax</span> <span class="n">R_1</span> <span class="n">R_2</span> <span class="o">...</span> <span class="n">w_1</span> <span class="n">w_2</span> <span class="o">...</span> <span class="n">keyword</span> <span class="n">values</span> <span class="o">...</span>
<span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">snad</span><span class="o">/</span><span class="n">atom</span> <span class="n">rcutfac</span> <span class="n">rfac0</span> <span class="n">twojmax</span> <span class="n">R_1</span> <span class="n">R_2</span> <span class="o">...</span> <span class="n">w_1</span> <span class="n">w_2</span> <span class="o">...</span> <span class="n">keyword</span> <span class="n">values</span> <span class="o">...</span>
<span class="n">compute</span> <span class="n">ID</span> <span class="n">group</span><span class="o">-</span><span class="n">ID</span> <span class="n">snav</span><span class="o">/</span><span class="n">atom</span> <span class="n">rcutfac</span> <span class="n">rfac0</span> <span class="n">twojmax</span> <span class="n">R_1</span> <span class="n">R_2</span> <span class="o">...</span> <span class="n">w_1</span> <span class="n">w_2</span> <span class="o">...</span> <span class="n">keyword</span> <span class="n">values</span> <span class="o">...</span>
</pre></div>
</div>
<ul class="simple">

2
doc/html/searchindex.js
View File

File diff suppressed because one or more lines are too long

16
doc/src/compute_angle_local.txt
View File

@ -10,12 +10,12 @@ compute angle/local command :h3
[Syntax:]
compute ID group-ID angle/local input1 input2 ... :pre
compute ID group-ID angle/local value1 value2 ... :pre
ID, group-ID are documented in "compute"_compute.html command :ulb,l
angle/local = style name of this compute command :l
one or more keywords may be appended :l
keyword = {theta} or {eng} :l
one or more values may be appended :l
value = {theta} or {eng} :l
{theta} = tabulate angles
{eng} = tabulate angle energies :pre
:ule
@ -32,6 +32,10 @@ interactions. The number of datums generated, aggregated across all
processors, equals the number of angles in the system, modified by the
group parameter as explained below.
The value {theta} is the angle for the 3 atoms in the interaction.
The value {eng} is the interaction energy for the angle.
The local data stored by this command is generated by looping over all
the atoms owned on a processor and their angles. An angle will only
be included if all 3 atoms in the angle are in the specified compute
@ -52,6 +56,12 @@ property/local"_compute_property_local.html command can be combined
with data from this command and output by the "dump local"_dump.html
command in a consistent way.
Here is an example of how to do this:
compute 1 all property/local atype aatom1 aatom2 aatom3
compute 2 all angle/local theta eng
dump 1 all local 1000 tmp.dump index c_1\[1\] c_1\[2\] c_1\[3\] c_1\[4\] c_2\[1\] c_2\[2\] :pre
[Output info:]
This compute calculates a local vector or local array depending on the

15
doc/src/compute_bond_local.txt
View File

@ -10,12 +10,12 @@ compute bond/local command :h3
[Syntax:]
compute ID group-ID bond/local input1 input2 ... :pre
compute ID group-ID bond/local value1 value2 ... :pre
ID, group-ID are documented in "compute"_compute.html command :ulb,l
bond/local = style name of this compute command :l
one or more keywords may be appended :l
keyword = {dist} or {eng} :l
one or more values may be appended :l
value = {dist} or {eng} or {force} :l
{dist} = bond distance
{eng} = bond energy
{force} = bond force :pre
@ -33,6 +33,13 @@ interactions. The number of datums generated, aggregated across all
processors, equals the number of bonds in the system, modified
by the group parameter as explained below.
The value {dist} is the length of the bond.
The value {eng} is the interaction energy for the bond.
The value {force} is the force acting between the pair of atoms in the
bond.
The local data stored by this command is generated by looping over all
the atoms owned on a processor and their bonds. A bond will only be
included if both atoms in the bond are in the specified compute group.
@ -54,7 +61,7 @@ command in a consistent way.
Here is an example of how to do this:
compute 1 all property/local batom1 batom2 btype
compute 1 all property/local btype batom1 batom2
compute 2 all bond/local dist eng
dump 1 all local 1000 tmp.dump index c_1\[1\] c_1\[2\] c_1\[3\] c_2\[1\] c_2\[2\] :pre

15
doc/src/compute_dihedral_local.txt
View File

@ -10,12 +10,12 @@ compute dihedral/local command :h3
[Syntax:]
compute ID group-ID dihedral/local input1 input2 ... :pre
compute ID group-ID dihedral/local value1 value2 ... :pre
ID, group-ID are documented in "compute"_compute.html command :ulb,l
dihedral/local = style name of this compute command :l
one or more keywords may be appended :l
keyword = {phi} :l
one or more values may be appended :l
value = {phi} :l
{phi} = tabulate dihedral angles :pre
:ule
@ -30,6 +30,9 @@ interactions. The number of datums generated, aggregated across all
processors, equals the number of angles in the system, modified by the
group parameter as explained below.
The value {phi} is the dihedral angle, as defined in the diagram on
the "dihedral_style"_dihedral_style.html doc page.
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
@ -45,6 +48,12 @@ property/local"_compute_property_local.html command can be combined
with data from this command and output by the "dump local"_dump.html
command in a consistent way.
Here is an example of how to do this:
compute 1 all property/local dtype datom1 datom2 datom3 datom4
compute 2 all dihedral/local phi
dump 1 all local 1000 tmp.dump index c_1\[1\] c_1\[2\] c_1\[3\] c_1\[4\] c_1\[5\] c_2\[1\] :pre
[Output info:]
This compute calculates a local vector or local array depending on the

16
doc/src/compute_improper_local.txt
View File

@ -10,12 +10,12 @@ compute improper/local command :h3
[Syntax:]
compute ID group-ID improper/local input1 input2 ... :pre
compute ID group-ID improper/local value1 value2 ... :pre
ID, group-ID are documented in "compute"_compute.html command :ulb,l
improper/local = style name of this compute command :l
one or more keywords may be appended :l
keyword = {chi} :l
one or more values may be appended :l
value = {chi} :l
{chi} = tabulate improper angles :pre
:ule
@ -30,6 +30,10 @@ interactions. The number of datums generated, aggregated across all
processors, equals the number of impropers in the system, modified by
the group parameter as explained below.
The value {chi} is the improper angle, as defined in the doc pages for
the individual improper styles listed on
"improper_style"_improper_style.html doc page.
The local data stored by this command is generated by looping over all
the atoms owned on a processor and their impropers. An improper will
only be included if all 4 atoms in the improper are in the specified
@ -45,6 +49,12 @@ property/local"_compute_property_local.html command can be combined
with data from this command and output by the "dump local"_dump.html
command in a consistent way.
Here is an example of how to do this:
compute 1 all property/local itype iatom1 iatom2 iatom3 iatom4
compute 2 all improper/local chi
dump 1 all local 1000 tmp.dump index c_1\[1\] c_1\[2\] c_1\[3\] c_1\[4\] c_1\[5\] c_2\[1\] :pre
[Output info:]
This compute calculates a local vector or local array depending on the

49
doc/src/compute_pair_local.txt
View File

@ -10,17 +10,20 @@ compute pair/local command :h3
[Syntax:]
compute ID group-ID pair/local input1 input2 ... :pre
compute ID group-ID pair/local value1 value2 ... keyword args ... :pre
ID, group-ID are documented in "compute"_compute.html command :ulb,l
pair/local = style name of this compute command :l
zero or more keywords may be appended :l
keyword = {dist} or {eng} or {force} or {fx} or {fy} or {fz} or {pN} :l
one or more values may be appended :l
value = {dist} or {eng} or {force} or {fx} or {fy} or {fz} or {pN} :l
{dist} = pairwise distance
{eng} = pairwise energy
{force} = pairwise force
{fx},{fy},{fz} = components of pairwise force
{pN} = pair style specific quantities for allowed N values :pre
zero or more keyword/arg pairs may be appended :l
keyword = {cutoff} :l
{cutoff} arg = {type} or {radius} :pre
:ule
[Examples:]
@ -44,13 +47,13 @@ force cutoff distance for that interaction, as defined by the
"pair_style"_pair_style.html and "pair_coeff"_pair_coeff.html
commands.
The output {dist} is the distance bewteen the pair of atoms.
The value {dist} is the distance bewteen the pair of atoms.
The output {eng} is the interaction energy for the pair of atoms.
The value {eng} is the interaction energy for the pair of atoms.
The output {force} is the force acting between the pair of atoms,
which is positive for a repulsive force and negative for an attractive
force. The outputs {fx}, {fy}, and {fz} are the xyz components of
The value {force} is the force acting between the pair of atoms, which
is positive for a repulsive force and negative for an attractive
force. The values {fx}, {fy}, and {fz} are the xyz components of
{force} on atom I.
A pair style may define additional pairwise quantities which can be
@ -61,10 +64,19 @@ which calculate the tangential force between two particles and return
its components and magnitude acting on atom I for N = 1,2,3,4. See
individual pair styles for detils.
The output {dist} will be in distance "units"_units.html. The output
{eng} will be in energy "units"_units.html. The outputs {force},
{fx}, {fy}, and {fz} will be in force "units"_units.html. The output
{pN} will be in whatever units the pair style defines.
The value {dist} will be in distance "units"_units.html. The value
{eng} will be in energy "units"_units.html. The values {force}, {fx},
{fy}, and {fz} will be in force "units"_units.html. The values {pN}
will be in whatever units the pair style defines.
The optional {cutoff} keyword determines how the force cutoff distance
for an interaction is determined. For the default setting of {type},
the pairwise cutoff defined by the "pair_style"_pair_style.html
command for the types of the two atoms is used. For the {radius}
setting, the sum of the radii of the two particles is used as a
cutoff. For example, this is appropriate for granular particles which
only interact when they are overlapping, as computed by "granular pair
styles"_pair_gran.txt.
Note that as atoms migrate from processor to processor, there will be
no consistent ordering of the entries within the local vector or array
@ -76,6 +88,12 @@ property/local"_compute_property_local.html command can be combined
with data from this command and output by the "dump local"_dump.html
command in a consistent way.
Here is an example of how to do this:
compute 1 all property/local patom1 patom2
compute 2 all pair/local dist eng force
dump 1 all local 1000 tmp.dump index c_1\[1\] c_1\[2\] c_2\[1\] c_2\[2\] c_2\[3\] :pre
NOTE: For pairs, if two atoms I,J are involved in 1-2, 1-3, 1-4
interactions within the molecular topology, their pairwise interaction
may be turned off, and thus they may not appear in the neighbor list,
@ -105,7 +123,8 @@ options.
The output for {dist} will be in distance "units"_units.html. The
output for {eng} will be in energy "units"_units.html. The output for
{force} will be in force "units"_units.html.
{force}, {fx}, {fy}, and {fz} will be in force "units"_units.html.
The outpur for {pN} will be in whatever units the pair style defines.
[Restrictions:] none
@ -114,4 +133,6 @@ output for {eng} will be in energy "units"_units.html. The output for
"dump local"_dump.html, "compute
property/local"_compute_property_local.html
[Default:] none
[Default:]
The keyword default is cutoff = type.

40
doc/src/compute_property_local.txt
View File

@ -10,17 +10,17 @@ compute property/local command :h3
[Syntax:]
compute ID group-ID property/local input1 input2 ... :pre
compute ID group-ID property/local attribute1 attribute2 ... keyword args ... :pre
ID, group-ID are documented in "compute"_compute.html command :ulb,l
property/local = style name of this compute command :l
input = one or more attributes :l
possible attributes = natom1 natom2 ntype1 ntype2
patom1 patom2 ptype1 ptype2
batom1 batom2 btype
aatom1 aatom2 aatom3 atype
datom1 datom2 datom3 dtype
iatom1 iatom2 iatom3 itype :pre
one or more attributes may be appended :l
possible attributes = natom1 natom2 ntype1 ntype2
patom1 patom2 ptype1 ptype2
batom1 batom2 btype
aatom1 aatom2 aatom3 atype
datom1 datom2 datom3 dtype
iatom1 iatom2 iatom3 itype :pre
natom1, natom2 = IDs of 2 atoms in each pair (within neighbor cutoff)
ntype1, ntype2 = type of 2 atoms in each pair (within neighbor cutoff)
@ -34,6 +34,9 @@ input = one or more attributes :l
dtype = dihedral type of each dihedral
iatom1, iatom2, iatom3, iatom4 = IDs of 4 atoms in each improper
itype = improper type of each improper :pre
zero or more keyword/arg pairs may be appended :l
keyword = {cutoff} :l
{cutoff} arg = {type} or {radius} :pre
:ule
[Examples:]
@ -50,9 +53,9 @@ to bond information, then the number of datums generated, aggregated
across all processors, equals the number of bonds in the system.
Ditto for pairs, angles, etc.
If multiple input attributes are specified then they must all generate
the same amount of information, so that the resulting local array has
the same number of rows for each column. This means that only bond
If multiple attributes are specified then they must all generate the
same amount of information, so that the resulting local array has the
same number of rows for each column. This means that only bond
attributes can be specified together, or angle attributes, etc. Bond
and angle attributes can not be mixed in the same compute
property/local command.
@ -68,6 +71,15 @@ force cutoff distance for that pair to be included, as defined by the
"pair_style"_pair_style.html and "pair_coeff"_pair_coeff.html
commands.
The optional {cutoff} keyword determines how the force cutoff distance
for an interaction is determined for the {patom1} and {patom2}
attributes. For the default setting of {type}, the pairwise cutoff
defined by the "pair_style"_pair_style.html command for the types of
the two atoms is used. For the {radius} setting, the sum of the radii
of the two particles is used as a cutoff. For example, this is
appropriate for granular particles which only interact when they are
overlapping, as computed by "granular pair styles"_pair_gran.txt.
If the inputs are bond, angle, etc attributes, the local data is
generated by looping over all the atoms owned on a processor and
extracting bond, angle, etc info. For bonds, info about an individual
@ -117,6 +129,8 @@ The attributes that start with "a", "d", "i", refer to similar values
for "angles"_angle_style.html, "dihedrals"_dihedral_style.html, and
"impropers"_improper_style.html.
The optional {cutoff} keyword
[Output info:]
This compute calculates a local vector or local array depending on the
@ -138,4 +152,6 @@ specified attribute.
"dump local"_dump.html, "compute reduce"_compute_reduce.html
[Default:] none
[Default:]
The keyword default is cutoff = type.