AccumulatorAverageCollapsingLog

java.lang.Object
- etomica.data.DataProcessor
- - etomica.data.DataProcessorForked
  - - etomica.data.DataAccumulator
    - - etomica.data.AccumulatorAverageCollapsingLog

All Implemented Interfaces:

DataPipe, DataPipeForked, DataSourceIndependent, IDataSink, IDataSource

Direct Known Subclasses:

AccumulatorAverageCollapsingLogAB
```
public class AccumulatorAverageCollapsingLog
extends DataAccumulator
implements DataSourceIndependent
```
AccumulatorAverage that keeps track of block averages and standard deviations corresponding to all block sizes from 1 to the n where n is the largest power of 2 less than the current number of samples. In addition to block averages and standard deviations of the sampled quantity, the natural log of the block averages and standard deviation of the natural log is also calculated (this is what makes this class actually useful). getData returns the average natural log values for all block sizes as a DataFunction.
This class also uses a method to improve the block statistics for large. All block averages are kept for a particular block size (n1 blocks of size b1). Statistics for that block are computed from that data. Block averages for blocks of the next larger size (2*n1) are computed by randomly selecting n1/2 pairs of block values from the b1 set (without including any block value more than once). After using all block values, n1/2 additional pairs are taken from the full b1 set, such that n1 blocks of size b1*2 are obtained, instead of n1/2 blocks that would normally exist. Statistics for block size b1*2 are computed from these n1 blocks. This process is repeated for each block size such that the largest block size (which would normally have 1 block) has n1 blocks.
This accumulator can only operate on Data with a single value.

Field Summary

Fields
Modifier and Type	Field	Description
`protected DataFunction`	`averages`
`protected double[]`	`blockSums`
`protected long`	`count`
`protected int`	`initialSeed`
`protected java.util.ArrayList<java.lang.Integer>`	`intArrayList`
`protected AccumulatorAverageCollapsing`	`lAvg`
`protected DataDouble`	`lData`
`protected DataDouble.DataInfoDouble`	`lDataInfo`
`protected double[][]`	`lSums`
`protected DataDoubleArray`	`nData`
`protected DataDoubleArray.DataInfoDoubleArray`	`nDataInfo`
`protected int`	`nMoments`
`protected int`	`nRawData`
`protected int`	`nRawDataDoubles`
`protected DataTag`	`nTag`
`protected IRandom`	`random`
`protected double[]`	`rawData`
`protected double[]`	`rawData2`
`protected double[]`	`rawData3`
`protected int`	`rawDataBlockSize`
`protected DataFunction`	`skew`
`protected DataFunction`	`stdev`
`protected double[][]`	`sums`
`protected boolean`	`withReplacement`

Fields inherited from class etomica.data.DataAccumulator
active, hasUnpushedData, pushInterval, putCount

Fields inherited from class etomica.data.DataProcessor
dataInfo, dataSink, tag

Constructor Summary

Constructors
Constructor	Description
`AccumulatorAverageCollapsingLog()`
`AccumulatorAverageCollapsingLog(int nMoments)`	With this constructor, the accumulator will use an internal RNG with a set seed such that each resampling of the data will be identical (the same set of samples will go into the averages and the standard deviations, etc).
`AccumulatorAverageCollapsingLog(IRandom random)`
`AccumulatorAverageCollapsingLog(IRandom random, int nMoments)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`addData(IData data)`	Add the given values to the sums and block sums.
`protected void`	`doSums(double[] subSums, double v)`	Performs the block sum after
`void`	`enableRawLogStatistics()`
`protected void`	`ensureHappyIntArrayList()`	Refills inArrayList if it's empty.
`IData`	`getAverageLogs()`	Returns the average natural logs of the block averages, for all block sizes.
`IData`	`getAverages()`	Returns the averages for all block sizes
`long`	`getCount()`
`IData`	`getData()`
`int`	`getIndependentArrayDimension()`	Returns the number of independent data dimensions
`DataDoubleArray`	`getIndependentData(int i)`	Returns the X data for the given dimension
`DataDoubleArray.DataInfoDoubleArray`	`getIndependentDataInfo(int i)`	Returns the DataInfo for the given dimension
`DataTag`	`getIndependentTag()`	Returns the tag associated with this DataSource.
`int`	`getNumRawData()`
`double[]`	`getRawData()`
`int`	`getRawDataBlockSize()`
`AccumulatorAverage`	`getRawLogAccumulator()`
`double`	`getRawLogDataCorrelation()`	Returns the correlation between consecutive values of the log of the "raw" data held by the accumulator.
`double`	`getSampleLogVariance()`
`double`	`getSampleVariance()`
`IData`	`getSkewLog()`	Returns the standard deviation of the log of the block averages, for all block sizes.
`IData`	`getStdev()`	Returns the standard deviation of the block averages, for all block sizes.
`IData`	`getStdevLog()`	Returns the standard deviation of the log of the block averages, for all block sizes.
`static void`	`main(java.lang.String[] args)`
`IData`	`processData(IData inputData)`	Returns getData() every `pushInterval` times it is invoked, otherwise returns null (thereby preventing transmission of data to the next DataSinks).
`IDataInfo`	`processDataInfo(IDataInfo incomingDataInfo)`	Informs this DataProcessor of the DataInfo for the Data it will be processing.
`protected void`	`reblockData()`	Reblock data from rawData2 into rawData3, then copy it back to rawData2
`protected void`	`reblockData(int n)`	Reblock data from rawData into rawData2, taking blocks of size n
`void`	`reset()`	Resets all sums to zero.
`protected void`	`resizeData(int newSize)`
`void`	`setNumRawDataDoubles(int newNumRawDataDoubles)`	Sets the number of times the random block generation method is used.

Methods inherited from class etomica.data.DataAccumulator
getPushInterval, isActive, setActive, setPushInterval, toString

Methods inherited from interface etomica.data.DataPipe
getTag

Methods inherited from class etomica.data.DataProcessor
getDataInfo, getTag, putData, putDataInfo

Methods inherited from class etomica.data.DataProcessorForked
addDataSink, getDataSink, getDataSinks, removeDataSink, setDataSink, setDataSinks

Methods inherited from interface etomica.data.IDataSink
putData, putDataInfo

Methods inherited from interface etomica.data.IDataSource
getDataInfo, getTag

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - nTag
```
protected final DataTag nTag
```
  - random
```
protected final IRandom random
```
  - nMoments
```
protected final int nMoments
```
  - withReplacement
```
protected final boolean withReplacement
```
    See Also:
    
    Constant Field Values
  - count
```
protected long count
```
  - blockSums
```
protected double[] blockSums
```
  - sums
```
protected double[][] sums
```
  - lSums
```
protected double[][] lSums
```
  - averages
```
protected DataFunction averages
```
  - stdev
```
protected DataFunction stdev
```
  - skew
```
protected DataFunction skew
```
  - nDataInfo
```
protected DataDoubleArray.DataInfoDoubleArray nDataInfo
```
  - nData
```
protected DataDoubleArray nData
```
  - rawData
```
protected double[] rawData
```
  - rawData2
```
protected double[] rawData2
```
  - rawData3
```
protected double[] rawData3
```
  - nRawData
```
protected int nRawData
```
  - rawDataBlockSize
```
protected int rawDataBlockSize
```
  - nRawDataDoubles
```
protected int nRawDataDoubles
```
  - intArrayList
```
protected java.util.ArrayList<java.lang.Integer> intArrayList
```
  - initialSeed
```
protected int initialSeed
```
  - lAvg
```
protected AccumulatorAverageCollapsing lAvg
```
  - lData
```
protected DataDouble lData
```
  - lDataInfo
```
protected DataDouble.DataInfoDouble lDataInfo
```
- Constructor Detail
  - AccumulatorAverageCollapsingLog
```
public AccumulatorAverageCollapsingLog()
```
  - AccumulatorAverageCollapsingLog
```
public AccumulatorAverageCollapsingLog(int nMoments)
```
    With this constructor, the accumulator will use an internal RNG with a set seed such that each resampling of the data will be identical (the same set of samples will go into the averages and the standard deviations, etc).
    
    Parameters:
    
    nMoments - the number of moments handled by the accumulator. should be 2 (standard deviation) or 3 (stdev + skew).
  - AccumulatorAverageCollapsingLog
```
public AccumulatorAverageCollapsingLog(IRandom random)
```
  - AccumulatorAverageCollapsingLog
```
public AccumulatorAverageCollapsingLog(IRandom random,
                                       int nMoments)
```
    Parameters:
    
    nMoments - the number of moments handled by the accumulator. should be 2 (standard deviation) or 3 (stdev + skew).
- Method Detail
  - main
```
public static void main(java.lang.String[] args)
```
  - setNumRawDataDoubles
```
public void setNumRawDataDoubles(int newNumRawDataDoubles)
```
    Sets the number of times the random block generation method is used. The number of blocks used will be 2^numRawDataDoubles.
  - processData
```
public IData processData(IData inputData)
```
    Description copied from class: DataAccumulator
    
    Returns getData() every pushInterval times it is invoked, otherwise returns null (thereby preventing transmission of data to the next DataSinks). If isActive is false, data is not accumulated and no action is performed.
    
    Overrides:
    
    processData in class DataAccumulator
    
    Parameters:
    
    inputData - data to be processed.
    
    Returns:
    
    processed data
  - addData
```
public boolean addData(IData data)
```
    Add the given values to the sums and block sums. If any of the given data values is NaN, method returns with no effect on accumulation sums.
    
    Specified by:
    
    addData in class DataAccumulator
    
    Parameters:
    
    data - the data to be processed
    
    Returns:
    
    true if the Accumulator's getData method will now return different data.
  - getCount
```
public long getCount()
```
  - resizeData
```
protected void resizeData(int newSize)
```
  - getData
```
public IData getData()
```
    Specified by:
    
    getData in interface IDataSource
    
    Specified by:
    
    getData in class DataAccumulator
    
    Returns:
    
    the data given by this source
  - getAverages
```
public IData getAverages()
```
    Returns the averages for all block sizes
  - getAverageLogs
```
public IData getAverageLogs()
```
    Returns the average natural logs of the block averages, for all block sizes.
  - reblockData
```
protected void reblockData()
```
    Reblock data from rawData2 into rawData3, then copy it back to rawData2
  - reblockData
```
protected void reblockData(int n)
```
    Reblock data from rawData into rawData2, taking blocks of size n
  - ensureHappyIntArrayList
```
protected void ensureHappyIntArrayList()
```
    Refills inArrayList if it's empty.
  - getStdev
```
public IData getStdev()
```
    Returns the standard deviation of the block averages, for all block sizes.
  - getStdevLog
```
public IData getStdevLog()
```
    Returns the standard deviation of the log of the block averages, for all block sizes.
  - getSkewLog
```
public IData getSkewLog()
```
    Returns the standard deviation of the log of the block averages, for all block sizes.
  - doSums
```
protected void doSums(double[] subSums,
                      double v)
```
    Performs the block sum after
  - getNumRawData
```
public int getNumRawData()
```
  - getRawData
```
public double[] getRawData()
```
  - getRawLogDataCorrelation
```
public double getRawLogDataCorrelation()
```
    Returns the correlation between consecutive values of the log of the "raw" data held by the accumulator. Raw data may be individual samples, or block averages, depending on how much data has been collected. The method returning the standard deviation of the log is based on the idea that the "raw" data is uncorrelated. If the correlation is small, the standard deviation can be adjusted. If large, then the standard deviation is bogus (too small) and you must either collect more data (so that the raw data are block averages with more samples) or decrease the # of raw doubles (setNumRawDataDoubles) so that the accumulator blocks data more aggressively.
  - getSampleVariance
```
public double getSampleVariance()
```
  - getSampleLogVariance
```
public double getSampleLogVariance()
```
  - getRawDataBlockSize
```
public int getRawDataBlockSize()
```
  - reset
```
public void reset()
```
    Resets all sums to zero. All statistics are cleared.
    
    Specified by:
    
    reset in class DataAccumulator
  - processDataInfo
```
public IDataInfo processDataInfo(IDataInfo incomingDataInfo)
```
    Description copied from class: DataProcessor
    
    Informs this DataProcessor of the DataInfo for the Data it will be processing. Typically the subclass will use this information to make any objects or otherwise prepare for calls to processData.
    
    Specified by:
    
    processDataInfo in class DataProcessor
    
    Parameters:
    
    incomingDataInfo - the DataInfo of the Data that will be input to this DataProcessor
    
    Returns:
    
    the DataInfo of the Data that will be output by this DataProcessor
  - getIndependentArrayDimension
```
public int getIndependentArrayDimension()
```
    Description copied from interface: DataSourceIndependent
    
    Returns the number of independent data dimensions
    
    Specified by:
    
    getIndependentArrayDimension in interface DataSourceIndependent
  - getIndependentData
```
public DataDoubleArray getIndependentData(int i)
```
    Description copied from interface: DataSourceIndependent
    
    Returns the X data for the given dimension
    
    Specified by:
    
    getIndependentData in interface DataSourceIndependent
  - getIndependentDataInfo
```
public DataDoubleArray.DataInfoDoubleArray getIndependentDataInfo(int i)
```
    Description copied from interface: DataSourceIndependent
    
    Returns the DataInfo for the given dimension
    
    Specified by:
    
    getIndependentDataInfo in interface DataSourceIndependent
  - getIndependentTag
```
public DataTag getIndependentTag()
```
    Description copied from interface: DataSourceIndependent
    
    Returns the tag associated with this DataSource.
    
    Specified by:
    
    getIndependentTag in interface DataSourceIndependent
  - enableRawLogStatistics
```
public void enableRawLogStatistics()
```
  - getRawLogAccumulator
```
public AccumulatorAverage getRawLogAccumulator()
```

Class AccumulatorAverageCollapsingLog

Field Summary

Fields inherited from class etomica.data.DataAccumulator

Fields inherited from class etomica.data.DataProcessor

Constructor Summary

Method Summary

Methods inherited from class etomica.data.DataAccumulator

Methods inherited from interface etomica.data.DataPipe

Methods inherited from class etomica.data.DataProcessor

Methods inherited from class etomica.data.DataProcessorForked

Methods inherited from interface etomica.data.IDataSink

Methods inherited from interface etomica.data.IDataSource

Methods inherited from class java.lang.Object

Field Detail

nTag

random

nMoments

withReplacement

count

blockSums

sums

lSums

averages

stdev

skew

nDataInfo

nData

rawData

rawData2

rawData3

nRawData

rawDataBlockSize

nRawDataDoubles

intArrayList

initialSeed

lAvg

lData

lDataInfo

Constructor Detail

AccumulatorAverageCollapsingLog

AccumulatorAverageCollapsingLog

AccumulatorAverageCollapsingLog

AccumulatorAverageCollapsingLog

Method Detail

main

setNumRawDataDoubles

processData

addData

getCount

resizeData

getData

getAverages

getAverageLogs

reblockData

reblockData

ensureHappyIntArrayList

getStdev

getStdevLog

getSkewLog

doSums

getNumRawData

getRawData

getRawLogDataCorrelation

getSampleVariance

getSampleLogVariance

getRawDataBlockSize

reset

processDataInfo

getIndependentArrayDimension

getIndependentData

getIndependentDataInfo

getIndependentTag

enableRawLogStatistics

getRawLogAccumulator