If the fix ave/histo/weight command is used, exactly two values must
be specified. If the values are vectors, they must be the same
length. The first value (a scalar or vector) is what is histogrammed
into bins, in the same manner the fix ave/histo command operates. The
second value (a scalar or vector) is used as a "weight". This means
that instead of each value tallying a "1" to its bin, the
corresponding weight is tallied. E.g. the Nth entry in the first
vector tallies the Nth entry (weight) in the second vector.
----------
The *Nevery*\ , *Nrepeat*\ , and *Nfreq* arguments specify on what
timesteps the input values will be used in order to contribute to the
histogram. The final histogram is generated on timesteps that are
multiple of *Nfreq*\ . It is averaged over *Nrepeat* histograms,
computed in the preceding portion of the simulation every *Nevery*
timesteps. *Nfreq* must be a multiple of *Nevery* and *Nevery* must
be non-zero even if *Nrepeat* is 1. Also, the timesteps
contributing to the histogram value cannot overlap,
i.e. Nrepeat*Nevery can not exceed Nfreq.
For example, if Nevery=2, Nrepeat=6, and Nfreq=100, then input values
on timesteps 90,92,94,96,98,100 will be used to compute the final
histogram on timestep 100. Similarly for timesteps
190,192,194,196,198,200 on timestep 200, etc. If Nrepeat=1 and Nfreq
= 100, then no time averaging of the histogram is done; a histogram is
simply generated on timesteps 100,200,etc.
----------
The atom attribute values (x,y,z,vx,vy,vz,fx,fy,fz) are
self-explanatory. Note that other atom attributes can be used as
inputs to this fix by using the :doc:`compute property/atom <compute_property_atom>` command and then specifying
an input value from that compute.
If a value begins with "c_", a compute ID must follow which has been
previously defined in the input script. If *mode* = scalar, then if
no bracketed term is appended, the global scalar calculated by the
compute is used. If a bracketed term is appended, the Ith element of
the global vector calculated by the compute is used. If *mode* =
vector, then if no bracketed term is appended, the global or per-atom
or local vector calculated by the compute is used. Or if the compute
calculates an array, all of the columns of the array are used as if
they had been specified as individual vectors (see description above).
If a bracketed term is appended, the Ith column of the global or
per-atom or local array calculated by the compute is used.
Note that there is a :doc:`compute reduce <compute_reduce>` command
which can sum per-atom quantities into a global scalar or vector which
can thus be accessed by fix ave/histo. Or it can be a compute defined
not in your input script, but by :doc:`thermodynamic output <thermo_style>` or other fixes such as :doc:`fix nvt <fix_nh>` or :doc:`fix temp/rescale <fix_temp_rescale>`. See
the doc pages for these commands which give the IDs of these computes.
Users can also write code for their own compute styles and :doc:`add them to LAMMPS <Section_modify>`.
If a value begins with "f_", a fix ID must follow which has been
previously defined in the input script. If *mode* = scalar, then if
no bracketed term is appended, the global scalar calculated by the fix
is used. If a bracketed term is appended, the Ith element of the
global vector calculated by the fix is used. If *mode* = vector, then
if no bracketed term is appended, the global or per-atom or local
vector calculated by the fix is used. Or if the fix calculates an
array, all of the columns of the array are used as if they had been
specified as individual vectors (see description above). If a
bracketed term is appended, the Ith column of the global or per-atom
or local array calculated by the fix is used.
Note that some fixes only produce their values on certain timesteps,
which must be compatible with *Nevery*\ , else an error will result.
Users can also write code for their own fix styles and :doc:`add them to LAMMPS <Section_modify>`.
If a value begins with "v_", a variable name must follow which has
been previously defined in the input script. If *mode* = scalar, then
only equal-style or vector-style variables can be used, which both
produce global values. In this mode, a vector-style variable requires
a bracketed term to specify the Ith element of the vector calculated
by the variable. If *mode* = vector, then only vector-style or
atom-style variables can be used, which produce a global or per-atom
vector respectively. The vector-style variable must be used without a
bracketed term. See the :doc:`variable <variable>` command for details.
Note that variables of style *equal*\ , *vector*\ , and *atom* define a
formula which can reference individual atom properties or
thermodynamic keywords, or they can invoke other computes, fixes, or
variables when they are evaluated, so this is a very general means of
specifying quantities to histogram.
----------
Additional optional keywords also affect the operation of this fix.
If the *mode* keyword is set to *scalar*\ , then all input values must
be global scalars, or elements of global vectors. If the *mode*
keyword is set to *vector*\ , then all input values must be global or
per-atom or local vectors, or columns of global or per-atom or local
arrays.
The *beyond* keyword determines how input values that fall outside the
*lo* to *hi* bounds are treated. Values such that *lo* <= value <=
*hi* are assigned to one bin. Values on a bin boundary are assigned
to the lower of the 2 bins. If *beyond* is set to *ignore* then
values < *lo* and values > *hi* are ignored, i.e. they are not binned.
If *beyond* is set to *end* then values < *lo* are counted in the
first bin and values > *hi* are counted in the last bin. If *beyond*
is set to *extend* then two extra bins are created, so that there are
Nbins+2 total bins. Values < *lo* are counted in the first bin and
values > *hi* are counted in the last bin (Nbins+1). Values between
*lo* and *hi* (inclusive) are counted in bins 2 thru Nbins+1. The
"coordinate" stored and printed for these two extra bins is *lo* and
*hi*\ .
The *ave* keyword determines how the histogram produced every *Nfreq*
steps are averaged with histograms produced on previous steps that
were multiples of *Nfreq*\ , before they are accessed by another output
command or written to a file.
If the *ave* setting is *one*\ , then the histograms produced on
timesteps that are multiples of *Nfreq* are independent of each other;
they are output as-is without further averaging.
If the *ave* setting is *running*\ , then the histograms produced on
timesteps that are multiples of *Nfreq* are summed and averaged in a
cumulative sense before being output. Each bin value in the histogram
is thus the average of the bin value produced on that timestep with
all preceding values for the same bin. This running average begins
when the fix is defined; it can only be restarted by deleting the fix
via the :doc:`unfix <unfix>` command, or by re-defining the fix by
re-specifying it.
If the *ave* setting is *window*\ , then the histograms produced on
timesteps that are multiples of *Nfreq* are summed within a moving
"window" of time, so that the last M histograms are used to produce
the output. E.g. if M = 3 and Nfreq = 1000, then the output on step
10000 will be the combined histogram of the individual histograms on
steps 8000,9000,10000. Outputs on early steps will be sums over less
than M histograms if they are not available.
The *start* keyword specifies what timestep histogramming will begin
on. The default is step 0. Often input values can be 0.0 at time 0,
so setting *start* to a larger value can avoid including a 0.0 in
a running or windowed histogram.
The *file* keyword allows a filename to be specified. Every *Nfreq*
steps, one histogram is written to the file. This includes a leading
line that contains the timestep, number of bins, the total count of
values contributing to the histogram, the count of values that were
not histogrammed (see the *beyond* keyword), the minimum value
encountered, and the maximum value encountered. The min/max values
include values that were not histogrammed. Following the leading
line, one line per bin is written into the file. Each line contains
the bin #, the coordinate for the center of the bin (between *lo* and
*hi*\ ), the count of values in the bin, and the normalized count. The
normalized count is the bin count divided by the total count (not
including values not histogrammed), so that the normalized values sum
to 1.0 across all bins.
The *overwrite* keyword will continuously overwrite the output file
with the latest output, so that it only contains one timestep worth of
output. This option can only be used with the *ave running* setting.
The *title1* and *title2* and *title3* keywords allow specification of
the strings that will be printed as the first 3 lines of the output
file, assuming the *file* keyword was used. LAMMPS uses default
values for each of these, so they do not need to be specified.
