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 "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.setColumns(input.columnCount(), 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.setColumns(input.columnCount(), true);
 182     gmx::AnalysisDataSimpleHistogramModulePointer module(
 183             new gmx::AnalysisDataSimpleHistogramModule(
 184                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 185     data.addModule(module);
 186
 187     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 188     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 189     ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
 190     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
 191                                               &module->averager()));
 192     ASSERT_NO_THROW(presentAllData(input, &data));
 193     ASSERT_NO_THROW(module->averager().done());
 194 }
 195
 196
 197 /********************************************************************
 198  * Tests for gmx::AnalysisDataWeightedHistogramModule.
 199  */
 200
 201 typedef gmx::test::AnalysisDataTestFixture WeightedHistogramModuleTest;
 202
 203 // Input data for the tests below (both weighted and bin average modules).
 204 static const real weightedinputdata[] = {
 205     1.0,  0.7, 0.5, MPSTOP, 1.1, 1.0, MPSTOP, 2.3, 1.0, MPSTOP, 2.9, 2.0, END_OF_FRAME,
 206     2.0,  1.3, 1.0, MPSTOP, 2.2, 3.0, END_OF_FRAME,
 207     3.0,  3.3, 0.5, MPSTOP, 1.2, 2.0, MPSTOP, 1.3, 1.0, END_OF_FRAME,
 208     END_OF_DATA
 209 };
 210
 211 TEST_F(WeightedHistogramModuleTest, ComputesCorrectly)
 212 {
 213     gmx::test::AnalysisDataTestInput input(weightedinputdata);
 214     gmx::AnalysisData data;
 215     data.setColumns(input.columnCount(), true);
 216     gmx::AnalysisDataWeightedHistogramModulePointer module(
 217         new gmx::AnalysisDataWeightedHistogramModule(
 218                 gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 219     data.addModule(module);
 220
 221     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 222     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 223     ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
 224     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
 225                                               &module->averager()));
 226     ASSERT_NO_THROW(presentAllData(input, &data));
 227     ASSERT_NO_THROW(module->averager().done());
 228 }
 229
 230
 231 TEST_F(WeightedHistogramModuleTest, ComputesCorrectlyWithAll)
 232 {
 233     gmx::test::AnalysisDataTestInput input(weightedinputdata);
 234     gmx::AnalysisData data;
 235     data.setColumns(input.columnCount(), true);
 236     gmx::AnalysisDataWeightedHistogramModulePointer module(
 237             new gmx::AnalysisDataWeightedHistogramModule(
 238                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 239     data.addModule(module);
 240
 241     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 242     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 243     ASSERT_NO_THROW(addReferenceCheckerModule("Histogram", module.get()));
 244     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage",
 245                                               &module->averager()));
 246     ASSERT_NO_THROW(presentAllData(input, &data));
 247     ASSERT_NO_THROW(module->averager().done());
 248 }
 249
 250
 251 /********************************************************************
 252  * Tests for gmx::AnalysisDataBinAverageModule.
 253  */
 254
 255 typedef gmx::test::AnalysisDataTestFixture BinAverageModuleTest;
 256
 257 TEST_F(BinAverageModuleTest, ComputesCorrectly)
 258 {
 259     gmx::test::AnalysisDataTestInput input(weightedinputdata);
 260     gmx::AnalysisData data;
 261     data.setColumns(input.columnCount(), true);
 262     gmx::AnalysisDataBinAverageModulePointer module(
 263         new gmx::AnalysisDataBinAverageModule(
 264                 gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 265     data.addModule(module);
 266
 267     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 268     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 269     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage", module.get()));
 270     ASSERT_NO_THROW(presentAllData(input, &data));
 271 }
 272
 273
 274 TEST_F(BinAverageModuleTest, ComputesCorrectlyWithAll)
 275 {
 276     gmx::test::AnalysisDataTestInput input(weightedinputdata);
 277     gmx::AnalysisData data;
 278     data.setColumns(input.columnCount(), true);
 279     gmx::AnalysisDataBinAverageModulePointer module(
 280             new gmx::AnalysisDataBinAverageModule(
 281                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 282     data.addModule(module);
 283
 284     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 285     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 286     ASSERT_NO_THROW(addReferenceCheckerModule("HistogramAverage", module.get()));
 287     ASSERT_NO_THROW(presentAllData(input, &data));
 288 }
 289
 290
 291 /********************************************************************
 292  * Tests for gmx::AbstractAverageHistogram.
 293  *
 294  * This class derives from gmx::AbstractAnalysisArrayData, and is tested using
 295  * corresponding facilities in gmx::test::AnalysisDataTestFixture.
 296  */
 297
 298 typedef gmx::test::AnalysisDataTestFixture AbstractAverageHistogramTest;
 299
 300 // Input data for average histogram tests.
 301 static const real averageinputdata[] = {
 302     1.0, 2.0, 1.0, END_OF_FRAME,
 303     1.5, 1.0, 1.0, END_OF_FRAME,
 304     2.0, 3.0, 2.0, END_OF_FRAME,
 305     2.5, 4.0, 2.0, END_OF_FRAME,
 306     3.0, 2.0, 1.0, END_OF_FRAME,
 307     3.5, 0.0, 3.0, END_OF_FRAME,
 308     4.0, 1.0, 3.0, END_OF_FRAME,
 309     END_OF_DATA
 310 };
 311
 312 /*! \internal \brief
 313  * Mock object for testing gmx::AbstractAverageHistogram.
 314  *
 315  * Exposes necessary methods from gmx::AbstractAverageHistogram to use with
 316  * gmx::test::AnalysisDataTestFixture::setupArrayData().
 317  */
 318 class MockAverageHistogram : public gmx::AbstractAverageHistogram
 319 {
 320     public:
 321         MockAverageHistogram() {}
 322         explicit MockAverageHistogram(const gmx::AnalysisHistogramSettings &settings)
 323             : AbstractAverageHistogram(settings)
 324         {
 325         }
 326
 327         using AbstractAverageHistogram::init;
 328         using AbstractAverageHistogram::setColumnCount;
 329         using AbstractAverageHistogram::setRowCount;
 330         using AbstractAverageHistogram::allocateValues;
 331         using AbstractAverageHistogram::setValue;
 332 };
 333
 334
 335 TEST_F(AbstractAverageHistogramTest, ClonesCorrectly)
 336 {
 337     gmx::test::AnalysisDataTestInput input(averageinputdata);
 338     MockAverageHistogram data(
 339             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 340     setupArrayData(input, &data);
 341
 342     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 343     gmx::AverageHistogramPointer copy(data.clone());
 344     ASSERT_NO_THROW(addStaticCheckerModule(input, copy.get()));
 345     ASSERT_NO_THROW(copy->done());
 346     ASSERT_NO_THROW(data.done());
 347     gmx::AverageHistogramPointer copy2(data.clone());
 348     ASSERT_NO_THROW(addStaticCheckerModule(input, copy2.get()));
 349     ASSERT_NO_THROW(copy2->done());
 350 }
 351
 352
 353 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidth)
 354 {
 355     gmx::test::AnalysisDataTestInput input(averageinputdata);
 356     MockAverageHistogram data(
 357             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 358     setupArrayData(input, &data);
 359
 360     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 361     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 362     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(false));
 363     ASSERT_NO_THROW(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 364     ASSERT_NO_THROW(data.done());
 365     ASSERT_NO_THROW(resampled->done());
 366 }
 367
 368
 369 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidthWithIntegerBins)
 370 {
 371     gmx::test::AnalysisDataTestInput input(averageinputdata);
 372     MockAverageHistogram data(
 373             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 374     setupArrayData(input, &data);
 375
 376     ASSERT_NO_THROW(addStaticCheckerModule(input, &data));
 377     ASSERT_NO_THROW(addReferenceCheckerModule("InputData", &data));
 378     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(true));
 379     ASSERT_NO_THROW(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 380     ASSERT_NO_THROW(data.done());
 381     ASSERT_NO_THROW(resampled->done());
 382 }
 383
 384 } // namespace