.. index:: compute property/local

compute property/local command
==============================

Syntax
""""""

.. code-block:: LAMMPS

   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
* one or more attributes of the same type (neighbor, pair, bond, angle,
  dihedral, or improper) 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, datom4, dtype,
                           iatom1, iatom2, iatom3, iatom4, itype

  * Neighbor attributes

  .. parsed-literal::

     natom1, natom2 = store IDs of two atoms in each pair (within neighbor cutoff)
     ntype1, ntype2 = store types of two atoms in each pair (within neighbor cutoff)

  * Pair attributes

  .. parsed-literal::

     patom1, patom2 = store IDs of two atoms in each pair (within force cutoff)
     ptype1, ptype2 = store types of two atoms in each pair (within force cutoff)

  * Bond attributes

  .. parsed-literal::

     batom1, batom2 = store IDs of two atoms in each bond
     btype = store bond type of each bond

  * Angle attributes

  .. parsed-literal::

     aatom1, aatom2, aatom3 = store IDs of three atoms in each angle
     atype = store angle type of each angle

  * Dihedral attributes

  .. parsed-literal::

     datom1, datom2, datom3, datom4 = store IDs of 4 atoms in each dihedral
     dtype = store dihedral type of each dihedral

  * Improper attributes

  .. parsed-literal::

     iatom1, iatom2, iatom3, iatom4 = store IDs of 4 atoms in each improper
     itype = store improper type of each improper

* zero or more keyword/arg pairs may be appended
* keyword = *cutoff*

  .. parsed-literal::

       *cutoff* arg = *type* or *radius*

Examples
""""""""

.. code-block:: LAMMPS

   compute 1 all property/local btype batom1 batom2
   compute 1 all property/local atype aatom2

Description
"""""""""""

Define a computation that stores the specified attributes as local
data so it can be accessed by other :doc:`output commands
<Howto_output>`.  If the input attributes refer 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 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 cannot be mixed in the same compute
property/local command.

If the inputs are pair attributes, the local data is generated by
looping over the pairwise neighbor list.  Info about an individual
pairwise interaction will only be included if both atoms in the pair
are in the specified compute group.  For *natom1* and *natom2*, all
atom pairs in the neighbor list are considered (out to the neighbor
cutoff = force cutoff + :doc:`neighbor skin <neighbor>`).  For *patom1*
and *patom2*, the distance between the atoms must be less than the
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 :doc:`granular pair styles <pair_gran>`.
Note that if a granular model defines atom types such that all
particles of a specific type are monodisperse (same diameter), then
the two settings are effectively identical.

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
bond will only be included if both atoms in the bond are in the
specified compute group.  Likewise for angles, dihedrals, etc.

For bonds and angles, a bonds/angles that have been broken by setting
their bond/angle type to 0 will not be included.  Bonds/angles that
have been turned off (see the :doc:`fix shake <fix_shake>` or
:doc:`delete_bonds <delete_bonds>` commands) by setting their
bond/angle type negative are written into the file.  This is
consistent with the :doc:`compute bond/local <compute_bond_local>` and
:doc:`compute angle/local <compute_angle_local>` commands

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
guaranteed is that the ordering on a particular timestep will be the
same for local vectors or arrays generated by other compute commands.
For example, output from the :doc:`compute bond/local
<compute_bond_local>` command can be combined with bond atom indices
from this command and output by the :doc:`dump local <dump>` command
in a consistent way.

The *natom1* and *natom2* or *patom1* and *patom2* attributes refer
to the atom IDs of the two atoms in each pairwise interaction computed
by the :doc:`pair_style <pair_style>` command.  The *ntype1* and
*ntype2* or *ptype1* and *ptype2* attributes refer to the atom types
of the two atoms in each pairwise interaction.

.. note::

   For pairs, if two atoms :math:`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,
   and will not be part of the local data created by this command.  More
   specifically, this may be true of :math:`I,J` pairs with a weighting factor
   of 0.0; pairs with a non-zero weighting factor are included.  The
   weighting factors for 1--2, 1--3, and 1--4 pairwise interactions are set
   by the :doc:`special_bonds <special_bonds>` command.

The *batom1* and *batom2* attributes refer to the atom IDs of the 2
atoms in each :doc:`bond <bond_style>`.  The *btype* attribute refers to
the type of the bond, from 1 to Nbtypes = # of bond types.  The number
of bond types is defined in the data file read by the
:doc:`read_data <read_data>` command.

The attributes that start with "a", "d", and "i" refer to similar values
for :doc:`angles <angle_style>`, :doc:`dihedrals <dihedral_style>`, and
:doc:`impropers <improper_style>`.

Output info
"""""""""""

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
the array is the number of bonds, angles, etc.  If a single input is
specified, a local vector is produced.  If two or more inputs are
specified, a local array is produced where the number of columns = the
number of inputs.  The vector or array can be accessed by any command
that uses local values from a compute as input.  See the :doc:`Howto
output <Howto_output>` page for an overview of LAMMPS output options.

The vector or array values will be integers that correspond to the
specified attribute.

Restrictions
""""""""""""
 none

Related commands
""""""""""""""""

:doc:`dump local <dump>`, :doc:`compute reduce <compute_reduce>`

Default
"""""""

The keyword default is cutoff = type.
