/*
* This file is part of the GROMACS molecular simulation package.
*
- * Copyright (c) 2010,2011,2012,2013, by the GROMACS development team, led by
- * David van der Spoel, Berk Hess, Erik Lindahl, and including many
- * others, as listed in the AUTHORS file in the top-level source
- * directory and at http://www.gromacs.org.
+ * Copyright (c) 2010,2011,2012,2013,2014, by the GROMACS development team, led by
+ * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
+ * and including many others, as listed in the AUTHORS file in the
+ * top-level source directory and at http://www.gromacs.org.
*
* GROMACS is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* \author Teemu Murtola <teemu.murtola@gmail.com>
* \ingroup module_analysisdata
*/
-#include "gromacs/analysisdata/modules/histogram.h"
+#include "gmxpre.h"
+
+#include "histogram.h"
#include <cmath>
#include <limits>
+#include <vector>
#include "gromacs/analysisdata/dataframe.h"
#include "gromacs/analysisdata/datastorage.h"
namespace
{
-/*! \internal \brief
+/*! \brief
* Represents copies of average histograms.
*
* Methods in AbstractAverageHistogram that return new histogram instances
for (int c = 0; c < columnCount(); ++c)
{
real v1, v2;
+ real e1, e2;
if (bFirstHalfBin)
{
- v1 = value(0, c);
+ v1 = value(0, c).value();
+ e1 = value(0, c).error();
v2 = 0;
+ e2 = 0;
}
else
{
- v1 = value(j, c);
- v2 = value(j + 1, c);
- }
- if (c == 1)
- {
- dest->setValue(i, c, sqrt(v1 * v1 + v2 * v2));
- }
- else
- {
- dest->setValue(i, c, v1 + v2);
+ v1 = value(j, c).value();
+ e1 = value(j, c).error();
+ v2 = value(j + 1, c).value();
+ e2 = value(j + 1, c).error();
}
+ dest->value(i, c).setValue(v1 + v2, std::sqrt(e1 * e1 + e2 * e2));
}
if (bFirstHalfBin)
{
void
AbstractAverageHistogram::normalizeProbability()
{
- real sum = 0;
- for (int i = 0; i < rowCount(); ++i)
+ for (int c = 0; c < columnCount(); ++c)
{
- sum += value(i, 0);
+ real sum = 0;
+ for (int i = 0; i < rowCount(); ++i)
+ {
+ sum += value(i, c).value();
+ }
+ if (sum > 0.0)
+ {
+ scaleSingle(c, 1.0 / (sum * xstep()));
+ }
}
- scale(1.0 / (sum * xstep()));
}
void
-AbstractAverageHistogram::scale(real norm)
+AbstractAverageHistogram::scaleSingle(int index, real factor)
{
for (int i = 0; i < rowCount(); ++i)
{
- value(i, 0) *= norm;
- value(i, 1) *= norm;
+ value(i, index).value() *= factor;
+ value(i, index).error() *= factor;
}
}
void
-AbstractAverageHistogram::scaleVector(real norm[])
+AbstractAverageHistogram::scaleAll(real factor)
{
- for (int i = 0; i < rowCount(); ++i)
+ for (int i = 0; i < columnCount(); ++i)
+ {
+ scaleSingle(i, factor);
+ }
+}
+
+
+void
+AbstractAverageHistogram::scaleAllByVector(real factor[])
+{
+ for (int c = 0; c < columnCount(); ++c)
{
- value(i, 0) *= norm[i];
- value(i, 1) *= norm[i];
+ for (int i = 0; i < rowCount(); ++i)
+ {
+ value(i, c).value() *= factor[i];
+ value(i, c).error() *= factor[i];
+ }
}
}
namespace internal
{
-/*! \internal \brief
+/*! \internal
+ * \brief
* Implements average histogram module that averages per-frame histograms.
*
* This class is used for accumulating average histograms in per-frame
* \ingroup module_analysisdata
*/
class BasicAverageHistogramModule : public AbstractAverageHistogram,
- public AnalysisDataModuleInterface
+ public AnalysisDataModuleSerial
{
public:
BasicAverageHistogramModule();
virtual void dataFinished();
private:
- //! Averaging helper object.
- AnalysisDataFrameAverager averager_;
+ //! Averaging helper objects for each input data set.
+ std::vector<AnalysisDataFrameAverager> averagers_;
// Copy and assign disallowed by base.
};
BasicAverageHistogramModule::BasicAverageHistogramModule()
{
- setColumnCount(2);
}
const AnalysisHistogramSettings &settings)
: AbstractAverageHistogram(settings)
{
- setColumnCount(2);
}
int
BasicAverageHistogramModule::flags() const
{
- return efAllowMulticolumn;
+ return efAllowMulticolumn | efAllowMultipleDataSets;
}
void
BasicAverageHistogramModule::dataStarted(AbstractAnalysisData *data)
{
- GMX_RELEASE_ASSERT(rowCount() == data->columnCount(),
- "Inconsistent data sizes, something is wrong in the initialization");
- averager_.setColumnCount(rowCount());
+ setColumnCount(data->dataSetCount());
+ averagers_.resize(data->dataSetCount());
+ for (int i = 0; i < data->dataSetCount(); ++i)
+ {
+ GMX_RELEASE_ASSERT(rowCount() == data->columnCount(i),
+ "Inconsistent data sizes, something is wrong in the initialization");
+ averagers_[i].setColumnCount(data->columnCount(i));
+ }
}
void
BasicAverageHistogramModule::pointsAdded(const AnalysisDataPointSetRef &points)
{
- averager_.addPoints(points);
+ averagers_[points.dataSetIndex()].addPoints(points);
}
void
BasicAverageHistogramModule::dataFinished()
{
- averager_.finish();
allocateValues();
- for (int i = 0; i < rowCount(); ++i)
+ for (int i = 0; i < columnCount(); ++i)
{
- setValue(i, 0, averager_.average(i));
- setValue(i, 1, sqrt(averager_.variance(i)));
+ averagers_[i].finish();
+ for (int j = 0; j < rowCount(); ++j)
+ {
+ value(j, i).setValue(averagers_[i].average(j),
+ std::sqrt(averagers_[i].variance(j)));
+ }
}
}
/*! \brief
* Initializes data storage frame when a new frame starts.
*/
- void initFrame(AnalysisDataStorageFrame *frame);
+ void initFrame(int dataSetCount, AnalysisDataStorageFrame *frame);
//! Storage implementation object.
AnalysisDataStorage storage_;
void
-BasicHistogramImpl::initFrame(AnalysisDataStorageFrame *frame)
+BasicHistogramImpl::initFrame(int dataSetCount, AnalysisDataStorageFrame *frame)
{
- for (int i = 0; i < frame->columnCount(); ++i)
+ for (int s = 0; s < dataSetCount; ++s)
{
- frame->setValue(i, 0.0);
+ frame->selectDataSet(s);
+ for (int i = 0; i < frame->columnCount(); ++i)
+ {
+ frame->setValue(i, 0.0);
+ }
}
+ frame->selectDataSet(0);
}
} // namespace internal
}
+int
+AnalysisDataSimpleHistogramModule::frameCount() const
+{
+ return impl_->storage_.frameCount();
+}
+
+
int
AnalysisDataSimpleHistogramModule::flags() const
{
- return efAllowMulticolumn | efAllowMultipoint;
+ return efAllowMulticolumn | efAllowMultipoint | efAllowMissing
+ | efAllowMultipleDataSets;
}
-void
-AnalysisDataSimpleHistogramModule::dataStarted(AbstractAnalysisData *data)
+bool
+AnalysisDataSimpleHistogramModule::parallelDataStarted(
+ AbstractAnalysisData *data,
+ const AnalysisDataParallelOptions &options)
{
addModule(impl_->averager_);
- setColumnCount(settings().binCount());
- notifyDataStart();
- impl_->storage_.startDataStorage(this);
+ setDataSetCount(data->dataSetCount());
+ for (int i = 0; i < data->dataSetCount(); ++i)
+ {
+ setColumnCount(i, settings().binCount());
+ }
+ impl_->storage_.startParallelDataStorage(this, &moduleManager(), options);
+ return true;
}
AnalysisDataSimpleHistogramModule::frameStarted(const AnalysisDataFrameHeader &header)
{
AnalysisDataStorageFrame &frame = impl_->storage_.startFrame(header);
- impl_->initFrame(&frame);
+ impl_->initFrame(dataSetCount(), &frame);
}
{
AnalysisDataStorageFrame &frame =
impl_->storage_.currentFrame(points.frameIndex());
+ frame.selectDataSet(points.dataSetIndex());
for (int i = 0; i < points.columnCount(); ++i)
{
- int bin = settings().findBin(points.y(i));
- if (bin != -1)
+ if (points.present(i))
{
- frame.value(bin) += 1;
+ const int bin = settings().findBin(points.y(i));
+ if (bin != -1)
+ {
+ frame.value(bin) += 1;
+ }
}
}
}
void
AnalysisDataSimpleHistogramModule::dataFinished()
{
- notifyDataFinish();
+ impl_->storage_.finishDataStorage();
}
}
+int
+AnalysisDataWeightedHistogramModule::frameCount() const
+{
+ return impl_->storage_.frameCount();
+}
+
+
int
AnalysisDataWeightedHistogramModule::flags() const
{
- return efAllowMulticolumn | efAllowMultipoint;
+ return efAllowMulticolumn | efAllowMultipoint | efAllowMultipleDataSets;
}
-void
-AnalysisDataWeightedHistogramModule::dataStarted(AbstractAnalysisData *data)
+bool
+AnalysisDataWeightedHistogramModule::parallelDataStarted(
+ AbstractAnalysisData *data,
+ const AnalysisDataParallelOptions &options)
{
addModule(impl_->averager_);
- setColumnCount(settings().binCount());
- notifyDataStart();
- impl_->storage_.startDataStorage(this);
+ setDataSetCount(data->dataSetCount());
+ for (int i = 0; i < data->dataSetCount(); ++i)
+ {
+ setColumnCount(i, settings().binCount());
+ }
+ impl_->storage_.startParallelDataStorage(this, &moduleManager(), options);
+ return true;
}
AnalysisDataWeightedHistogramModule::frameStarted(const AnalysisDataFrameHeader &header)
{
AnalysisDataStorageFrame &frame = impl_->storage_.startFrame(header);
- impl_->initFrame(&frame);
+ impl_->initFrame(dataSetCount(), &frame);
}
{
AnalysisDataStorageFrame &frame =
impl_->storage_.currentFrame(points.frameIndex());
+ frame.selectDataSet(points.dataSetIndex());
for (int i = 1; i < points.columnCount(); ++i)
{
frame.value(bin) += points.y(i);
void
AnalysisDataWeightedHistogramModule::dataFinished()
{
- notifyDataFinish();
+ impl_->storage_.finishDataStorage();
}
}
//! Histogram settings.
- AnalysisHistogramSettings settings_;
- //! Averaging helper object.
- AnalysisDataFrameAverager averager_;
+ AnalysisHistogramSettings settings_;
+ //! Averaging helper objects for each input data set.
+ std::vector<AnalysisDataFrameAverager> averagers_;
};
AnalysisDataBinAverageModule::AnalysisDataBinAverageModule()
const AnalysisHistogramSettings &settings)
: impl_(new Impl(settings))
{
- setColumnCount(3);
setRowCount(settings.binCount());
setXAxis(settings.firstEdge() + 0.5 * settings.binWidth(),
settings.binWidth());
int
AnalysisDataBinAverageModule::flags() const
{
- return efAllowMulticolumn | efAllowMultipoint;
+ return efAllowMulticolumn | efAllowMultipoint | efAllowMultipleDataSets;
}
void
-AnalysisDataBinAverageModule::dataStarted(AbstractAnalysisData * /*data*/)
+AnalysisDataBinAverageModule::dataStarted(AbstractAnalysisData *data)
{
- impl_->averager_.setColumnCount(rowCount());
+ setColumnCount(data->dataSetCount());
+ impl_->averagers_.resize(data->dataSetCount());
+ for (int i = 0; i < data->dataSetCount(); ++i)
+ {
+ impl_->averagers_[i].setColumnCount(rowCount());
+ }
}
int bin = settings().findBin(points.y(0));
if (bin != -1)
{
+ AnalysisDataFrameAverager &averager = impl_->averagers_[points.dataSetIndex()];
for (int i = 1; i < points.columnCount(); ++i)
{
- impl_->averager_.addValue(bin, points.y(i));
+ averager.addValue(bin, points.y(i));
}
}
}
void
AnalysisDataBinAverageModule::dataFinished()
{
- impl_->averager_.finish();
allocateValues();
- for (int i = 0; i < settings().binCount(); ++i)
+ for (int i = 0; i < columnCount(); ++i)
{
- setValue(i, 0, impl_->averager_.average(i));
- setValue(i, 1, std::sqrt(impl_->averager_.variance(i)));
- setValue(i, 2, impl_->averager_.sampleCount(i));
+ AnalysisDataFrameAverager &averager = impl_->averagers_[i];
+ averager.finish();
+ for (int j = 0; j < rowCount(); ++j)
+ {
+ value(j, i).setValue(averager.average(j),
+ std::sqrt(averager.variance(j)));
+ }
}
valuesReady();
}
biod.pnpi.spb.ru / alexxy / gromacs.git / blobdiff