Class XVG

Initialize the class from a xvg file.

:Arguments: 
      *filename* 
            is the xvg file; it can only be of type XY or
            NXY. If it is supplied then it is read and parsed
            when :attr:`XVG.array` is accessed.
      *names*
            optional labels for the columns (currently only
            written as comments to file); string with columns
            separated by commas or a list of strings
      *permissive*
            ``False`` raises a :exc:`ValueError` and logs and errior 
            when encountering data lines that it cannot parse.
            ``True`` ignores those lines and logs a warning---this is
            a risk because it might read a corrupted input file [``False``]
      *savedata*
            ``True`` includes the data (:attr:`XVG.array`` and
            associated caches) when the instance is pickled (see
            :mod:`pickle`); this is oftens not desirable because the
            data are already on disk (the xvg file *filename*) and the
            resulting pickle file can become very big. ``False`` omits
            those data from a pickle. [``False``]
            

Overrides: object.__init__

Write array to xvg file filename in NXY format.

Set and change the parameters for calculations involving correlation functions.

:Keywords:
   *nstep*
       only process every *nstep* data point to speed up the FFT; if
       left empty a default is chosen that produces roughly 25,000 data
       points (or whatever is set in *ncorrel*)
   *ncorrel*
       If no *nstep* is supplied, aim at using *ncorrel* data points for
       the FFT; sets :attr:`XVG.ncorrel`.
   *force*            
       force recalculating correlation data even if cached values are
       available
   *kwargs*
       see :func:`numkit.timeseries.tcorrel` for other options

.. SeeAlso: :attr:`XVG.error` for details and references.

Read and cache the file as a numpy array.

The array is returned with column-first indexing, i.e. for a data file with columns X Y1 Y2 Y3 ... the array a will be a[0] = X, a[1] = Y1, ... .

Set the array data from a (i.e. completely replace).

No sanity checks at the moment...

Plot xvg file data.

The first column of the data is always taken as the abscissa
X. Additional columns are plotted as ordinates Y1, Y2, ...

In the special case that there is only a single column then this column
is plotted against the index, i.e. (N, Y).

:Keywords:
  *columns* : list
       Select the columns of the data to be plotted; the list
       is used as a numpy.array extended slice. The default is
       to use all columns. Columns are selected *after* a transform.
  *transform* : function
       function ``transform(array) -> array`` which transforms
       the original array; must return a 2D numpy array of
       shape [X, Y1, Y2, ...] where X, Y1, ... are column
       vectors.  By default the transformation is the
       identity [``lambda x: x``].
  *maxpoints* : int
       limit the total number of data points; matplotlib has issues processing
       png files with >100,000 points and pdfs take forever to display. Set to
       ``None`` if really all data should be displayed. At the moment we simply
       subsample the data at regular intervals. [10000]
  *kwargs*
       All other keyword arguments are passed on to :func:`pylab.plot`.

Quick hack: errorbar plot.

Set columns to select [x, y, dy].

custom pickling protocol: http://docs.python.org/library/pickle.html

If :attr:`XVG.savedata` is ``False`` then any attributes in
:attr:`XVG.__pickle_excluded` are *not* pickled as they are but simply
pickled with the default value.

array

Represent xvg data as a (cached) numpy array.

The array is returned with column-first indexing, i.e. for a data file with columns X Y1 Y2 Y3 ... the array a will be a[0] = X, a[1] = Y1, ... .

Get Method:

unreachable.array(self) - Represent xvg data as a (cached) numpy array.

ma

Represent data as a masked array.

The array is returned with column-first indexing, i.e. for a data file with
columns X Y1 Y2 Y3 ... the array a will be a[0] = X, a[1] = Y1, ... .

inf and nan are filtered via :func:`numpy.isfinite`.

Get Method:

unreachable.ma(self) - Represent data as a masked array.

mean

Get Method:

unreachable.mean(self) - Mean value of all data columns.

std

Get Method:

unreachable.std(self) - Standard deviation from the mean of all data columns.

min

Get Method:

unreachable.min(self) - Minimum of the data columns.

max

Get Method:

unreachable.max(self) - Maximum of the data columns.

error

Error on the mean of the data, taking the correlation time into account.

See Frenkel and Smit, Academic Press, San Diego 2002, p526:

error = sqrt(2*tc*acf[0]/T)

where acf() is the autocorrelation function of the fluctuations around the mean, y-<y>, tc is the correlation time, and T the total length of the simulation.

Get Method:

unreachable.error(self) - Error on the mean of the data, taking the correlation time into account.

tc

Correlation time of the data.

See :meth:`XVG.error` for details.

Get Method:

unreachable.tc(self) - Correlation time of the data.