src/gromacs/analysisdata/tests/histogram.cpp

   1 /*
   2  *
   3  *                This source code is part of
   4  *
   5  *                 G   R   O   M   A   C   S
   6  *
   7  *          GROningen MAchine for Chemical Simulations
   8  *
   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.
  13
  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.
  18  *
  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.
  25  *
  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.
  28  *
  29  * For more info, check our website at http://www.gromacs.org
  30  */
  31 /*! \internal \file
  32  * \brief
  33  * Tests for functionality of analysis data histogram modules.
  34  *
  35  * These tests check that classes in histogram.h compute histograms correctly
  36  * with simple input data.  Also different ways of initializing the histograms
  37  * are tested.
  38  * Checking is done using gmx::test::AnalysisDataTestFixture and reference
  39  * data.  Also the input data is written to the reference data to catch
  40  * out-of-date reference.
  41  *
  42  * \author Teemu Murtola <teemu.murtola@cbr.su.se>
  43  * \ingroup module_analysisdata
  44  */
  45 #include <gtest/gtest.h>
  46
  47 #include "gromacs/analysisdata/analysisdata.h"
  48 #include "gromacs/analysisdata/modules/histogram.h"
  49
  50 #include "testutils/datatest.h"
  51
  52 namespace
  53 {
  54
  55 /********************************************************************
  56  * Tests for gmx::AnalysisHistogramSettings.
  57  *
  58  * These tests check that gmx::AnalysisHistogramSettings objects can be
  59  * initialized from various types of values, and that the bin positions are
  60  * computed correctly based on the input values.
  61  */
  62
  63 TEST(AnalysisHistogramSettingsTest, InitializesFromBins)
  64 {
  65     gmx::AnalysisHistogramSettings settings(
  66         gmx::histogramFromBins(1.0, 5, 0.5));
  67     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
  68     EXPECT_EQ(5, settings.binCount());
  69     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
  70     EXPECT_FLOAT_EQ(3.5, settings.lastEdge());
  71 }
  72
  73
  74 TEST(AnalysisHistogramSettingsTest, InitializesFromBinsWithIntegerBins)
  75 {
  76     gmx::AnalysisHistogramSettings settings(
  77         gmx::histogramFromBins(1.0, 5, 0.5).integerBins());
  78     EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
  79     EXPECT_EQ(5, settings.binCount());
  80     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
  81     EXPECT_FLOAT_EQ(3.25, settings.lastEdge());
  82 }
  83
  84
  85 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinCount)
  86 {
  87     gmx::AnalysisHistogramSettings settings(
  88         gmx::histogramFromRange(1.0, 4.0).binCount(6));
  89     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
  90     EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
  91     EXPECT_EQ(6, settings.binCount());
  92     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
  93 }
  94
  95
  96 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinWidth)
  97 {
  98     gmx::AnalysisHistogramSettings settings(
  99         gmx::histogramFromRange(1.0, 4.0).binWidth(0.5));
 100     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
 101     EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
 102     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 103     EXPECT_EQ(6, settings.binCount());
 104 }
 105
 106
 107 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinCountAndIntegerBins)
 108 {
 109     gmx::AnalysisHistogramSettings settings(
 110         gmx::histogramFromRange(1.0, 4.0).binCount(7).integerBins());
 111     EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
 112     EXPECT_FLOAT_EQ(4.25, settings.lastEdge());
 113     EXPECT_EQ(7, settings.binCount());
 114     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 115 }
 116
 117
 118 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinWidthAndIntegerBins)
 119 {
 120     gmx::AnalysisHistogramSettings settings(
 121         gmx::histogramFromRange(1.0, 4.0).binWidth(0.5).integerBins());
 122     EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
 123     EXPECT_FLOAT_EQ(4.25, settings.lastEdge());
 124     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 125     EXPECT_EQ(7, settings.binCount());
 126 }
 127
 128
 129 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithRoundedRange)
 130 {
 131     gmx::AnalysisHistogramSettings settings(
 132         gmx::histogramFromRange(1.2, 3.8).binWidth(0.5).roundRange());
 133     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
 134     EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
 135     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 136     EXPECT_EQ(6, settings.binCount());
 137 }
 138
 139
 140 /********************************************************************
 141  * Tests for gmx::AnalysisDataSimpleHistogramModule.
 142  */
 143
 144 typedef gmx::test::AnalysisDataTestFixture SimpleHistogramModuleTest;
 145
 146 // Input data for the tests below.
 147 using gmx::test::END_OF_DATA;
 148 using gmx::test::END_OF_FRAME;
 149 using gmx::test::MPSTOP;
 150 static const real simpleinputdata[] = {
 151     1.0,  0.7, MPSTOP, 1.1, MPSTOP, 2.3, MPSTOP, 2.9, END_OF_FRAME,
 152     2.0,  1.3, MPSTOP, 2.2, END_OF_FRAME,
 153     3.0,  3.3, MPSTOP, 1.2, MPSTOP, 1.3, END_OF_FRAME,
 154     END_OF_DATA
 155 };
 156
 157 TEST_F(SimpleHistogramModuleTest, ComputesCorrectly)
 158 {
 159     gmx::test::AnalysisDataTestInput input(simpleinputdata);
 160     gmx::AnalysisData data;
 161     data.setColumnCount(input.columnCount());
 162     data.setMultipoint(true);
 163     gmx::AnalysisDataSimpleHistogramModulePointer module(
 164         new gmx::AnalysisDataSimpleHistogramModule(
 165                 gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 166     data.addModule(module);
 167
 168     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 169     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 170     ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
 171     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
 172                                               &module->averager()));
 173     ASSERT_NO_THROW(presentAllData(input, &data));
 174     ASSERT_NO_THROW(module->averager().done());
 175 }
 176
 177
 178 TEST_F(SimpleHistogramModuleTest, ComputesCorrectlyWithAll)
 179 {
 180     gmx::test::AnalysisDataTestInput input(simpleinputdata);
 181     gmx::AnalysisData data;
 182     data.setColumnCount(input.columnCount());
 183     data.setMultipoint(true);
 184     gmx::AnalysisDataSimpleHistogramModulePointer module(
 185             new gmx::AnalysisDataSimpleHistogramModule(
 186                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 187     data.addModule(module);
 188
 189     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 190     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 191     ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
 192     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
 193                                               &module->averager()));
 194     ASSERT_NO_THROW(presentAllData(input, &data));
 195     ASSERT_NO_THROW(module->averager().done());
 196 }
 197
 198
 199 /********************************************************************
 200  * Tests for gmx::AnalysisDataWeightedHistogramModule.
 201  */
 202
 203 typedef gmx::test::AnalysisDataTestFixture WeightedHistogramModuleTest;
 204
 205 // Input data for the tests below (both weighted and bin average modules).
 206 static const real weightedinputdata[] = {
 207     1.0,  0.7, 0.5, MPSTOP, 1.1, 1.0, MPSTOP, 2.3, 1.0, MPSTOP, 2.9, 2.0, END_OF_FRAME,
 208     2.0,  1.3, 1.0, MPSTOP, 2.2, 3.0, END_OF_FRAME,
 209     3.0,  3.3, 0.5, MPSTOP, 1.2, 2.0, MPSTOP, 1.3, 1.0, END_OF_FRAME,
 210     END_OF_DATA
 211 };
 212
 213 TEST_F(WeightedHistogramModuleTest, ComputesCorrectly)
 214 {
 215     gmx::test::AnalysisDataTestInput input(weightedinputdata);
 216     gmx::AnalysisData data;
 217     data.setColumnCount(input.columnCount());
 218     data.setMultipoint(true);
 219     gmx::AnalysisDataWeightedHistogramModulePointer module(
 220         new gmx::AnalysisDataWeightedHistogramModule(
 221                 gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 222     data.addModule(module);
 223
 224     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 225     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 226     ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
 227     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
 228                                               &module->averager()));
 229     ASSERT_NO_THROW(presentAllData(input, &data));
 230     ASSERT_NO_THROW(module->averager().done());
 231 }
 232
 233
 234 TEST_F(WeightedHistogramModuleTest, ComputesCorrectlyWithAll)
 235 {
 236     gmx::test::AnalysisDataTestInput input(weightedinputdata);
 237     gmx::AnalysisData data;
 238     data.setColumnCount(input.columnCount());
 239     data.setMultipoint(true);
 240     gmx::AnalysisDataWeightedHistogramModulePointer module(
 241             new gmx::AnalysisDataWeightedHistogramModule(
 242                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 243     data.addModule(module);
 244
 245     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 246     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 247     ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
 248     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
 249                                               &module->averager()));
 250     ASSERT_NO_THROW(presentAllData(input, &data));
 251     ASSERT_NO_THROW(module->averager().done());
 252 }
 253
 254
 255 /********************************************************************
 256  * Tests for gmx::AnalysisDataBinAverageModule.
 257  */
 258
 259 typedef gmx::test::AnalysisDataTestFixture BinAverageModuleTest;
 260
 261 TEST_F(BinAverageModuleTest, ComputesCorrectly)
 262 {
 263     gmx::test::AnalysisDataTestInput input(weightedinputdata);
 264     gmx::AnalysisData data;
 265     data.setColumnCount(input.columnCount());
 266     data.setMultipoint(true);
 267     gmx::AnalysisDataBinAverageModulePointer module(
 268         new gmx::AnalysisDataBinAverageModule(
 269                 gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 270     data.addModule(module);
 271
 272     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 273     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 274     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage", module.get()));
 275     ASSERT_NO_THROW(presentAllData(input, &data));
 276 }
 277
 278
 279 TEST_F(BinAverageModuleTest, ComputesCorrectlyWithAll)
 280 {
 281     gmx::test::AnalysisDataTestInput input(weightedinputdata);
 282     gmx::AnalysisData data;
 283     data.setColumnCount(input.columnCount());
 284     data.setMultipoint(true);
 285     gmx::AnalysisDataBinAverageModulePointer module(
 286             new gmx::AnalysisDataBinAverageModule(
 287                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 288     data.addModule(module);
 289
 290     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 291     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 292     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage", module.get()));
 293     ASSERT_NO_THROW(presentAllData(input, &data));
 294 }
 295
 296
 297 /********************************************************************
 298  * Tests for gmx::AbstractAverageHistogram.
 299  *
 300  * This class derives from gmx::AbstractAnalysisArrayData, and is tested using
 301  * corresponding facilities in gmx::test::AnalysisDataTestFixture.
 302  */
 303
 304 typedef gmx::test::AnalysisDataTestFixture AbstractAverageHistogramTest;
 305
 306 // Input data for average histogram tests.
 307 static const real averageinputdata[] = {
 308     1.0, 2.0, 1.0, END_OF_FRAME,
 309     1.5, 1.0, 1.0, END_OF_FRAME,
 310     2.0, 3.0, 2.0, END_OF_FRAME,
 311     2.5, 4.0, 2.0, END_OF_FRAME,
 312     3.0, 2.0, 1.0, END_OF_FRAME,
 313     3.5, 0.0, 3.0, END_OF_FRAME,
 314     4.0, 1.0, 3.0, END_OF_FRAME,
 315     END_OF_DATA
 316 };
 317
 318 /*! \internal \brief
 319  * Mock object for testing gmx::AbstractAverageHistogram.
 320  *
 321  * Exposes necessary methods from gmx::AbstractAverageHistogram to use with
 322  * gmx::test::AnalysisDataTestFixture::setupArrayData().
 323  */
 324 class MockAverageHistogram : public gmx::AbstractAverageHistogram
 325 {
 326     public:
 327         MockAverageHistogram() {}
 328         explicit MockAverageHistogram(const gmx::AnalysisHistogramSettings &settings)
 329             : AbstractAverageHistogram(settings)
 330         {
 331         }
 332
 333         using AbstractAverageHistogram::init;
 334         using AbstractAverageHistogram::setColumnCount;
 335         using AbstractAverageHistogram::setRowCount;
 336         using AbstractAverageHistogram::allocateValues;
 337         using AbstractAverageHistogram::setValue;
 338 };
 339
 340
 341 TEST_F(AbstractAverageHistogramTest, ClonesCorrectly)
 342 {
 343     gmx::test::AnalysisDataTestInput input(averageinputdata);
 344     MockAverageHistogram data(
 345             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 346     setupArrayData(input, &data);
 347
 348     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 349     gmx::AverageHistogramPointer copy(data.clone());
 350     ASSERT_NO_THROW(addStaticCheckerModule(input, copy.get()));
 351     ASSERT_NO_THROW(copy->done());
 352     ASSERT_NO_THROW(data.done());
 353     gmx::AverageHistogramPointer copy2(data.clone());
 354     ASSERT_NO_THROW(addStaticCheckerModule(input, copy2.get()));
 355     ASSERT_NO_THROW(copy2->done());
 356 }
 357
 358
 359 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidth)
 360 {
 361     gmx::test::AnalysisDataTestInput input(averageinputdata);
 362     MockAverageHistogram data(
 363             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 364     setupArrayData(input, &data);
 365
 366     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 367     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 368     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(false));
 369     ASSERT_NO_THROW(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 370     ASSERT_NO_THROW(data.done());
 371     ASSERT_NO_THROW(resampled->done());
 372 }
 373
 374
 375 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidthWithIntegerBins)
 376 {
 377     gmx::test::AnalysisDataTestInput input(averageinputdata);
 378     MockAverageHistogram data(
 379             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 380     setupArrayData(input, &data);
 381
 382     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 383     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 384     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(true));
 385     ASSERT_NO_THROW(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 386     ASSERT_NO_THROW(data.done());
 387     ASSERT_NO_THROW(resampled->done());
 388 }
 389
 390 } // namespace