# compute chunk/spread/atom command
## Syntax
``` LAMMPS
compute ID group-ID chunk/spread/atom chunkID input1 input2 ...
```
- ID, group-ID are documented in [compute](compute) command
- chunk/spread/atom = style name of this compute command
- chunkID = ID of [compute chunk/atom](compute_chunk_atom) command
- one or more inputs can be listed
- input = c_ID, c_ID\[N\], f_ID, f_ID\[N\]
c_ID = global vector calculated by a compute with ID
c_ID[I] = Ith column of global array calculated by a compute with ID, I can include wildcard (see below)
f_ID = global vector calculated by a fix with ID
f_ID[I] = Ith column of global array calculated by a fix with ID, I can include wildcard (see below)
## Examples
``` LAMMPS
compute 1 all chunk/spread/atom mychunk c_com[*] c_gyration
```
## Description
Define a calculation that \"spreads\" one or more per-chunk values to
each atom in the chunk. This can be useful in several scenarios:
- For creating a [dump file](dump) where each atom lists info about
the chunk it is in, e.g. for post-processing purposes.
- To access chunk value in [atom-style variables](variable) that need
info about the chunk each atom is in.
- To use the [fix ave/chunk](fix_ave_chunk) command to spatially
average per-chunk values calculated by a per-chunk compute.
Examples are given below.
In LAMMPS, chunks are collections of atoms defined by a [compute
chunk/atom](compute_chunk_atom) command, which assigns each atom to a
single chunk (or no chunk). The ID for this command is specified as
chunkID. For example, a single chunk could be the atoms in a molecule or
atoms in a spatial bin. See the [compute chunk/atom](compute_chunk_atom)
and [Howto chunk](Howto_chunk) doc pages for details of how chunks can
be defined and examples of how they can be used to measure properties of
a system.
For inputs that are computes, they must be a compute that calculates
per-chunk values. These are computes whose style names end in
\"/chunk\".
For inputs that are fixes, they should be a fix that calculates
per-chunk values. For example, [fix ave/chunk](fix_ave_chunk) or [fix
ave/time](fix_ave_time) (assuming it is time-averaging per-chunk data).
For each atom, this compute accesses its chunk ID from the specified
*chunkID* compute, then accesses the per-chunk value in each input.
Those values are copied to this compute to become the output for that
atom.
The values generated by this compute will be 0.0 for atoms not in the
specified compute group *group-ID*. They will also be 0.0 if the atom is
not in a chunk, as assigned by the *chunkID* compute. They will also be
0.0 if the current chunk ID for the atom is out-of-bounds with respect
to the number of chunks stored by a particular input compute or fix.
:::: note
::: title
Note
:::
LAMMPS does not check that a compute or fix which calculates per-chunk
values uses the same definition of chunks as this compute. It\'s up to
you to be consistent. Likewise, for a fix input, LAMMPS does not check
that it is per-chunk data. It only checks that the fix produces a global
vector or array.
::::
------------------------------------------------------------------------
Each listed input is operated on independently.
If a bracketed index I is used, it can be specified using a wildcard
asterisk with the index to effectively specify multiple values. This
takes the form \"\*\" or \"\*n\" or \"n\*\" or \"m\*n\". If N = the
number of columns in the array, then an asterisk with no numeric values
means all indices from 1 to N. A leading asterisk means all indices from
1 to n (inclusive). A trailing asterisk means all indices from n to N
(inclusive). A middle asterisk means all indices from m to n
(inclusive).
Using a wildcard is the same as if the individual columns of the array
had been listed one by one. E.g. these 2 compute chunk/spread/atom
commands are equivalent, since the [compute
com/chunk](compute_com_chunk) command creates a per-atom array with 3
columns:
``` LAMMPS
compute com all com/chunk mychunk
compute 10 all chunk/spread/atom mychunk c_com[*]
compute 10 all chunk/spread/atom mychunk c_com[1] c_com[2] c_com[3]
```
------------------------------------------------------------------------
Here is an example of writing a dump file the with the center-of-mass
(COM) for the chunk each atom is in. The commands below can be added to
the bench/in.chain script.
``` LAMMPS
compute cmol all chunk/atom molecule
compute com all com/chunk cmol
compute comchunk all chunk/spread/atom cmol c_com[*]
dump 1 all custom 50 tmp.dump id mol type x y z c_comchunk[*]
dump_modify 1 sort id
```
The same per-chunk data for each atom could be used to define per-atom
forces for the [fix addforce](fix_addforce) command. In this example the
forces act to pull atoms of an extended polymer chain towards its COM in
an attractive manner.
``` LAMMPS
compute prop all property/atom xu yu zu
variable k equal 0.1
variable fx atom v_k*(c_comchunk[1]-c_prop[1])
variable fy atom v_k*(c_comchunk[2]-c_prop[2])
variable fz atom v_k*(c_comchunk[3]-c_prop[3])
fix 3 all addforce v_fx v_fy v_fz
```
Note that [compute property/atom](compute_property_atom) is used to
generate unwrapped coordinates for use in the per-atom force
calculation, so that the effect of periodic boundaries is accounted for
properly.
Over time this applied force could shrink each polymer chain\'s radius
of gyration in a polymer mixture simulation. Here is output from the
bench/in.chain script. Thermo output is shown for 1000 steps, where the
last column is the average radius of gyration over all 320 chains in the
32000 atom system:
compute gyr all gyration/chunk cmol
variable ave equal ave(c_gyr)
thermo_style custom step etotal press v_ave
0 22.394765 4.6721833 5.128278
100 22.445002 4.8166709 5.0348372
200 22.500128 4.8790392 4.9364875
300 22.534686 4.9183766 4.8590693
400 22.557196 4.9492211 4.7937849
500 22.571017 4.9161853 4.7412008
600 22.573944 5.0229708 4.6931243
700 22.581804 5.0541301 4.6440647
800 22.584683 4.9691734 4.6000016
900 22.59128 5.0247538 4.5611513
1000 22.586832 4.94697 4.5238362
------------------------------------------------------------------------
Here is an example for using one set of chunks, defined for molecules,
to compute the dipole moment vector for each chunk. E.g. for water
molecules. Then spreading those values to each atom in each chunk. Then
defining a second set of chunks based on spatial bins. And finally,
using the [fix ave/chunk](fix_ave_chunk) command to calculate an average
dipole moment vector per spatial bin.
``` LAMMPS
compute cmol all chunk/atom molecule
compute dipole all dipole/chunk cmol
compute spread all chunk/spread/atom cmol c_dipole[1] c_dipole[2] c_dipole[3]
compute cspatial all chunk/atom bin/1d z lower 0.1 units reduced
fix ave all ave/chunk 100 10 1000 cspatial c_spread[*]
```
Note that the [fix ave/chunk](fix_ave_chunk) command requires per-atom
values as input. That is why the compute chunk/spread/atom command is
used to assign per-chunk values to each atom in the chunk. If a molecule
straddles bin boundaries, each of its atoms contributes in a weighted
manner to the average dipole moment of the spatial bin it is in.
------------------------------------------------------------------------
## Output info
This compute calculates a per-atom vector or array, which can be
accessed by any command that uses per-atom values from a compute as
input. See the [Howto output](Howto_output) page for an overview of
LAMMPS output options.
The output is a per-atom vector if a single input value is specified,
otherwise a per-atom array is output. The number of columns in the array
is the number of inputs provided. The per-atom values for the vector or
each column of the array will be in whatever [units](units) the
corresponding input value is in.
The vector or array values are \"intensive\".
## Restrictions
> none
## Related commands
[compute chunk/atom](compute_chunk_atom), [fix
ave/chunk](fix_ave_chunk), [compute reduce/chunk](compute_reduce_chunk)
## Default
none