src/gromacs/analysisdata/tests/histogram.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2012,2013, by the GROMACS development team, led by
   5  * David van der Spoel, Berk Hess, Erik Lindahl, and including many
   6  * others, as listed in the AUTHORS file in the top-level source
   7  * directory and at http://www.gromacs.org.
   8  *
   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.
  13  *
  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.
  18  *
  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.
  23  *
  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.
  31  *
  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.
  34  */
  35 /*! \internal \file
  36  * \brief
  37  * Tests for functionality of analysis data histogram modules.
  38  *
  39  * These tests check that classes in histogram.h compute histograms correctly
  40  * with simple input data.  Also different ways of initializing the histograms
  41  * are tested.
  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.
  45  *
  46  * \author Teemu Murtola <teemu.murtola@gmail.com>
  47  * \ingroup module_analysisdata
  48  */
  49 #include <gtest/gtest.h>
  50
  51 #include "gromacs/analysisdata/analysisdata.h"
  52 #include "gromacs/analysisdata/modules/histogram.h"
  53
  54 #include "testutils/datatest.h"
  55 #include "testutils/testasserts.h"
  56
  57 using gmx::test::AnalysisDataTestInput;
  58
  59 namespace
  60 {
  61
  62 /********************************************************************
  63  * Tests for gmx::AnalysisHistogramSettings.
  64  *
  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.
  68  */
  69
  70 TEST(AnalysisHistogramSettingsTest, InitializesFromBins)
  71 {
  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());
  78 }
  79
  80
  81 TEST(AnalysisHistogramSettingsTest, InitializesFromBinsWithIntegerBins)
  82 {
  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());
  89 }
  90
  91
  92 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinCount)
  93 {
  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());
 100 }
 101
 102
 103 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinWidth)
 104 {
 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());
 111 }
 112
 113
 114 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinCountAndIntegerBins)
 115 {
 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());
 122 }
 123
 124
 125 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinWidthAndIntegerBins)
 126 {
 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());
 133 }
 134
 135
 136 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithRoundedRange)
 137 {
 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());
 144 }
 145
 146
 147 /********************************************************************
 148  * Tests for gmx::AnalysisDataSimpleHistogramModule.
 149  */
 150
 151 //! Test fixture for gmx::AnalysisDataSimpleHistogramModule.
 152 typedef gmx::test::AnalysisDataTestFixture SimpleHistogramModuleTest;
 153
 154 // Input data for gmx::AnalysisDataSimpleHistogramModule tests.
 155 class SimpleInputData
 156 {
 157     public:
 158         static const AnalysisDataTestInput &get()
 159         {
 160             static SimpleInputData singleton;
 161             return singleton.data_;
 162         }
 163
 164         SimpleInputData() : data_(1, true)
 165         {
 166             using gmx::test::AnalysisDataTestInputFrame;
 167             AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
 168             frame1.addPointSetWithValues(0, 0.7);
 169             frame1.addPointSetWithValues(0, 1.1);
 170             frame1.addPointSetWithValues(0, 2.3);
 171             frame1.addPointSetWithValues(0, 2.9);
 172             AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
 173             frame2.addPointSetWithValues(0, 1.3);
 174             frame2.addPointSetWithValues(0, 2.2);
 175             AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
 176             frame3.addPointSetWithValues(0, 3.3);
 177             frame3.addPointSetWithValues(0, 1.2);
 178             frame3.addPointSetWithValues(0, 1.3);
 179         }
 180
 181     private:
 182         AnalysisDataTestInput  data_;
 183 };
 184
 185 TEST_F(SimpleHistogramModuleTest, ComputesCorrectly)
 186 {
 187     const AnalysisDataTestInput &input = SimpleInputData::get();
 188     gmx::AnalysisData            data;
 189     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 190
 191     gmx::AnalysisDataSimpleHistogramModulePointer module(
 192             new gmx::AnalysisDataSimpleHistogramModule(
 193                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 194     data.addModule(module);
 195
 196     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 197     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 198     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 199     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 200                                                   &module->averager()));
 201     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 202     ASSERT_NO_THROW_GMX(module->averager().done());
 203 }
 204
 205
 206 TEST_F(SimpleHistogramModuleTest, ComputesCorrectlyWithAll)
 207 {
 208     const AnalysisDataTestInput &input = SimpleInputData::get();
 209     gmx::AnalysisData            data;
 210     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 211
 212     gmx::AnalysisDataSimpleHistogramModulePointer module(
 213             new gmx::AnalysisDataSimpleHistogramModule(
 214                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 215     data.addModule(module);
 216
 217     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 218     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 219     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 220     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 221                                                   &module->averager()));
 222     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 223     ASSERT_NO_THROW_GMX(module->averager().done());
 224 }
 225
 226
 227 /********************************************************************
 228  * Tests for gmx::AnalysisDataWeightedHistogramModule.
 229  */
 230
 231 //! Test fixture for gmx::AnalysisDataWeightedHistogramModule.
 232 typedef gmx::test::AnalysisDataTestFixture WeightedHistogramModuleTest;
 233
 234 // Input data for both weighted histogram and bin average module tests.
 235 class WeightedInputData
 236 {
 237     public:
 238         static const AnalysisDataTestInput &get()
 239         {
 240             static WeightedInputData singleton;
 241             return singleton.data_;
 242         }
 243
 244         WeightedInputData() : data_(2, true)
 245         {
 246             using gmx::test::AnalysisDataTestInputFrame;
 247             AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
 248             frame1.addPointSetWithValues(0, 0.7, 0.5);
 249             frame1.addPointSetWithValues(0, 1.1, 1.0);
 250             frame1.addPointSetWithValues(0, 2.3, 1.0);
 251             frame1.addPointSetWithValues(0, 2.9, 2.0);
 252             AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
 253             frame2.addPointSetWithValues(0, 1.3, 1.0);
 254             frame2.addPointSetWithValues(0, 2.2, 3.0);
 255             AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
 256             frame3.addPointSetWithValues(0, 3.3, 0.5);
 257             frame3.addPointSetWithValues(0, 1.2, 2.0);
 258             frame3.addPointSetWithValues(0, 1.3, 1.0);
 259         }
 260
 261     private:
 262         AnalysisDataTestInput  data_;
 263 };
 264
 265 TEST_F(WeightedHistogramModuleTest, ComputesCorrectly)
 266 {
 267     const AnalysisDataTestInput &input = WeightedInputData::get();
 268     gmx::AnalysisData            data;
 269     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 270
 271     gmx::AnalysisDataWeightedHistogramModulePointer module(
 272             new gmx::AnalysisDataWeightedHistogramModule(
 273                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 274     data.addModule(module);
 275
 276     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 277     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 278     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 279     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 280                                                   &module->averager()));
 281     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 282     ASSERT_NO_THROW_GMX(module->averager().done());
 283 }
 284
 285
 286 TEST_F(WeightedHistogramModuleTest, ComputesCorrectlyWithAll)
 287 {
 288     const AnalysisDataTestInput &input = WeightedInputData::get();
 289     gmx::AnalysisData            data;
 290     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 291
 292     gmx::AnalysisDataWeightedHistogramModulePointer module(
 293             new gmx::AnalysisDataWeightedHistogramModule(
 294                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 295     data.addModule(module);
 296
 297     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 298     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 299     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 300     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 301                                                   &module->averager()));
 302     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 303     ASSERT_NO_THROW_GMX(module->averager().done());
 304 }
 305
 306
 307 /********************************************************************
 308  * Tests for gmx::AnalysisDataBinAverageModule.
 309  */
 310
 311 //! Test fixture for gmx::AnalysisDataBinAverageModule.
 312 typedef gmx::test::AnalysisDataTestFixture BinAverageModuleTest;
 313
 314 TEST_F(BinAverageModuleTest, ComputesCorrectly)
 315 {
 316     const AnalysisDataTestInput &input = WeightedInputData::get();
 317     gmx::AnalysisData            data;
 318     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 319
 320     gmx::AnalysisDataBinAverageModulePointer module(
 321             new gmx::AnalysisDataBinAverageModule(
 322                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 323     data.addModule(module);
 324
 325     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 326     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 327     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
 328     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 329 }
 330
 331
 332 TEST_F(BinAverageModuleTest, ComputesCorrectlyWithAll)
 333 {
 334     const AnalysisDataTestInput &input = WeightedInputData::get();
 335     gmx::AnalysisData            data;
 336     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 337
 338     gmx::AnalysisDataBinAverageModulePointer module(
 339             new gmx::AnalysisDataBinAverageModule(
 340                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 341     data.addModule(module);
 342
 343     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 344     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 345     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
 346     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 347 }
 348
 349
 350 /********************************************************************
 351  * Tests for gmx::AbstractAverageHistogram.
 352  *
 353  * This class derives from gmx::AbstractAnalysisArrayData, and is tested using
 354  * corresponding facilities in gmx::test::AnalysisDataTestFixture.
 355  */
 356
 357 //! Test fixture for gmx::AbstractAverageHistogram.
 358 typedef gmx::test::AnalysisDataTestFixture AbstractAverageHistogramTest;
 359
 360 // Input data for gmx::AbstractAverageHistogram tests.
 361 class AverageInputData
 362 {
 363     public:
 364         static const AnalysisDataTestInput &get()
 365         {
 366             static AverageInputData singleton;
 367             return singleton.data_;
 368         }
 369
 370         AverageInputData() : data_(2, false)
 371         {
 372             data_.addFrameWithValues(1.0,  2.0, 1.0);
 373             data_.addFrameWithValues(1.5,  1.0, 1.0);
 374             data_.addFrameWithValues(2.0,  3.0, 2.0);
 375             data_.addFrameWithValues(2.5,  4.0, 2.0);
 376             data_.addFrameWithValues(3.0,  2.0, 1.0);
 377             data_.addFrameWithValues(3.5,  0.0, 3.0);
 378             data_.addFrameWithValues(4.0,  1.0, 3.0);
 379         }
 380
 381     private:
 382         AnalysisDataTestInput  data_;
 383 };
 384
 385 /*! \internal \brief
 386  * Mock object for testing gmx::AbstractAverageHistogram.
 387  *
 388  * Exposes necessary methods from gmx::AbstractAverageHistogram to use with
 389  * gmx::test::AnalysisDataTestFixture::setupArrayData().
 390  */
 391 class MockAverageHistogram : public gmx::AbstractAverageHistogram
 392 {
 393     public:
 394         MockAverageHistogram() {}
 395         //! Creates a histogram module with defined bin parameters.
 396         explicit MockAverageHistogram(const gmx::AnalysisHistogramSettings &settings)
 397             : AbstractAverageHistogram(settings)
 398         {
 399         }
 400
 401         using AbstractAverageHistogram::init;
 402         using AbstractAverageHistogram::setColumnCount;
 403         using AbstractAverageHistogram::setRowCount;
 404         using AbstractAverageHistogram::allocateValues;
 405         using AbstractAverageHistogram::setValue;
 406 };
 407
 408
 409 TEST_F(AbstractAverageHistogramTest, ClonesCorrectly)
 410 {
 411     const AnalysisDataTestInput &input = AverageInputData::get();
 412     MockAverageHistogram         data(
 413             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 414     setupArrayData(input, &data);
 415
 416     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 417     gmx::AverageHistogramPointer copy(data.clone());
 418     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy.get()));
 419     ASSERT_NO_THROW_GMX(copy->done());
 420     ASSERT_NO_THROW_GMX(data.done());
 421     gmx::AverageHistogramPointer copy2(data.clone());
 422     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy2.get()));
 423     ASSERT_NO_THROW_GMX(copy2->done());
 424 }
 425
 426
 427 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidth)
 428 {
 429     const AnalysisDataTestInput &input = AverageInputData::get();
 430     MockAverageHistogram         data(
 431             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 432     setupArrayData(input, &data);
 433
 434     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 435     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 436     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(false));
 437     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 438     ASSERT_NO_THROW_GMX(data.done());
 439     ASSERT_NO_THROW_GMX(resampled->done());
 440 }
 441
 442
 443 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidthWithIntegerBins)
 444 {
 445     const AnalysisDataTestInput &input = AverageInputData::get();
 446     MockAverageHistogram         data(
 447             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 448     setupArrayData(input, &data);
 449
 450     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 451     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 452     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(true));
 453     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 454     ASSERT_NO_THROW_GMX(data.done());
 455     ASSERT_NO_THROW_GMX(resampled->done());
 456 }
 457
 458 } // namespace