DataVirialOverlap

java.lang.Object
- etomica.virial.overlap.DataVirialOverlap

All Implemented Interfaces:

IntegratorOverlap.ReferenceFracSource
```
public class DataVirialOverlap
extends java.lang.Object
implements IntegratorOverlap.ReferenceFracSource
```
Convenience class that analyzes data from the reference and target system, providing average and error estimates on values and ratios. With multiple alpha values, linear or spline interpolation is used to interpolate and find results for intermediate alpha values. The targetIndex parameter taken by some methods refers to the target value of interest. Typically there is one target value, so targetIndex=0. If more than one target exists (perhaps a nominal target as well as values for specific diagrams, or values for differences of integrands), then those average and ratios can be accessed with the appropriate targetIndex. The appropriate targetIndex depends on the order that values were returned by the MeterVirial. The default targetIndex is 0.

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class DataVirialOverlap.FullResult

Nested Classes
Modifier and Type	Class	Description
`static class`	`DataVirialOverlap.FullResult`

Field Summary

Fields
Modifier and Type	Field	Description
`protected AlphaSource`	`alphaSource`
`protected AccumulatorAverage.StatType`	`avgStat`
`protected boolean`	`doIgnoreRefAvg`
`protected AccumulatorAverage.StatType`	`errorStat`
`protected DataVirialOverlap.FullResult`	`fullOverlapResult`
`protected DataVirialOverlap.FullResult`	`fullRatioResult`
`protected DataVirialOverlap.FullResult`	`fullSystemResult`
`protected AccumulatorAverage.StatType`	`ratioErrorStat`
`protected AccumulatorAverage.StatType`	`ratioStat`
`protected AccumulatorRatioAverageCovarianceFull`	`refAccumulator`
`protected AkimaSpline`	`spline`
`protected AccumulatorRatioAverageCovarianceFull`	`targetAccumulator`

Constructor Summary

Constructors
Constructor	Description
`DataVirialOverlap(AlphaSource alphaSource, AccumulatorRatioAverageCovarianceFull aRefAccumulator, AccumulatorRatioAverageCovarianceFull aTargetAccumulator)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`AccumulatorRatioAverageCovarianceFull[]`	`getAccumulators()`
`AlphaSource`	`getAlphaSource()`
`double[]`	`getAverageAndError()`	Returns the total result (appropriate ratio of target, reference and overlap averages) and the uncertainty on that value.
`double[]`	`getAverageAndError(int targetIndex)`
`DataVirialOverlap.FullResult`	`getFullOverlapResultForAlpha(double alpha)`	Returns the full set of overlap results (averages and uncertainties for target and reference overlap averages).
`DataVirialOverlap.FullResult`	`getFullRatioResultForAlpha(double alpha)`	Returns the full set of ratio results (reference and target ratios and errors on those ratios).
`DataVirialOverlap.FullResult`	`getFullRatioResultForAlpha(double alpha, int targetIndex)`
`DataVirialOverlap.FullResult`	`getFullSystemResult()`	Simply return the reference and target averages and uncertainties.
`DataVirialOverlap.FullResult`	`getFullSystemResult(int targetIndex)`
`double`	`getIdealRefFraction(double oldFrac)`
`protected int`	`getNumTargets()`
`double`	`getOverlapAverage()`	Returns the ratio of the reference to target overlap-to-virial ratios (which reduces to reference/target) for the optimal value of the Bennett parameter.
`double`	`getOverlapAverage(int iParam)`	Returns the ratio of the reference to target overlap-to-virial ratios (which reduces to target/reference) for the given value of the Bennet parameter.
`double[]`	`getOverlapAverageAndErrorForAlpha(double alpha)`	Returns the overlap average and uncertainty for a given value of alpha.
`int`	`minDiffLocation()`	Deprecated.
`void`	`reset()`	Convenience method that resets reference and target accumulators
`void`	`setIgnoreReferenceAvg(boolean newDoIgnoreRefAvg)`	Directs this class to ignore the reference average when deciding how much time to spend on each system.

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

- Field Detail
  - refAccumulator
```
protected final AccumulatorRatioAverageCovarianceFull refAccumulator
```
  - targetAccumulator
```
protected final AccumulatorRatioAverageCovarianceFull targetAccumulator
```
  - alphaSource
```
protected final AlphaSource alphaSource
```
  - spline
```
protected final AkimaSpline spline
```
  - fullOverlapResult
```
protected final DataVirialOverlap.FullResult fullOverlapResult
```
  - fullSystemResult
```
protected final DataVirialOverlap.FullResult fullSystemResult
```
  - fullRatioResult
```
protected final DataVirialOverlap.FullResult fullRatioResult
```
  - avgStat
```
protected final AccumulatorAverage.StatType avgStat
```
  - errorStat
```
protected final AccumulatorAverage.StatType errorStat
```
  - ratioStat
```
protected final AccumulatorAverage.StatType ratioStat
```
  - ratioErrorStat
```
protected final AccumulatorAverage.StatType ratioErrorStat
```
  - doIgnoreRefAvg
```
protected boolean doIgnoreRefAvg
```
- Constructor Detail
  - DataVirialOverlap
```
public DataVirialOverlap(AlphaSource alphaSource,
                         AccumulatorRatioAverageCovarianceFull aRefAccumulator,
                         AccumulatorRatioAverageCovarianceFull aTargetAccumulator)
```
- Method Detail
  - getAccumulators
```
public AccumulatorRatioAverageCovarianceFull[] getAccumulators()
```
  - getAlphaSource
```
public AlphaSource getAlphaSource()
```
  - getNumTargets
```
protected int getNumTargets()
```
  - setIgnoreReferenceAvg
```
public void setIgnoreReferenceAvg(boolean newDoIgnoreRefAvg)
```
    Directs this class to ignore the reference average when deciding how much time to spend on each system. The reference average is generally the same across all simulations meaning that it can be precomputed. This is helpful when the reference average is difficult (compared to the other averages). What we need to do for that is to not include the error contribution from the reference average in getIdealRefFraction()
  - getAverageAndError
```
public double[] getAverageAndError()
```
    Returns the total result (appropriate ratio of target, reference and overlap averages) and the uncertainty on that value. Both are calculated for the optimal value of alpha.
  - getAverageAndError
```
public double[] getAverageAndError(int targetIndex)
```
  - getOverlapAverage
```
public double getOverlapAverage()
```
    Returns the ratio of the reference to target overlap-to-virial ratios (which reduces to reference/target) for the optimal value of the Bennett parameter. The optimal value is determined via interpolation of y=(ln(ratio) - ln(alpha)) vs. x=ln(alpha) and taking the x value where y=0. If there are at least 5 alpha values, Akima spline interpolation is used. With 1 alpha value, no interpolation is needed. With 3 alpha values, linear interpolation is used.
  - getFullSystemResult
```
public DataVirialOverlap.FullResult getFullSystemResult()
```
    Simply return the reference and target averages and uncertainties.
  - getFullSystemResult
```
public DataVirialOverlap.FullResult getFullSystemResult(int targetIndex)
```
  - getOverlapAverageAndErrorForAlpha
```
public double[] getOverlapAverageAndErrorForAlpha(double alpha)
```
    Returns the overlap average and uncertainty for a given value of alpha. This is useful to get an error estimate on a new value of alpha.
  - getFullOverlapResultForAlpha
```
public DataVirialOverlap.FullResult getFullOverlapResultForAlpha(double alpha)
```
    Returns the full set of overlap results (averages and uncertainties for target and reference overlap averages). All results are calculated for the given value of alpha.
  - getFullRatioResultForAlpha
```
public DataVirialOverlap.FullResult getFullRatioResultForAlpha(double alpha)
```
    Returns the full set of ratio results (reference and target ratios and errors on those ratios). All results are calculated for the given value of alpha. The errors in the ratios are calculated using the covariance (between the numerator and denominator) measured during the simulation.
  - getFullRatioResultForAlpha
```
public DataVirialOverlap.FullResult getFullRatioResultForAlpha(double alpha,
                                                               int targetIndex)
```
  - getOverlapAverage
```
public double getOverlapAverage(int iParam)
```
    Returns the ratio of the reference to target overlap-to-virial ratios (which reduces to target/reference) for the given value of the Bennet parameter.
  - minDiffLocation
```
@Deprecated
public int minDiffLocation()
```
    Deprecated.
    
    Returns the index of the Bennet parameter which minimizes the differences between the Bennet "sums" from the target and references accumulators. This parameter should be optimal for overlap sampling.
  - getIdealRefFraction
```
public double getIdealRefFraction(double oldFrac)
```
    Specified by:
    
    getIdealRefFraction in interface IntegratorOverlap.ReferenceFracSource
  - reset
```
public void reset()
```
    Convenience method that resets reference and target accumulators

Class DataVirialOverlap

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

refAccumulator

targetAccumulator

alphaSource

spline

fullOverlapResult

fullSystemResult

fullRatioResult

avgStat

errorStat

ratioStat

ratioErrorStat

doIgnoreRefAvg

Constructor Detail

DataVirialOverlap

Method Detail

getAccumulators

getAlphaSource

getNumTargets

setIgnoreReferenceAvg

getAverageAndError

getAverageAndError

getOverlapAverage

getFullSystemResult

getFullSystemResult

getOverlapAverageAndErrorForAlpha

getFullOverlapResultForAlpha

getFullRatioResultForAlpha

getFullRatioResultForAlpha

getOverlapAverage

minDiffLocation

getIdealRefFraction

reset