void
AnalysisDataModuleManager::notifyPointsAdd(const AnalysisDataPointSetRef &points) const
{
GMX_ASSERT(impl_->state_ == Impl::eInFrame, "notifyFrameStart() not called");
// TODO: Add checks for column spans (requires passing the information
// about the column counts from somewhere).
//GMX_ASSERT(points.lastColumn() < columnCount(points.dataSetIndex()),
// "Invalid columns");
GMX_ASSERT(points.frameIndex() == impl_->currIndex_,
"Points do not correspond to current frame");
if (impl_->bSerialModules_)
{
if (!impl_->bAllowMissing_ && !points.allPresent())
{
GMX_THROW(APIError("Missing data not supported by a module"));
}
Impl::ModuleList::const_iterator i;
for (i = impl_->modules_.begin(); i != impl_->modules_.end(); ++i)
{
if (!i->bParallel)
{
i->module->pointsAdded(points);
}
}
}
}
void
MockAnalysisDataModule::Impl::checkReferencePoints(
const AnalysisDataPointSetRef &points)
{
EXPECT_TRUE(frameChecker_.get() != NULL);
if (frameChecker_.get() != NULL)
{
TestReferenceChecker checker(
frameChecker_->checkCompound("DataValues", NULL));
checker.checkInteger(points.columnCount(), "Count");
if (checker.checkPresent(source_->dataSetCount() > 1, "DataSet"))
{
checker.checkInteger(points.dataSetIndex(), "DataSet");
}
const int sourceColumnCount = source_->columnCount(points.dataSetIndex());
const bool bAllColumns = (points.firstColumn() == 0
&& points.columnCount() == sourceColumnCount);
if (checker.checkPresent(!bAllColumns, "FirstColumn"))
{
checker.checkInteger(points.firstColumn(), "FirstColumn");
checker.checkInteger(points.lastColumn(), "LastColumn");
}
AnalysisDataValuesRef::const_iterator value;
for (value = points.values().begin(); value != points.values().end(); ++value)
{
checkReferenceDataPoint(&checker, *value);
}
}
}
void
AnalysisDataPlotModule::pointsAdded(const AnalysisDataPointSetRef &points)
{
if (!isFileOpen())
{
return;
}
for (int i = 0; i < points.columnCount(); ++i)
{
writeValue(points.values()[i]);
}
}
void
AnalysisDataDisplacementModule::pointsAdded(const AnalysisDataPointSetRef &points)
{
if (points.firstColumn() % _impl->ndim != 0
|| points.columnCount() % _impl->ndim != 0)
{
GMX_THROW(APIError("Partial data points"));
}
for (int i = 0; i < points.columnCount(); ++i)
{
_impl->oldval[_impl->ci + points.firstColumn() + i] = points.y(i);
}
}
void AnalysisDataFrameAverager::addPoints(const AnalysisDataPointSetRef &points)
{
const int firstColumn = points.firstColumn();
GMX_ASSERT(static_cast<size_t>(firstColumn + points.columnCount()) <= values_.size(),
"Initialized with too few columns");
for (int i = 0; i < points.columnCount(); ++i)
{
if (points.present(i))
{
addValue(firstColumn + i, points.y(i));
}
}
}
AnalysisDataPointSetRef::AnalysisDataPointSetRef(
const AnalysisDataPointSetRef &points, int firstColumn, int columnCount)
: header_(points.header()), dataSetIndex_(points.dataSetIndex()),
firstColumn_(0)
{
GMX_ASSERT(firstColumn >= 0, "Invalid first column");
GMX_ASSERT(columnCount >= 0, "Invalid column count");
if (points.lastColumn() < firstColumn
|| points.firstColumn() >= firstColumn + columnCount
|| columnCount == 0)
{
return;
}
AnalysisDataValuesRef::const_iterator begin = points.values().begin();
int pointsOffset = firstColumn - points.firstColumn();
if (pointsOffset > 0)
{
// Offset pointer if the first column is not the first in points.
begin += pointsOffset;
}
else
{
// Take into account if first column is before the first in points.
firstColumn_ = -pointsOffset;
columnCount -= -pointsOffset;
}
// Decrease column count if there are not enough columns in points.
AnalysisDataValuesRef::const_iterator end = begin + columnCount;
if (pointsOffset + columnCount > points.columnCount())
{
end = points.values().end();
}
values_ = AnalysisDataValuesRef(begin, end);
}
void
AnalysisDataAverageModule::pointsAdded(const AnalysisDataPointSetRef &points)
{
int firstcol = points.firstColumn();
for (int i = 0; i < points.columnCount(); ++i)
{
if (points.present(i))
{
real y = points.y(i);
value(firstcol + i, 0) += y;
value(firstcol + i, 1) += y * y;
nsamples_[firstcol + i] += 1;
}
}
}
void
AnalysisDataFrameAverageModule::pointsAdded(const AnalysisDataPointSetRef &points)
{
AnalysisDataStorageFrame &frame =
impl_->storage_.currentFrame(points.frameIndex());
for (int i = 0; i < points.columnCount(); ++i)
{
if (points.present(i))
{
const real y = points.y(i);
frame.value(0) += y;
impl_->sampleCount_ += 1;
}
}
}
void
AnalysisDataModuleManager::notifyParallelPointsAdd(
const AnalysisDataPointSetRef &points) const
{
// TODO: Add checks for column spans (requires passing the information
// about the column counts from somewhere).
//GMX_ASSERT(points.lastColumn() < columnCount(points.dataSetIndex()),
// "Invalid columns");
if (impl_->bParallelModules_)
{
if (!impl_->bAllowMissing_ && !points.allPresent())
{
GMX_THROW(APIError("Missing data not supported by a module"));
}
Impl::ModuleList::const_iterator i;
for (i = impl_->modules_.begin(); i != impl_->modules_.end(); ++i)
{
if (i->bParallel)
{
i->module->pointsAdded(points);
}
}
}
}
void
AnalysisDataVectorPlotModule::pointsAdded(const AnalysisDataPointSetRef &points)
{
if (points.firstColumn() % DIM != 0 || points.columnCount() % DIM != 0)
{
GMX_THROW(APIError("Partial data points"));
}
if (!isFileOpen())
{
return;
}
for (int i = 0; i < points.columnCount(); i += 3)
{
for (int d = 0; d < DIM; ++d)
{
if (bWrite_[i])
{
writeValue(points.values()[i + d]);
}
}
if (bWrite_[DIM])
{
const rvec y = { points.y(i), points.y(i + 1), points.y(i + 2) };
AnalysisDataValue value(norm(y));
writeValue(value);
}
}
}
void
AnalysisDataFrameAverageModule::pointsAdded(const AnalysisDataPointSetRef &points)
{
const int dataSet = points.dataSetIndex();
AnalysisDataStorageFrame &frame =
impl_->storage_.currentFrame(points.frameIndex());
for (int i = 0; i < points.columnCount(); ++i)
{
if (points.present(i))
{
// TODO: Consider using AnalysisDataFrameAverager
const real y = points.y(i);
const real delta = y - frame.value(dataSet);
impl_->sampleCount_[dataSet] += 1;
frame.value(dataSet) += delta / impl_->sampleCount_[dataSet];
}
}
}
void
AnalysisDataAverageModule::pointsAdded(const AnalysisDataPointSetRef &points)
{
if (impl_->bDataSets_)
{
const int dataSet = points.dataSetIndex();
for (int i = 0; i < points.columnCount(); ++i)
{
if (points.present(i))
{
impl_->averagers_[0].addValue(dataSet, points.y(i));
}
}
}
else
{
impl_->averagers_[points.dataSetIndex()].addPoints(points);
}
}
void
AbstractAnalysisData::notifyPointsAdd(const AnalysisDataPointSetRef &points) const
{
GMX_ASSERT(impl_->bInData_, "notifyDataStart() not called");
GMX_ASSERT(impl_->bInFrame_, "notifyFrameStart() not called");
GMX_ASSERT(points.lastColumn() < columnCount(), "Invalid columns");
GMX_ASSERT(points.frameIndex() == impl_->currIndex_,
"Points do not correspond to current frame");
if (!impl_->bAllowMissing_ && !points.allPresent())
{
GMX_THROW(APIError("Missing data not supported by a module"));
}
Impl::ModuleList::const_iterator i;
for (i = impl_->modules_.begin(); i != impl_->modules_.end(); ++i)
{
(*i)->pointsAdded(points);
}
}
void
AnalysisDataLifetimeModule::pointsAdded(const AnalysisDataPointSetRef &points)
{
const int dataSet = points.dataSetIndex();
// This assumption is strictly not necessary, but this is how the
// framework works currently, and makes the code below simpler.
GMX_ASSERT(points.firstColumn() == 0
&& points.lastColumn() == static_cast<int>(impl_->currentLifetimes_[dataSet].size()) - 1,
"Point set should cover all columns");
for (int i = 0; i < points.columnCount(); ++i)
{
// TODO: Perhaps add control over how this is determined?
const bool bPresent = points.present(i) && points.y(i) > 0.0;
if (bPresent)
{
++impl_->currentLifetimes_[dataSet][i];
}
else if (impl_->currentLifetimes_[dataSet][i] > 0)
{
impl_->addLifetime(dataSet, impl_->currentLifetimes_[dataSet][i]);
impl_->currentLifetimes_[dataSet][i] = 0;
}
}
}
