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 //! Test fixture for gmx::AnalysisDataSimpleHistogramModule.
 145 typedef gmx::test::AnalysisDataTestFixture SimpleHistogramModuleTest;
 146
 147 using gmx::test::END_OF_FRAME;
 148 using gmx::test::MPSTOP;
 149 //! Input data for gmx::AnalysisDataSimpleHistogramModule tests.
 150 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 };
 155
 156 TEST_F(SimpleHistogramModuleTest, ComputesCorrectly)
 157 {
 158     gmx::test::AnalysisDataTestInput input(simpleinputdata);
 159     gmx::AnalysisData                data;
 160     data.setColumnCount(input.columnCount());
 161     data.setMultipoint(true);
 162     gmx::AnalysisDataSimpleHistogramModulePointer module(
 163             new gmx::AnalysisDataSimpleHistogramModule(
 164                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 165     data.addModule(module);
 166
 167     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 168     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 169     ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
 170     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
 171                                               &module->averager()));
 172     ASSERT_NO_THROW(presentAllData(input, &data));
 173     ASSERT_NO_THROW(module->averager().done());
 174 }
 175
 176
 177 TEST_F(SimpleHistogramModuleTest, ComputesCorrectlyWithAll)
 178 {
 179     gmx::test::AnalysisDataTestInput input(simpleinputdata);
 180     gmx::AnalysisData                data;
 181     data.setColumnCount(input.columnCount());
 182     data.setMultipoint(true);
 183     gmx::AnalysisDataSimpleHistogramModulePointer module(
 184             new gmx::AnalysisDataSimpleHistogramModule(
 185                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 186     data.addModule(module);
 187
 188     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 189     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 190     ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
 191     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
 192                                               &module->averager()));
 193     ASSERT_NO_THROW(presentAllData(input, &data));
 194     ASSERT_NO_THROW(module->averager().done());
 195 }
 196
 197
 198 /********************************************************************
 199  * Tests for gmx::AnalysisDataWeightedHistogramModule.
 200  */
 201
 202 //! Test fixture for gmx::AnalysisDataWeightedHistogramModule.
 203 typedef gmx::test::AnalysisDataTestFixture WeightedHistogramModuleTest;
 204
 205 //! Input data for both weighted histogram and bin average module tests.
 206 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 };
 211
 212 TEST_F(WeightedHistogramModuleTest, ComputesCorrectly)
 213 {
 214     gmx::test::AnalysisDataTestInput input(weightedinputdata);
 215     gmx::AnalysisData                data;
 216     data.setColumnCount(input.columnCount());
 217     data.setMultipoint(true);
 218     gmx::AnalysisDataWeightedHistogramModulePointer module(
 219             new gmx::AnalysisDataWeightedHistogramModule(
 220                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 221     data.addModule(module);
 222
 223     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 224     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 225     ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
 226     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
 227                                               &module->averager()));
 228     ASSERT_NO_THROW(presentAllData(input, &data));
 229     ASSERT_NO_THROW(module->averager().done());
 230 }
 231
 232
 233 TEST_F(WeightedHistogramModuleTest, ComputesCorrectlyWithAll)
 234 {
 235     gmx::test::AnalysisDataTestInput input(weightedinputdata);
 236     gmx::AnalysisData                data;
 237     data.setColumnCount(input.columnCount());
 238     data.setMultipoint(true);
 239     gmx::AnalysisDataWeightedHistogramModulePointer module(
 240             new gmx::AnalysisDataWeightedHistogramModule(
 241                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 242     data.addModule(module);
 243
 244     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 245     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 246     ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
 247     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
 248                                               &module->averager()));
 249     ASSERT_NO_THROW(presentAllData(input, &data));
 250     ASSERT_NO_THROW(module->averager().done());
 251 }
 252
 253
 254 /********************************************************************
 255  * Tests for gmx::AnalysisDataBinAverageModule.
 256  */
 257
 258 //! Test fixture for gmx::AnalysisDataBinAverageModule.
 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 //! Test fixture for gmx::AbstractAverageHistogram.
 305 typedef gmx::test::AnalysisDataTestFixture AbstractAverageHistogramTest;
 306
 307 //! Input data for gmx::AbstractAverageHistogram tests.
 308 const real averageinputdata[] = {
 309     1.0, 2.0, 1.0, END_OF_FRAME,
 310     1.5, 1.0, 1.0, END_OF_FRAME,
 311     2.0, 3.0, 2.0, END_OF_FRAME,
 312     2.5, 4.0, 2.0, END_OF_FRAME,
 313     3.0, 2.0, 1.0, END_OF_FRAME,
 314     3.5, 0.0, 3.0, END_OF_FRAME,
 315     4.0, 1.0, 3.0, END_OF_FRAME
 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         //! Creates a histogram module with defined bin parameters.
 329         explicit MockAverageHistogram(const gmx::AnalysisHistogramSettings &settings)
 330             : AbstractAverageHistogram(settings)
 331         {
 332         }
 333
 334         using AbstractAverageHistogram::init;
 335         using AbstractAverageHistogram::setColumnCount;
 336         using AbstractAverageHistogram::setRowCount;
 337         using AbstractAverageHistogram::allocateValues;
 338         using AbstractAverageHistogram::setValue;
 339 };
 340
 341
 342 TEST_F(AbstractAverageHistogramTest, ClonesCorrectly)
 343 {
 344     gmx::test::AnalysisDataTestInput input(averageinputdata);
 345     MockAverageHistogram             data(
 346             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 347     setupArrayData(input, &data);
 348
 349     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 350     gmx::AverageHistogramPointer copy(data.clone());
 351     ASSERT_NO_THROW(addStaticCheckerModule(input, copy.get()));
 352     ASSERT_NO_THROW(copy->done());
 353     ASSERT_NO_THROW(data.done());
 354     gmx::AverageHistogramPointer copy2(data.clone());
 355     ASSERT_NO_THROW(addStaticCheckerModule(input, copy2.get()));
 356     ASSERT_NO_THROW(copy2->done());
 357 }
 358
 359
 360 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidth)
 361 {
 362     gmx::test::AnalysisDataTestInput input(averageinputdata);
 363     MockAverageHistogram             data(
 364             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 365     setupArrayData(input, &data);
 366
 367     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 368     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 369     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(false));
 370     ASSERT_NO_THROW(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 371     ASSERT_NO_THROW(data.done());
 372     ASSERT_NO_THROW(resampled->done());
 373 }
 374
 375
 376 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidthWithIntegerBins)
 377 {
 378     gmx::test::AnalysisDataTestInput input(averageinputdata);
 379     MockAverageHistogram             data(
 380             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 381     setupArrayData(input, &data);
 382
 383     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 384     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 385     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(true));
 386     ASSERT_NO_THROW(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 387     ASSERT_NO_THROW(data.done());
 388     ASSERT_NO_THROW(resampled->done());
 389 }
 390
 391 } // namespace