# compute pair/local command

## Syntax

``` LAMMPS
compute ID group-ID pair/local value1 value2 ... keyword args ...
```

-   ID, group-ID are documented in [compute](compute) command

-   pair/local = style name of this compute command

-   one or more values may be appended

-   value = *dist* or *dx* or *dy* or *dz* or *eng* or *force* or *fx*
    or *fy* or *fz* or *p1* or *p2* or \...

        *dist* = pairwise distance
        *dx*,\ *dy*,\ *dz* = components of pairwise distance
        *eng* = pairwise energy
        *force* = pairwise force
        *fx*,\ *fy*,\ *fz* = components of pairwise force
        *p1*, *p2*, ... = pair style specific quantities for allowed N values

-   zero or more keyword/arg pairs may be appended

-   keyword = *cutoff*

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

## Examples

``` LAMMPS
compute 1 all pair/local eng
compute 1 all pair/local dist eng force
compute 1 all pair/local dist eng fx fy fz
compute 1 all pair/local dist fx fy fz p1 p2 p3
```

## Description

Define a computation that calculates properties of individual pairwise
interactions. The number of datums generated, aggregated across all
processors, equals the number of pairwise interactions in the system.

The local data stored by this command 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, and if the current pairwise distance is less than the
force cutoff distance for that interaction, as defined by the
[pair_style](pair_style) and [pair_coeff](pair_coeff) commands.

The value *dist* is the distance between the pair of atoms. The values
*dx*, *dy*, and *dz* are the $(x,y,z)$ components of the *distance*
between the pair of atoms. This value is always the distance from the
atom of higher to the one with the lower atom ID.

The value *eng* is the interaction energy for the pair of atoms.

The value *force* is the force acting between the pair of atoms, which
is positive for a repulsive force and negative for an attractive force.
The values *fx*, *fy*, and *fz* are the $(x,y,z)$ components of *force*
on atom I. For pair styles that apply non-central forces, such as
[granular pair styles](pair_gran), these values only include the
$(x,y,z)$ components of the normal force component.

A pair style may define additional pairwise quantities which can be
accessed as *p1* to *pN*, where $N$ is defined by the pair style. Most
pair styles do not define any additional quantities, so $N = 0$. An
example of ones that do are the [granular pair styles](pair_gran) which
calculate the tangential force between two particles and return its
components and magnitude acting on atom $I$ for $N \in \{1,2,3,4\}$. See
individual pair styles for details.

When using *pN* with pair style *hybrid*, the output will be the Nth
quantity from the sub-style that computes the pairwise interaction
(based on atom types). If that sub-style does not define a *pN*, the
output will be 0.0. The maximum allowed $N$ is the maximum number of
quantities provided by any sub-style.

When using *pN* with pair style *hybrid/overlay* the quantities from all
sub-styles that provide them are concatenated together into one long
list. For example, if there are 3 sub-styles and 2 of them have
additional output (with 3 and 4 quantities, respectively), then 7 values
(\*p1\* up to *p7*) are defined. The values *p1* to *p3* refer to
quantities defined by the first of the two sub-styles. Values *p4* to
*p7* refer to quantities from the second of the two sub-styles. If the
referenced *pN* is not computed for the specific pairwise interaction
(based on atom types), then the output will be 0.0.

The value *dist*, *dx*, *dy* and *dz* will be in distance
[units](units). The value *eng* will be in energy [units](units). The
values *force*, *fx*, *fy*, and *fz* will be in force [units](units).
The values *pN* will be in whatever units the pair style defines.

The optional *cutoff* keyword determines how the force cutoff distance
for an interaction is determined. For the default setting of *type*, the
pairwise cutoff defined by the [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). 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.

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, pair
output from the [compute property/local](compute_property_local) command
can be combined with data from this command and output by the [dump
local](dump) command in a consistent way.

Here is an example of how to do this:

``` LAMMPS
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
::: title
Note
:::

For pairs, if two atoms I,J are involved in 1\--2, 1\--3, and 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 will be true of 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
[special_bonds](special_bonds) command. An exception is if long-range
Coulombics are being computed via the [kspace_style](kspace_style)
command, then atom pairs with weighting factors of zero are still
included in the neighbor list, so that a portion of the long-range
interaction contribution can be computed in the pair style. Hence in
that case, those atom pairs will be part of the local data created by
this command.
::::

## Output info

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
array is the number of pairs. If a single keyword is specified, a local
vector is produced. If two or more keywords are specified, a local array
is produced where the number of columns = the number of keywords. The
vector or array can be accessed by any command that uses local values
from a compute as input. See the [Howto output](Howto_output) page for
an overview of LAMMPS output options.

The output for *dist* will be in distance [units](units). The output for
*eng* will be in energy [units](units). The output for *force*, *fx*,
*fy*, and *fz* will be in force [units](units). The output for *pN* will
be in whatever units the pair style defines.

## Restrictions

> none

## Related commands

[dump local](dump), [compute property/local](compute_property_local)

## Default

The keyword default is cutoff = type.