3 * This source code is part of
7 * GROningen MAchine for Chemical Simulations
9 * Written by David van der Spoel, Erik Lindahl, Berk Hess, and others.
10 * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
11 * Copyright (c) 2001-2009, The GROMACS development team,
12 * check out http://www.gromacs.org for more information.
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version 2
17 * of the License, or (at your option) any later version.
19 * If you want to redistribute modifications, please consider that
20 * scientific software is very special. Version control is crucial -
21 * bugs must be traceable. We will be happy to consider code for
22 * inclusion in the official distribution, but derived work must not
23 * be called official GROMACS. Details are found in the README & COPYING
24 * files - if they are missing, get the official version at www.gromacs.org.
26 * To help us fund GROMACS development, we humbly ask that you cite
27 * the papers on the package - you can find them in the top README file.
29 * For more info, check our website at http://www.gromacs.org
33 * Implements classes in histogram.h.
35 * \author Teemu Murtola <teemu.murtola@cbr.su.se>
36 * \ingroup module_analysisdata
38 #include "gromacs/analysisdata/modules/histogram.h"
44 #include "gromacs/basicmath.h"
45 #include "gromacs/analysisdata/dataframe.h"
46 #include "gromacs/analysisdata/datastorage.h"
47 #include "gromacs/fatalerror/exceptions.h"
48 #include "gromacs/fatalerror/gmxassert.h"
50 #include "histogram-impl.h"
52 static const real UNDEFINED = std::numeric_limits<real>::max();
53 static bool isDefined(real value)
55 return value != UNDEFINED;
61 /********************************************************************
62 * AnalysisHistogramSettingsInitializer
65 AnalysisHistogramSettingsInitializer::AnalysisHistogramSettingsInitializer()
66 : min_(UNDEFINED), max_(UNDEFINED), binWidth_(UNDEFINED),
67 binCount_(0), bIntegerBins_(false), bRoundRange_(false),
73 /********************************************************************
74 * AnalysisHistogramSettings
77 AnalysisHistogramSettings::AnalysisHistogramSettings()
78 : firstEdge_(0.0), lastEdge_(0.0), binWidth_(0.0), inverseBinWidth_(0.0),
79 binCount_(0), bAll_(false)
84 AnalysisHistogramSettings::AnalysisHistogramSettings(
85 const AnalysisHistogramSettingsInitializer &settings)
87 GMX_RELEASE_ASSERT(isDefined(settings.min_),
88 "Histogram start value must be defined");
89 GMX_RELEASE_ASSERT(!isDefined(settings.max_) || settings.max_ > settings.min_,
90 "Histogram end value must be larger than start value");
91 GMX_RELEASE_ASSERT(!isDefined(settings.binWidth_) || settings.binWidth_ > 0.0,
92 "Histogram bin width must be positive");
93 GMX_RELEASE_ASSERT(settings.binCount_ >= 0,
94 "Histogram bin count must be positive");
96 if (!isDefined(settings.max_))
98 GMX_RELEASE_ASSERT(isDefined(settings.binWidth_) && settings.binCount_ > 0,
99 "Not all required values provided");
100 GMX_RELEASE_ASSERT(!settings.bRoundRange_,
101 "Rounding only supported for min/max ranges");
103 firstEdge_ = settings.min_;
104 binCount_ = settings.binCount_;
105 binWidth_ = settings.binWidth_;
106 if (settings.bIntegerBins_)
108 firstEdge_ -= 0.5 * binWidth_;
110 lastEdge_ = firstEdge_ + binCount_ * binWidth_;
114 GMX_RELEASE_ASSERT(!(isDefined(settings.binWidth_) && settings.binCount_ > 0),
115 "Conflicting histogram bin specifications");
116 GMX_RELEASE_ASSERT(isDefined(settings.binWidth_) || settings.binCount_ > 0,
117 "Not all required values provided");
119 if (settings.bRoundRange_)
121 GMX_RELEASE_ASSERT(!settings.bIntegerBins_,
122 "Rounding and integer bins cannot be combined");
123 GMX_RELEASE_ASSERT(isDefined(settings.binWidth_),
124 "Rounding only makes sense with defined binwidth");
125 binWidth_ = settings.binWidth_;
126 firstEdge_ = binWidth_ * floor(settings.min_ / binWidth_);
127 lastEdge_ = binWidth_ * ceil(settings.max_ / binWidth_);
128 binCount_ = static_cast<int>((lastEdge_ - firstEdge_) / binWidth_ + 0.5);
132 firstEdge_ = settings.min_;
133 lastEdge_ = settings.max_;
134 if (settings.binCount_ > 0)
136 binCount_ = settings.binCount_;
137 if (settings.bIntegerBins_)
139 GMX_RELEASE_ASSERT(settings.binCount_ > 1,
140 "Bin count must be at least two with integer bins");
141 binWidth_ = (lastEdge_ - firstEdge_) / (binCount_ - 1);
142 firstEdge_ -= 0.5 * binWidth_;
143 lastEdge_ += 0.5 * binWidth_;
147 binWidth_ = (lastEdge_ - firstEdge_) / binCount_;
152 binWidth_ = settings.binWidth_;
153 binCount_ = static_cast<int>((lastEdge_ - firstEdge_) / binWidth_ + 0.5);
154 if (settings.bIntegerBins_)
156 firstEdge_ -= 0.5 * binWidth_;
159 lastEdge_ = firstEdge_ + binCount_ * binWidth_;
164 inverseBinWidth_ = 1.0 / binWidth_;
165 bAll_ = settings.bIncludeAll_;
170 AnalysisHistogramSettings::findBin(real y) const
174 return bAll_ ? 0 : -1;
176 int bin = static_cast<int>((y - firstEdge_) * inverseBinWidth_);
177 if (bin >= binCount_)
179 return bAll_ ? binCount_ - 1 : -1;
185 /********************************************************************
186 * AbstractAverageHistogram
189 AbstractAverageHistogram::AbstractAverageHistogram()
194 AbstractAverageHistogram::AbstractAverageHistogram(
195 const AnalysisHistogramSettings &settings)
196 : settings_(settings)
198 setRowCount(settings.binCount());
199 setXAxis(settings.firstEdge() + 0.5 * settings.binWidth(),
200 settings.binWidth());
204 AbstractAverageHistogram::~AbstractAverageHistogram()
210 AbstractAverageHistogram::init(const AnalysisHistogramSettings &settings)
212 settings_ = settings;
213 setRowCount(settings.binCount());
214 setXAxis(settings.firstEdge() + 0.5 * settings.binWidth(),
215 settings.binWidth());
219 AverageHistogramPointer
220 AbstractAverageHistogram::resampleDoubleBinWidth(bool bIntegerBins) const
225 nbins = (rowCount() + 1) / 2;
229 nbins = rowCount() / 2;
232 AverageHistogramPointer dest(
233 new internal::StaticAverageHistogram(
234 histogramFromBins(xstart(), nbins, 2*xstep())
235 .integerBins(bIntegerBins)));
236 dest->setColumnCount(columnCount());
237 dest->allocateValues();
240 for (i = j = 0; i < nbins; ++i)
242 const bool bFirstHalfBin = (bIntegerBins && i == 0);
243 for (int c = 0; c < columnCount(); ++c)
254 v2 = value(j + 1, c);
258 dest->setValue(i, c, sqrt(v1 * v1 + v2 * v2));
262 dest->setValue(i, c, v1 + v2);
278 AverageHistogramPointer
279 AbstractAverageHistogram::clone() const
281 AverageHistogramPointer dest(new internal::StaticAverageHistogram());
282 copyContents(this, dest.get());
288 AbstractAverageHistogram::normalizeProbability()
291 for (int i = 0; i < rowCount(); ++i)
295 scale(1.0 / (sum * xstep()));
300 AbstractAverageHistogram::scale(real norm)
302 for (int i = 0; i < rowCount(); ++i)
311 AbstractAverageHistogram::scaleVector(real norm[])
313 for (int i = 0; i < rowCount(); ++i)
315 value(i, 0) *= norm[i];
316 value(i, 1) *= norm[i];
321 /********************************************************************
322 * StaticAverageHistogram
328 StaticAverageHistogram::StaticAverageHistogram()
333 StaticAverageHistogram::StaticAverageHistogram(
334 const AnalysisHistogramSettings &settings)
335 : AbstractAverageHistogram(settings)
340 /********************************************************************
341 * BasicAverageHistogramModule
344 BasicAverageHistogramModule::BasicAverageHistogramModule()
351 BasicAverageHistogramModule::BasicAverageHistogramModule(
352 const AnalysisHistogramSettings &settings)
353 : AbstractAverageHistogram(settings), frameCount_(0)
360 BasicAverageHistogramModule::flags() const
362 return efAllowMulticolumn;
367 BasicAverageHistogramModule::dataStarted(AbstractAnalysisData *data)
369 GMX_RELEASE_ASSERT(rowCount() == data->columnCount(),
370 "Inconsistent data sizes, something is wrong in the initialization");
376 BasicAverageHistogramModule::frameStarted(const AnalysisDataFrameHeader & /*header*/)
382 BasicAverageHistogramModule::pointsAdded(const AnalysisDataPointSetRef &points)
384 int firstcol = points.firstColumn();
385 for (int i = 0; i < points.columnCount(); ++i)
387 real y = points.y(i);
388 value(firstcol + i, 0) += y;
389 value(firstcol + i, 1) += y * y;
395 BasicAverageHistogramModule::frameFinished(const AnalysisDataFrameHeader & /*header*/)
402 BasicAverageHistogramModule::dataFinished()
404 for (int i = 0; i < rowCount(); ++i)
406 real ave = value(i, 0) / frameCount_;
407 real std = sqrt(value(i, 1) / frameCount_ - ave * ave);
414 /********************************************************************
418 BasicHistogramImpl::BasicHistogramImpl()
419 : averager_(new BasicAverageHistogramModule())
424 BasicHistogramImpl::BasicHistogramImpl(const AnalysisHistogramSettings &settings)
425 : settings_(settings), averager_(new BasicAverageHistogramModule(settings))
430 BasicHistogramImpl::~BasicHistogramImpl()
435 void BasicHistogramImpl::init(const AnalysisHistogramSettings &settings)
437 settings_ = settings;
438 averager_->init(settings);
443 BasicHistogramImpl::initFrame(AnalysisDataStorageFrame *frame)
445 for (int i = 0; i < frame->columnCount(); ++i)
447 frame->setValue(i, 0.0);
451 } // namespace internal
454 /********************************************************************
455 * AnalysisDataSimpleHistogramModule
458 AnalysisDataSimpleHistogramModule::AnalysisDataSimpleHistogramModule()
459 : impl_(new internal::BasicHistogramImpl())
464 AnalysisDataSimpleHistogramModule::AnalysisDataSimpleHistogramModule(
465 const AnalysisHistogramSettings &settings)
466 : impl_(new internal::BasicHistogramImpl(settings))
471 AnalysisDataSimpleHistogramModule::~AnalysisDataSimpleHistogramModule()
476 void AnalysisDataSimpleHistogramModule::init(const AnalysisHistogramSettings &settings)
478 impl_->init(settings);
482 AbstractAverageHistogram &
483 AnalysisDataSimpleHistogramModule::averager()
485 return *impl_->averager_;
489 const AnalysisHistogramSettings &
490 AnalysisDataSimpleHistogramModule::settings() const
492 return impl_->settings_;
497 AnalysisDataSimpleHistogramModule::flags() const
499 return efAllowMulticolumn | efAllowMultipoint;
504 AnalysisDataSimpleHistogramModule::dataStarted(AbstractAnalysisData *data)
506 addModule(impl_->averager_);
507 setColumnCount(settings().binCount());
509 impl_->storage_.startDataStorage(this);
514 AnalysisDataSimpleHistogramModule::frameStarted(const AnalysisDataFrameHeader &header)
516 AnalysisDataStorageFrame &frame = impl_->storage_.startFrame(header);
517 impl_->initFrame(&frame);
522 AnalysisDataSimpleHistogramModule::pointsAdded(const AnalysisDataPointSetRef &points)
524 AnalysisDataStorageFrame &frame =
525 impl_->storage_.currentFrame(points.frameIndex());
526 for (int i = 0; i < points.columnCount(); ++i)
528 int bin = settings().findBin(points.y(i));
531 frame.value(bin) += 1;
538 AnalysisDataSimpleHistogramModule::frameFinished(const AnalysisDataFrameHeader &header)
540 impl_->storage_.finishFrame(header.index());
545 AnalysisDataSimpleHistogramModule::dataFinished()
552 AnalysisDataSimpleHistogramModule::tryGetDataFrameInternal(int index) const
554 return impl_->storage_.tryGetDataFrame(index);
559 AnalysisDataSimpleHistogramModule::requestStorageInternal(int nframes)
561 return impl_->storage_.requestStorage(nframes);
565 /********************************************************************
566 * AnalysisDataWeightedHistogramModule
569 AnalysisDataWeightedHistogramModule::AnalysisDataWeightedHistogramModule()
570 : impl_(new internal::BasicHistogramImpl())
575 AnalysisDataWeightedHistogramModule::AnalysisDataWeightedHistogramModule(
576 const AnalysisHistogramSettings &settings)
577 : impl_(new internal::BasicHistogramImpl(settings))
582 AnalysisDataWeightedHistogramModule::~AnalysisDataWeightedHistogramModule()
587 void AnalysisDataWeightedHistogramModule::init(const AnalysisHistogramSettings &settings)
589 impl_->init(settings);
593 AbstractAverageHistogram &
594 AnalysisDataWeightedHistogramModule::averager()
596 return *impl_->averager_;
600 const AnalysisHistogramSettings &
601 AnalysisDataWeightedHistogramModule::settings() const
603 return impl_->settings_;
608 AnalysisDataWeightedHistogramModule::flags() const
610 return efAllowMulticolumn | efAllowMultipoint;
615 AnalysisDataWeightedHistogramModule::dataStarted(AbstractAnalysisData *data)
617 addModule(impl_->averager_);
618 setColumnCount(settings().binCount());
620 impl_->storage_.startDataStorage(this);
625 AnalysisDataWeightedHistogramModule::frameStarted(const AnalysisDataFrameHeader &header)
627 AnalysisDataStorageFrame &frame = impl_->storage_.startFrame(header);
628 impl_->initFrame(&frame);
633 AnalysisDataWeightedHistogramModule::pointsAdded(const AnalysisDataPointSetRef &points)
635 if (points.firstColumn() != 0 || points.columnCount() < 2)
637 GMX_THROW(APIError("Invalid data layout"));
639 int bin = settings().findBin(points.y(0));
642 AnalysisDataStorageFrame &frame =
643 impl_->storage_.currentFrame(points.frameIndex());
644 for (int i = 1; i < points.columnCount(); ++i)
646 frame.value(bin) += points.y(i);
653 AnalysisDataWeightedHistogramModule::frameFinished(const AnalysisDataFrameHeader &header)
655 impl_->storage_.finishFrame(header.index());
660 AnalysisDataWeightedHistogramModule::dataFinished()
667 AnalysisDataWeightedHistogramModule::tryGetDataFrameInternal(int index) const
669 return impl_->storage_.tryGetDataFrame(index);
674 AnalysisDataWeightedHistogramModule::requestStorageInternal(int nframes)
676 return impl_->storage_.requestStorage(nframes);
680 /********************************************************************
681 * AnalysisDataBinAverageModule
684 AnalysisDataBinAverageModule::AnalysisDataBinAverageModule()
690 AnalysisDataBinAverageModule::AnalysisDataBinAverageModule(
691 const AnalysisHistogramSettings &settings)
692 : settings_(settings)
695 setRowCount(settings.binCount());
696 setXAxis(settings.firstEdge() + 0.5 * settings.binWidth(),
697 settings.binWidth());
701 AnalysisDataBinAverageModule::~AnalysisDataBinAverageModule()
707 AnalysisDataBinAverageModule::init(const AnalysisHistogramSettings &settings)
709 settings_ = settings;
710 setRowCount(settings.binCount());
711 setXAxis(settings.firstEdge() + 0.5 * settings.binWidth(),
712 settings.binWidth());
717 AnalysisDataBinAverageModule::flags() const
719 return efAllowMulticolumn | efAllowMultipoint;
724 AnalysisDataBinAverageModule::dataStarted(AbstractAnalysisData * /*data*/)
731 AnalysisDataBinAverageModule::frameStarted(const AnalysisDataFrameHeader & /*header*/)
737 AnalysisDataBinAverageModule::pointsAdded(const AnalysisDataPointSetRef &points)
739 if (points.firstColumn() != 0 || points.columnCount() < 2)
741 GMX_THROW(APIError("Invalid data layout"));
743 int bin = settings().findBin(points.y(0));
746 for (int i = 1; i < points.columnCount(); ++i)
748 real y = points.y(i);
750 value(bin, 1) += y * y;
752 value(bin, 2) += points.columnCount() - 1;
758 AnalysisDataBinAverageModule::frameFinished(const AnalysisDataFrameHeader & /*header*/)
764 AnalysisDataBinAverageModule::dataFinished()
766 for (int i = 0; i < settings().binCount(); ++i)
768 real n = value(i, 2);
771 real ave = value(i, 0) / n;
772 real std = sqrt(value(i, 1) / n - ave * ave);