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:: .. 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 * ID, group-ID are documented in :doc:`compute <compute>` command
* angle/local = style name of this compute command * angle/local = style name of this compute command
* one or more keywords may be appended * one or more values may be appended
* keyword = *theta* or *eng* * value = *theta* or *eng*
.. parsed-literal:: .. parsed-literal::
*theta* = tabulate angles *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 processors, equals the number of angles in the system, modified by the
group parameter as explained below. 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 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 the atoms owned on a processor and their angles. An angle will only
be included if all 3 atoms in the angle are in the specified compute be included if all 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>` with data from this command and output by the :doc:`dump local <dump>`
command in a consistent way. 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:** **Output info:**
This compute calculates a local vector or local array depending on the 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:: .. 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 * ID, group-ID are documented in :doc:`compute <compute>` command
* bond/local = style name of this compute command * bond/local = style name of this compute command
* one or more keywords may be appended * one or more values may be appended
* keyword = *dist* or *eng* * value = *dist* or *eng* or *force*
.. parsed-literal:: .. parsed-literal::
*dist* = bond distance *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 processors, equals the number of bonds in the system, modified
by the group parameter as explained below. 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 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 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. 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:: .. 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 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] 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:: .. 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 * ID, group-ID are documented in :doc:`compute <compute>` command
* dihedral/local = style name of this compute command * dihedral/local = style name of this compute command
* one or more keywords may be appended * one or more values may be appended
* keyword = *phi* * value = *phi*
.. parsed-literal:: .. parsed-literal::
*phi* = tabulate dihedral angles *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 processors, equals the number of angles in the system, modified by the
group parameter as explained below. 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 local data stored by this command is generated by looping over all
the atoms owned on a processor and their dihedrals. A dihedral will the atoms owned on a processor and their dihedrals. A dihedral will
only be included if all 4 atoms in the dihedral are in the specified only be included if all 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>` with data from this command and output by the :doc:`dump local <dump>`
command in a consistent way. 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:** **Output info:**
This compute calculates a local vector or local array depending on the 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:: .. 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 * ID, group-ID are documented in :doc:`compute <compute>` command
* improper/local = style name of this compute command * improper/local = style name of this compute command
* one or more keywords may be appended * one or more values may be appended
* keyword = *chi* * value = *chi*
.. parsed-literal:: .. parsed-literal::
*chi* = tabulate improper angles *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 processors, equals the number of impropers in the system, modified by
the group parameter as explained below. 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 local data stored by this command is generated by looping over all
the atoms owned on a processor and their impropers. An improper will the atoms owned on a processor and their impropers. An improper will
only be included if all 4 atoms in the improper are in the specified only be included if all 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>` with data from this command and output by the :doc:`dump local <dump>`
command in a consistent way. 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:** **Output info:**
This compute calculates a local vector or local array depending on the 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:: .. 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 * ID, group-ID are documented in :doc:`compute <compute>` command
* pair/local = style name of this compute command * pair/local = style name of this compute command
* zero or more keywords may be appended * one or more values may be appended
* keyword = *dist* or *eng* or *force* or *fx* or *fy* or *fz* or *pN* * value = *dist* or *eng* or *force* or *fx* or *fy* or *fz* or *pN*
.. parsed-literal:: .. parsed-literal::
*dist* = pairwise distance *dist* = pairwise distance
@ -22,6 +22,12 @@ Syntax
*fx*\ ,\ *fy*\ ,\ *fz* = components of pairwise force *fx*\ ,\ *fy*\ ,\ *fz* = components of pairwise force
*pN* = pair style specific quantities for allowed N values *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 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>` :doc:`pair_style <pair_style>` and :doc:`pair_coeff <pair_coeff>`
commands. 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, The value *force* is the force acting between the pair of atoms, which
which is positive for a repulsive force and negative for an attractive is positive for a repulsive force and negative for an attractive
force. The outputs *fx*\ , *fy*\ , and *fz* are the xyz components of force. The values *fx*\ , *fy*\ , and *fz* are the xyz components of
*force* on atom I. *force* on atom I.
A pair style may define additional pairwise quantities which can be 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 its components and magnitude acting on atom I for N = 1,2,3,4. See
individual pair styles for detils. individual pair styles for detils.
The output *dist* will be in distance :doc:`units <units>`. The output The value *dist* will be in distance :doc:`units <units>`. The value
*eng* will be in energy :doc:`units <units>`. The outputs *force*\ , *eng* will be in energy :doc:`units <units>`. The values *force*\ , *fx*\ ,
*fx*\ , *fy*\ , and *fz* will be in force :doc:`units <units>`. The output *fy*\ , and *fz* will be in force :doc:`units <units>`. The values *pN*
*pN* will be in whatever units the pair style defines. 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 Note that as atoms migrate from processor to processor, there will be
no consistent ordering of the entries within the local vector or array 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>` with data from this command and output by the :doc:`dump local <dump>`
command in a consistent way. 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:: .. note::
For pairs, if two atoms I,J are involved in 1-2, 1-3, 1-4 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 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 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 Restrictions
"""""""""""" """"""""""""
@ -121,7 +144,10 @@ Related commands
:doc:`dump local <dump>`, :doc:`compute property/local <compute_property_local>` :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 .. _lws: http://lammps.sandia.gov

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

@ -8,19 +8,19 @@ Syntax
.. parsed-literal:: .. 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 * ID, group-ID are documented in :doc:`compute <compute>` command
* property/local = style name of this compute command * property/local = style name of this compute command
* input = one or more attributes * one or more attributes may be appended
.. parsed-literal:: .. parsed-literal::
possible attributes = natom1 natom2 ntype1 ntype2 possible attributes = natom1 natom2 ntype1 ntype2
patom1 patom2 ptype1 ptype2 patom1 patom2 ptype1 ptype2
batom1 batom2 btype batom1 batom2 btype
aatom1 aatom2 aatom3 atype aatom1 aatom2 aatom3 atype
datom1 datom2 datom3 dtype datom1 datom2 datom3 dtype
iatom1 iatom2 iatom3 itype iatom1 iatom2 iatom3 itype
.. parsed-literal:: .. parsed-literal::
@ -37,6 +37,12 @@ Syntax
iatom1, iatom2, iatom3, iatom4 = IDs of 4 atoms in each improper iatom1, iatom2, iatom3, iatom4 = IDs of 4 atoms in each improper
itype = improper type of 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 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. across all processors, equals the number of bonds in the system.
Ditto for pairs, angles, etc. Ditto for pairs, angles, etc.
If multiple input attributes are specified then they must all generate If multiple attributes are specified then they must all generate the
the same amount of information, so that the resulting local array has same amount of information, so that the resulting local array has the
the same number of rows for each column. This means that only bond same number of rows for each column. This means that only bond
attributes can be specified together, or angle attributes, etc. Bond attributes can be specified together, or angle attributes, etc. Bond
and angle attributes can not be mixed in the same compute and angle attributes can not be mixed in the same compute
property/local command. 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>` :doc:`pair_style <pair_style>` and :doc:`pair_coeff <pair_coeff>`
commands. 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 If the inputs are bond, angle, etc attributes, the local data is
generated by looping over all the atoms owned on a processor and generated by looping over all the atoms owned on a processor and
extracting bond, angle, etc info. For bonds, info about an individual 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 for :doc:`angles <angle_style>`, :doc:`dihedrals <dihedral_style>`, and
:doc:`impropers <improper_style>`. :doc:`impropers <improper_style>`.
The optional *cutoff* keyword
**Output info:** **Output info:**
This compute calculates a local vector or local array depending on the 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>` :doc:`dump local <dump>`, :doc:`compute reduce <compute_reduce>`
**Default:** none Default
"""""""
The keyword default is cutoff = type.
.. _lws: http://lammps.sandia.gov .. _lws: http://lammps.sandia.gov

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

@ -14,9 +14,9 @@ Syntax
.. parsed-literal:: .. 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 sna/atom 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 snad/atom 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 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 * ID, group-ID are documented in :doc:`compute <compute>` command
* sna/atom = style name of this 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> <span id="index-0"></span><h1>compute angle/local command</h1>
<div class="section" id="syntax"> <div class="section" id="syntax">
<h2>Syntax</h2> <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> </pre></div>
</div> </div>
<ul class="simple"> <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>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>angle/local = style name of this compute command</li>
<li>one or more keywords may be appended</li> <li>one or more values may be appended</li>
<li>keyword = <em>theta</em> or <em>eng</em></li> <li>value = <em>theta</em> or <em>eng</em></li>
</ul> </ul>
<pre class="literal-block"> <pre class="literal-block">
<em>theta</em> = tabulate angles <em>theta</em> = tabulate angles
@ -155,6 +155,8 @@
interactions. The number of datums generated, aggregated across all interactions. The number of datums generated, aggregated across all
processors, equals the number of angles in the system, modified by the processors, equals the number of angles in the system, modified by the
group parameter as explained below.</p> 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 <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 the atoms owned on a processor and their angles. An angle will only
be included if all 3 atoms in the angle are in the specified compute be included if all 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 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> 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> 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><strong>Output info:</strong></p>
<p>This compute calculates a local vector or local array depending on the <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 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> <span id="index-0"></span><h1>compute bond/local command</h1>
<div class="section" id="syntax"> <div class="section" id="syntax">
<h2>Syntax</h2> <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> </pre></div>
</div> </div>
<ul class="simple"> <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>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>bond/local = style name of this compute command</li>
<li>one or more keywords may be appended</li> <li>one or more values may be appended</li>
<li>keyword = <em>dist</em> or <em>eng</em></li> <li>value = <em>dist</em> or <em>eng</em> or <em>force</em></li>
</ul> </ul>
<pre class="literal-block"> <pre class="literal-block">
<em>dist</em> = bond distance <em>dist</em> = bond distance
@ -156,6 +156,10 @@
interactions. The number of datums generated, aggregated across all interactions. The number of datums generated, aggregated across all
processors, equals the number of bonds in the system, modified processors, equals the number of bonds in the system, modified
by the group parameter as explained below.</p> 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 <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 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. 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> 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> command in a consistent way.</p>
<p>Here is an example of how to do this:</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">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> <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> </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> <span id="index-0"></span><h1>compute dihedral/local command</h1>
<div class="section" id="syntax"> <div class="section" id="syntax">
<h2>Syntax</h2> <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> </pre></div>
</div> </div>
<ul class="simple"> <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>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>dihedral/local = style name of this compute command</li>
<li>one or more keywords may be appended</li> <li>one or more values may be appended</li>
<li>keyword = <em>phi</em></li> <li>value = <em>phi</em></li>
</ul> </ul>
<pre class="literal-block"> <pre class="literal-block">
<em>phi</em> = tabulate dihedral angles <em>phi</em> = tabulate dihedral angles
@ -153,6 +153,8 @@
interactions. The number of datums generated, aggregated across all interactions. The number of datums generated, aggregated across all
processors, equals the number of angles in the system, modified by the processors, equals the number of angles in the system, modified by the
group parameter as explained below.</p> 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 <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 the atoms owned on a processor and their dihedrals. A dihedral will
only be included if all 4 atoms in the dihedral are in the specified only be included if all 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 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> 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> 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><strong>Output info:</strong></p>
<p>This compute calculates a local vector or local array depending on the <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 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> <span id="index-0"></span><h1>compute improper/local command</h1>
<div class="section" id="syntax"> <div class="section" id="syntax">
<h2>Syntax</h2> <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> </pre></div>
</div> </div>
<ul class="simple"> <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>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>improper/local = style name of this compute command</li>
<li>one or more keywords may be appended</li> <li>one or more values may be appended</li>
<li>keyword = <em>chi</em></li> <li>value = <em>chi</em></li>
</ul> </ul>
<pre class="literal-block"> <pre class="literal-block">
<em>chi</em> = tabulate improper angles <em>chi</em> = tabulate improper angles
@ -153,6 +153,9 @@
interactions. The number of datums generated, aggregated across all interactions. The number of datums generated, aggregated across all
processors, equals the number of impropers in the system, modified by processors, equals the number of impropers in the system, modified by
the group parameter as explained below.</p> 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 <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 the atoms owned on a processor and their impropers. An improper will
only be included if all 4 atoms in the improper are in the specified only be included if all 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 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> 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> 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><strong>Output info:</strong></p>
<p>This compute calculates a local vector or local array depending on the <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 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> <span id="index-0"></span><h1>compute pair/local command</h1>
<div class="section" id="syntax"> <div class="section" id="syntax">
<h2>Syntax</h2> <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> </pre></div>
</div> </div>
<ul class="simple"> <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>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>pair/local = style name of this compute command</li>
<li>zero or more keywords may be appended</li> <li>one or more values 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>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> </ul>
<pre class="literal-block"> <pre class="literal-block">
<em>dist</em> = pairwise distance <em>dist</em> = pairwise distance
@ -144,6 +144,13 @@
<em>fx</em>,<em>fy</em>,<em>fz</em> = components of pairwise force <em>fx</em>,<em>fy</em>,<em>fz</em> = components of pairwise force
<em>pN</em> = pair style specific quantities for allowed N values <em>pN</em> = pair style specific quantities for allowed N values
</pre> </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>
<div class="section" id="examples"> <div class="section" id="examples">
<h2>Examples</h2> <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 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> <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> commands.</p>
<p>The output <em>dist</em> is the distance bewteen the pair of atoms.</p> <p>The value <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 value <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, <p>The value <em>force</em> is the force acting between the pair of atoms, which
which is positive for a repulsive force and negative for an attractive 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 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> <em>force</em> on atom I.</p>
<p>A pair style may define additional pairwise quantities which can be <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 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 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 its components and magnitude acting on atom I for N = 1,2,3,4. See
individual pair styles for detils.</p> 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 <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 outputs <em>force</em>, <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>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>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>
<em>pN</em> will be in whatever units the pair style defines.</p> 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 <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 no consistent ordering of the entries within the local vector or array
from one timestep to the next. The only consistency that is 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 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> 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> 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"> <div class="admonition note">
<p class="first admonition-title">Note</p> <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 <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> 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 <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 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>
<div class="section" id="restrictions"> <div class="section" id="restrictions">
<h2>Restrictions</h2> <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"> <div class="section" id="related-commands">
<h2>Related commands</h2> <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><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>
</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> <span id="index-0"></span><h1>compute property/local command</h1>
<div class="section" id="syntax"> <div class="section" id="syntax">
<h2>Syntax</h2> <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> </pre></div>
</div> </div>
<ul class="simple"> <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>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>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> </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> <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">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">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">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">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> <span class="n">iatom1</span> <span class="n">iatom2</span> <span class="n">iatom3</span> <span class="n">itype</span>
</pre></div> </pre></div>
</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> <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> <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> </pre></div>
</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>
<div class="section" id="examples"> <div class="section" id="examples">
<h2>Examples</h2> <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 to bond information, then the number of datums generated, aggregated
across all processors, equals the number of bonds in the system. across all processors, equals the number of bonds in the system.
Ditto for pairs, angles, etc.</p> Ditto for pairs, angles, etc.</p>
<p>If multiple input attributes are specified then they must all generate <p>If multiple attributes are specified then they must all generate the
the same amount of information, so that the resulting local array has same amount of information, so that the resulting local array has the
the same number of rows for each column. This means that only bond same number of rows for each column. This means that only bond
attributes can be specified together, or angle attributes, etc. Bond attributes can be specified together, or angle attributes, etc. Bond
and angle attributes can not be mixed in the same compute and angle attributes can not be mixed in the same compute
property/local command.</p> 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 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> <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> 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 <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 generated by looping over all the atoms owned on a processor and
extracting bond, angle, etc info. For bonds, info about an individual 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 <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 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> <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><strong>Output info:</strong></p>
<p>This compute calculates a local vector or local array depending on the <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 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"> <div class="section" id="related-commands">
<h2>Related commands</h2> <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><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>
</div> </div>

6
doc/html/compute_sna_atom.html
View File

@ -134,9 +134,9 @@
<h1>compute snav/atom command</h1> <h1>compute snav/atom command</h1>
<div class="section" id="syntax"> <div class="section" id="syntax">
<h2>Syntax</h2> <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> <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">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">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> <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> </pre></div>
</div> </div>
<ul class="simple"> <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:] [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 ID, group-ID are documented in "compute"_compute.html command :ulb,l
angle/local = style name of this compute command :l angle/local = style name of this compute command :l
one or more keywords may be appended :l one or more values may be appended :l
keyword = {theta} or {eng} :l value = {theta} or {eng} :l
{theta} = tabulate angles {theta} = tabulate angles
{eng} = tabulate angle energies :pre {eng} = tabulate angle energies :pre
:ule :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 processors, equals the number of angles in the system, modified by the
group parameter as explained below. 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 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 the atoms owned on a processor and their angles. An angle will only
be included if all 3 atoms in the angle are in the specified compute be included if all 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 with data from this command and output by the "dump local"_dump.html
command in a consistent way. 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:] [Output info:]
This compute calculates a local vector or local array depending on the 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:] [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 ID, group-ID are documented in "compute"_compute.html command :ulb,l
bond/local = style name of this compute command :l bond/local = style name of this compute command :l
one or more keywords may be appended :l one or more values may be appended :l
keyword = {dist} or {eng} :l value = {dist} or {eng} or {force} :l
{dist} = bond distance {dist} = bond distance
{eng} = bond energy {eng} = bond energy
{force} = bond force :pre {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 processors, equals the number of bonds in the system, modified
by the group parameter as explained below. 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 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 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. 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: 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 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 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:] [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 ID, group-ID are documented in "compute"_compute.html command :ulb,l
dihedral/local = style name of this compute command :l dihedral/local = style name of this compute command :l
one or more keywords may be appended :l one or more values may be appended :l
keyword = {phi} :l value = {phi} :l
{phi} = tabulate dihedral angles :pre {phi} = tabulate dihedral angles :pre
:ule :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 processors, equals the number of angles in the system, modified by the
group parameter as explained below. 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 local data stored by this command is generated by looping over all
the atoms owned on a processor and their dihedrals. A dihedral will the atoms owned on a processor and their dihedrals. A dihedral will
only be included if all 4 atoms in the dihedral are in the specified only be included if all 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 with data from this command and output by the "dump local"_dump.html
command in a consistent way. 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:] [Output info:]
This compute calculates a local vector or local array depending on the 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:] [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 ID, group-ID are documented in "compute"_compute.html command :ulb,l
improper/local = style name of this compute command :l improper/local = style name of this compute command :l
one or more keywords may be appended :l one or more values may be appended :l
keyword = {chi} :l value = {chi} :l
{chi} = tabulate improper angles :pre {chi} = tabulate improper angles :pre
:ule :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 processors, equals the number of impropers in the system, modified by
the group parameter as explained below. 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 local data stored by this command is generated by looping over all
the atoms owned on a processor and their impropers. An improper will the atoms owned on a processor and their impropers. An improper will
only be included if all 4 atoms in the improper are in the specified only be included if all 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 with data from this command and output by the "dump local"_dump.html
command in a consistent way. 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:] [Output info:]
This compute calculates a local vector or local array depending on the 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:] [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 ID, group-ID are documented in "compute"_compute.html command :ulb,l
pair/local = style name of this compute command :l pair/local = style name of this compute command :l
zero or more keywords may be appended :l one or more values may be appended :l
keyword = {dist} or {eng} or {force} or {fx} or {fy} or {fz} or {pN} :l value = {dist} or {eng} or {force} or {fx} or {fy} or {fz} or {pN} :l
{dist} = pairwise distance {dist} = pairwise distance
{eng} = pairwise energy {eng} = pairwise energy
{force} = pairwise force {force} = pairwise force
{fx},{fy},{fz} = components of pairwise force {fx},{fy},{fz} = components of pairwise force
{pN} = pair style specific quantities for allowed N values :pre {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 :ule
[Examples:] [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 "pair_style"_pair_style.html and "pair_coeff"_pair_coeff.html
commands. 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, The value {force} is the force acting between the pair of atoms, which
which is positive for a repulsive force and negative for an attractive is positive for a repulsive force and negative for an attractive
force. The outputs {fx}, {fy}, and {fz} are the xyz components of force. The values {fx}, {fy}, and {fz} are the xyz components of
{force} on atom I. {force} on atom I.
A pair style may define additional pairwise quantities which can be 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 its components and magnitude acting on atom I for N = 1,2,3,4. See
individual pair styles for detils. individual pair styles for detils.
The output {dist} will be in distance "units"_units.html. The output The value {dist} will be in distance "units"_units.html. The value
{eng} will be in energy "units"_units.html. The outputs {force}, {eng} will be in energy "units"_units.html. The values {force}, {fx},
{fx}, {fy}, and {fz} will be in force "units"_units.html. The output {fy}, and {fz} will be in force "units"_units.html. The values {pN}
{pN} will be in whatever units the pair style defines. 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 Note that as atoms migrate from processor to processor, there will be
no consistent ordering of the entries within the local vector or array 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 with data from this command and output by the "dump local"_dump.html
command in a consistent way. 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 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 interactions within the molecular topology, their pairwise interaction
may be turned off, and thus they may not appear in the neighbor list, 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 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 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 [Restrictions:] none
@ -114,4 +133,6 @@ output for {eng} will be in energy "units"_units.html. The output for
"dump local"_dump.html, "compute "dump local"_dump.html, "compute
property/local"_compute_property_local.html 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:] [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 ID, group-ID are documented in "compute"_compute.html command :ulb,l
property/local = style name of this compute command :l property/local = style name of this compute command :l
input = one or more attributes :l one or more attributes may be appended :l
possible attributes = natom1 natom2 ntype1 ntype2 possible attributes = natom1 natom2 ntype1 ntype2
patom1 patom2 ptype1 ptype2 patom1 patom2 ptype1 ptype2
batom1 batom2 btype batom1 batom2 btype
aatom1 aatom2 aatom3 atype aatom1 aatom2 aatom3 atype
datom1 datom2 datom3 dtype datom1 datom2 datom3 dtype
iatom1 iatom2 iatom3 itype :pre iatom1 iatom2 iatom3 itype :pre
natom1, natom2 = IDs of 2 atoms in each pair (within neighbor cutoff) natom1, natom2 = IDs of 2 atoms in each pair (within neighbor cutoff)
ntype1, ntype2 = type 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 dtype = dihedral type of each dihedral
iatom1, iatom2, iatom3, iatom4 = IDs of 4 atoms in each improper iatom1, iatom2, iatom3, iatom4 = IDs of 4 atoms in each improper
itype = improper type of each improper :pre 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 :ule
[Examples:] [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. across all processors, equals the number of bonds in the system.
Ditto for pairs, angles, etc. Ditto for pairs, angles, etc.
If multiple input attributes are specified then they must all generate If multiple attributes are specified then they must all generate the
the same amount of information, so that the resulting local array has same amount of information, so that the resulting local array has the
the same number of rows for each column. This means that only bond same number of rows for each column. This means that only bond
attributes can be specified together, or angle attributes, etc. Bond attributes can be specified together, or angle attributes, etc. Bond
and angle attributes can not be mixed in the same compute and angle attributes can not be mixed in the same compute
property/local command. 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 "pair_style"_pair_style.html and "pair_coeff"_pair_coeff.html
commands. 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 If the inputs are bond, angle, etc attributes, the local data is
generated by looping over all the atoms owned on a processor and generated by looping over all the atoms owned on a processor and
extracting bond, angle, etc info. For bonds, info about an individual 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 for "angles"_angle_style.html, "dihedrals"_dihedral_style.html, and
"impropers"_improper_style.html. "impropers"_improper_style.html.
The optional {cutoff} keyword
[Output info:] [Output info:]
This compute calculates a local vector or local array depending on the 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 "dump local"_dump.html, "compute reduce"_compute_reduce.html
[Default:] none [Default:]
The keyword default is cutoff = type.