2 * This file is part of the GROMACS molecular simulation package.
4 * Copyright (c) 2012,2013,2014, by the GROMACS development team, led by
5 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
6 * and including many others, as listed in the AUTHORS file in the
7 * top-level source directory and at http://www.gromacs.org.
9 * GROMACS is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public License
11 * as published by the Free Software Foundation; either version 2.1
12 * of the License, or (at your option) any later version.
14 * GROMACS is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with GROMACS; if not, see
21 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 * If you want to redistribute modifications to GROMACS, please
25 * consider that scientific software is very special. Version
26 * control is crucial - bugs must be traceable. We will be happy to
27 * consider code for inclusion in the official distribution, but
28 * derived work must not be called official GROMACS. Details are found
29 * in the README & COPYING files - if they are missing, get the
30 * official version at http://www.gromacs.org.
32 * To help us fund GROMACS development, we humbly ask that you cite
33 * the research papers on the package. Check out http://www.gromacs.org.
37 * Tests for functionality of analysis data histogram modules.
39 * These tests check that classes in histogram.h compute histograms correctly
40 * with simple input data. Also different ways of initializing the histograms
42 * Checking is done using gmx::test::AnalysisDataTestFixture and reference
43 * data. Also the input data is written to the reference data to catch
44 * out-of-date reference.
46 * \author Teemu Murtola <teemu.murtola@gmail.com>
47 * \ingroup module_analysisdata
49 #include <gtest/gtest.h>
51 #include "gromacs/analysisdata/analysisdata.h"
52 #include "gromacs/analysisdata/modules/histogram.h"
54 #include "gromacs/analysisdata/tests/datatest.h"
55 #include "testutils/testasserts.h"
57 using gmx::test::AnalysisDataTestInput;
62 /********************************************************************
63 * Tests for gmx::AnalysisHistogramSettings.
65 * These tests check that gmx::AnalysisHistogramSettings objects can be
66 * initialized from various types of values, and that the bin positions are
67 * computed correctly based on the input values.
70 TEST(AnalysisHistogramSettingsTest, InitializesFromBins)
72 gmx::AnalysisHistogramSettings settings(
73 gmx::histogramFromBins(1.0, 5, 0.5));
74 EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
75 EXPECT_EQ(5, settings.binCount());
76 EXPECT_FLOAT_EQ(0.5, settings.binWidth());
77 EXPECT_FLOAT_EQ(3.5, settings.lastEdge());
81 TEST(AnalysisHistogramSettingsTest, InitializesFromBinsWithIntegerBins)
83 gmx::AnalysisHistogramSettings settings(
84 gmx::histogramFromBins(1.0, 5, 0.5).integerBins());
85 EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
86 EXPECT_EQ(5, settings.binCount());
87 EXPECT_FLOAT_EQ(0.5, settings.binWidth());
88 EXPECT_FLOAT_EQ(3.25, settings.lastEdge());
92 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinCount)
94 gmx::AnalysisHistogramSettings settings(
95 gmx::histogramFromRange(1.0, 4.0).binCount(6));
96 EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
97 EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
98 EXPECT_EQ(6, settings.binCount());
99 EXPECT_FLOAT_EQ(0.5, settings.binWidth());
103 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinWidth)
105 gmx::AnalysisHistogramSettings settings(
106 gmx::histogramFromRange(1.0, 4.0).binWidth(0.5));
107 EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
108 EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
109 EXPECT_FLOAT_EQ(0.5, settings.binWidth());
110 EXPECT_EQ(6, settings.binCount());
114 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinCountAndIntegerBins)
116 gmx::AnalysisHistogramSettings settings(
117 gmx::histogramFromRange(1.0, 4.0).binCount(7).integerBins());
118 EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
119 EXPECT_FLOAT_EQ(4.25, settings.lastEdge());
120 EXPECT_EQ(7, settings.binCount());
121 EXPECT_FLOAT_EQ(0.5, settings.binWidth());
125 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinWidthAndIntegerBins)
127 gmx::AnalysisHistogramSettings settings(
128 gmx::histogramFromRange(1.0, 4.0).binWidth(0.5).integerBins());
129 EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
130 EXPECT_FLOAT_EQ(4.25, settings.lastEdge());
131 EXPECT_FLOAT_EQ(0.5, settings.binWidth());
132 EXPECT_EQ(7, settings.binCount());
136 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithRoundedRange)
138 gmx::AnalysisHistogramSettings settings(
139 gmx::histogramFromRange(1.2, 3.8).binWidth(0.5).roundRange());
140 EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
141 EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
142 EXPECT_FLOAT_EQ(0.5, settings.binWidth());
143 EXPECT_EQ(6, settings.binCount());
147 /********************************************************************
148 * Tests for gmx::AnalysisDataSimpleHistogramModule.
151 //! Test fixture for gmx::AnalysisDataSimpleHistogramModule.
152 typedef gmx::test::AnalysisDataTestFixture SimpleHistogramModuleTest;
154 // Input data for gmx::AnalysisDataSimpleHistogramModule tests.
155 class SimpleInputData
158 static const AnalysisDataTestInput &get()
160 #ifndef INTEL_STATIC_ANON_NAMESPACE_BUG
161 static SimpleInputData singleton;
162 return singleton.data_;
164 static SimpleInputData singleton_histogram;
165 return singleton_histogram.data_;
169 SimpleInputData() : data_(1, true)
171 using gmx::test::AnalysisDataTestInputFrame;
172 data_.setColumnCount(0, 1);
173 AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
174 frame1.addPointSetWithValues(0, 0, 0.7);
175 frame1.addPointSetWithValues(0, 0, 1.1);
176 frame1.addPointSetWithValues(0, 0, 2.3);
177 frame1.addPointSetWithValues(0, 0, 2.9);
178 AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
179 frame2.addPointSetWithValues(0, 0, 1.3);
180 frame2.addPointSetWithValues(0, 0, 2.2);
181 AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
182 frame3.addPointSetWithValues(0, 0, 3.3);
183 frame3.addPointSetWithValues(0, 0, 1.2);
184 frame3.addPointSetWithValues(0, 0, 1.3);
188 AnalysisDataTestInput data_;
191 TEST_F(SimpleHistogramModuleTest, ComputesCorrectly)
193 const AnalysisDataTestInput &input = SimpleInputData::get();
194 gmx::AnalysisData data;
195 ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
197 gmx::AnalysisDataSimpleHistogramModulePointer module(
198 new gmx::AnalysisDataSimpleHistogramModule(
199 gmx::histogramFromRange(1.0, 3.0).binCount(4)));
200 data.addModule(module);
202 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
203 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
204 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
205 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
206 &module->averager()));
207 ASSERT_NO_THROW_GMX(presentAllData(input, &data));
208 ASSERT_NO_THROW_GMX(module->averager().done());
212 TEST_F(SimpleHistogramModuleTest, ComputesCorrectlyWithAll)
214 const AnalysisDataTestInput &input = SimpleInputData::get();
215 gmx::AnalysisData data;
216 ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
218 gmx::AnalysisDataSimpleHistogramModulePointer module(
219 new gmx::AnalysisDataSimpleHistogramModule(
220 gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
221 data.addModule(module);
223 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
224 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
225 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
226 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
227 &module->averager()));
228 ASSERT_NO_THROW_GMX(presentAllData(input, &data));
229 ASSERT_NO_THROW_GMX(module->averager().done());
233 /********************************************************************
234 * Tests for gmx::AnalysisDataWeightedHistogramModule.
237 //! Test fixture for gmx::AnalysisDataWeightedHistogramModule.
238 typedef gmx::test::AnalysisDataTestFixture WeightedHistogramModuleTest;
240 // Input data for both weighted histogram and bin average module tests.
241 class WeightedSimpleInputData
244 static const AnalysisDataTestInput &get()
246 #ifndef INTEL_STATIC_ANON_NAMESPACE_BUG
247 static WeightedSimpleInputData singleton;
248 return singleton.data_;
250 static WeightedSimpleInputData singleton_histogram;
251 return singleton_histogram.data_;
255 WeightedSimpleInputData() : data_(1, true)
257 using gmx::test::AnalysisDataTestInputFrame;
258 data_.setColumnCount(0, 2);
259 AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
260 frame1.addPointSetWithValues(0, 0, 0.7, 0.5);
261 frame1.addPointSetWithValues(0, 0, 1.1, 1.0);
262 frame1.addPointSetWithValues(0, 0, 2.3, 1.0);
263 frame1.addPointSetWithValues(0, 0, 2.9, 2.0);
264 AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
265 frame2.addPointSetWithValues(0, 0, 1.3, 1.0);
266 frame2.addPointSetWithValues(0, 0, 2.2, 3.0);
267 AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
268 frame3.addPointSetWithValues(0, 0, 3.3, 0.5);
269 frame3.addPointSetWithValues(0, 0, 1.2, 2.0);
270 frame3.addPointSetWithValues(0, 0, 1.3, 1.0);
274 AnalysisDataTestInput data_;
277 // Input data for both weighted histogram and bin average module tests.
278 class WeightedDataSetInputData
281 static const AnalysisDataTestInput &get()
283 #ifndef INTEL_STATIC_ANON_NAMESPACE_BUG
284 static WeightedDataSetInputData singleton;
285 return singleton.data_;
287 static WeightedDataSetInputData singleton_histogram;
288 return singleton_histogram.data_;
292 WeightedDataSetInputData() : data_(2, true)
294 using gmx::test::AnalysisDataTestInputFrame;
295 data_.setColumnCount(0, 2);
296 data_.setColumnCount(1, 2);
297 AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
298 frame1.addPointSetWithValues(0, 0, 0.7, 0.5);
299 frame1.addPointSetWithValues(0, 0, 1.1, 1.0);
300 frame1.addPointSetWithValues(1, 0, 2.3, 1.0);
301 frame1.addPointSetWithValues(1, 0, 2.9, 2.0);
302 AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
303 frame2.addPointSetWithValues(0, 0, 1.3, 1.0);
304 frame2.addPointSetWithValues(1, 0, 2.2, 3.0);
305 AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
306 frame3.addPointSetWithValues(0, 0, 3.3, 0.5);
307 frame3.addPointSetWithValues(0, 0, 1.2, 2.0);
308 frame3.addPointSetWithValues(1, 0, 1.3, 1.0);
312 AnalysisDataTestInput data_;
315 TEST_F(WeightedHistogramModuleTest, ComputesCorrectly)
317 const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
318 gmx::AnalysisData data;
319 ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
321 gmx::AnalysisDataWeightedHistogramModulePointer module(
322 new gmx::AnalysisDataWeightedHistogramModule(
323 gmx::histogramFromRange(1.0, 3.0).binCount(4)));
324 data.addModule(module);
326 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
327 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
328 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
329 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
330 &module->averager()));
331 ASSERT_NO_THROW_GMX(presentAllData(input, &data));
332 ASSERT_NO_THROW_GMX(module->averager().done());
336 TEST_F(WeightedHistogramModuleTest, ComputesCorrectlyWithAll)
338 const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
339 gmx::AnalysisData data;
340 ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
342 gmx::AnalysisDataWeightedHistogramModulePointer module(
343 new gmx::AnalysisDataWeightedHistogramModule(
344 gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
345 data.addModule(module);
347 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
348 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
349 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
350 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
351 &module->averager()));
352 ASSERT_NO_THROW_GMX(presentAllData(input, &data));
353 ASSERT_NO_THROW_GMX(module->averager().done());
357 TEST_F(WeightedHistogramModuleTest, HandlesMultipleDataSets)
359 const AnalysisDataTestInput &input = WeightedDataSetInputData::get();
360 gmx::AnalysisData data;
361 ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
363 gmx::AnalysisDataWeightedHistogramModulePointer module(
364 new gmx::AnalysisDataWeightedHistogramModule(
365 gmx::histogramFromRange(1.0, 3.0).binCount(4)));
366 data.addModule(module);
368 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
369 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
370 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
371 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
372 &module->averager()));
373 ASSERT_NO_THROW_GMX(presentAllData(input, &data));
374 ASSERT_NO_THROW_GMX(module->averager().done());
378 /********************************************************************
379 * Tests for gmx::AnalysisDataBinAverageModule.
382 //! Test fixture for gmx::AnalysisDataBinAverageModule.
383 typedef gmx::test::AnalysisDataTestFixture BinAverageModuleTest;
385 TEST_F(BinAverageModuleTest, ComputesCorrectly)
387 const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
388 gmx::AnalysisData data;
389 ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
391 gmx::AnalysisDataBinAverageModulePointer module(
392 new gmx::AnalysisDataBinAverageModule(
393 gmx::histogramFromRange(1.0, 3.0).binCount(4)));
394 data.addModule(module);
396 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
397 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
398 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
399 ASSERT_NO_THROW_GMX(presentAllData(input, &data));
403 TEST_F(BinAverageModuleTest, ComputesCorrectlyWithAll)
405 const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
406 gmx::AnalysisData data;
407 ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
409 gmx::AnalysisDataBinAverageModulePointer module(
410 new gmx::AnalysisDataBinAverageModule(
411 gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
412 data.addModule(module);
414 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
415 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
416 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
417 ASSERT_NO_THROW_GMX(presentAllData(input, &data));
421 TEST_F(BinAverageModuleTest, HandlesMultipleDataSets)
423 const AnalysisDataTestInput &input = WeightedDataSetInputData::get();
424 gmx::AnalysisData data;
425 ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
427 gmx::AnalysisDataBinAverageModulePointer module(
428 new gmx::AnalysisDataBinAverageModule(
429 gmx::histogramFromRange(1.0, 3.0).binCount(4)));
430 data.addModule(module);
432 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
433 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
434 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
435 ASSERT_NO_THROW_GMX(presentAllData(input, &data));
439 /********************************************************************
440 * Tests for gmx::AbstractAverageHistogram.
442 * This class derives from gmx::AbstractAnalysisArrayData, and is tested using
443 * corresponding facilities in gmx::test::AnalysisDataTestFixture.
446 //! Test fixture for gmx::AbstractAverageHistogram.
447 typedef gmx::test::AnalysisDataTestFixture AbstractAverageHistogramTest;
449 // Input data for gmx::AbstractAverageHistogram tests.
450 class AverageInputData
453 static const AnalysisDataTestInput &get()
455 #ifndef INTEL_STATIC_ANON_NAMESPACE_BUG
456 static AverageInputData singleton;
457 return singleton.data_;
459 static AverageInputData singleton_histogram;
460 return singleton_histogram.data_;
464 AverageInputData() : data_(1, false)
466 data_.setColumnCount(0, 1);
467 data_.addFrameWithValueAndError(1.0, 2.0, 1.0);
468 data_.addFrameWithValueAndError(1.5, 1.0, 1.0);
469 data_.addFrameWithValueAndError(2.0, 3.0, 2.0);
470 data_.addFrameWithValueAndError(2.5, 4.0, 2.0);
471 data_.addFrameWithValueAndError(3.0, 2.0, 1.0);
472 data_.addFrameWithValueAndError(3.5, 0.0, 3.0);
473 data_.addFrameWithValueAndError(4.0, 1.0, 3.0);
477 AnalysisDataTestInput data_;
481 * Mock object for testing gmx::AbstractAverageHistogram.
483 * Exposes necessary methods from gmx::AbstractAverageHistogram to use with
484 * gmx::test::AnalysisDataTestFixture::setupArrayData().
486 * \ingroup module_analysisdata
488 class MockAverageHistogram : public gmx::AbstractAverageHistogram
491 //! Creates a histogram module with defined bin parameters.
492 explicit MockAverageHistogram(const gmx::AnalysisHistogramSettings &settings)
493 : AbstractAverageHistogram(settings)
497 using AbstractAverageHistogram::init;
498 using AbstractAverageHistogram::setColumnCount;
499 using AbstractAverageHistogram::setRowCount;
500 using AbstractAverageHistogram::allocateValues;
501 using AbstractAverageHistogram::value;
505 TEST_F(AbstractAverageHistogramTest, ClonesCorrectly)
507 const AnalysisDataTestInput &input = AverageInputData::get();
508 MockAverageHistogram data(
509 gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
510 setupArrayData(input, &data);
512 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
513 gmx::AverageHistogramPointer copy(data.clone());
514 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy.get()));
515 ASSERT_NO_THROW_GMX(copy->done());
516 ASSERT_NO_THROW_GMX(data.done());
517 gmx::AverageHistogramPointer copy2(data.clone());
518 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy2.get()));
519 ASSERT_NO_THROW_GMX(copy2->done());
523 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidth)
525 const AnalysisDataTestInput &input = AverageInputData::get();
526 MockAverageHistogram data(
527 gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
528 setupArrayData(input, &data);
530 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
531 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
532 gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(false));
533 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
534 ASSERT_NO_THROW_GMX(data.done());
535 ASSERT_NO_THROW_GMX(resampled->done());
539 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidthWithIntegerBins)
541 const AnalysisDataTestInput &input = AverageInputData::get();
542 MockAverageHistogram data(
543 gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
544 setupArrayData(input, &data);
546 ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
547 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
548 gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(true));
549 ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
550 ASSERT_NO_THROW_GMX(data.done());
551 ASSERT_NO_THROW_GMX(resampled->done());