src/gromacs/analysisdata/tests/histogram.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   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.
   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 "gmxpre.h"
  50
  51 #include "gromacs/analysisdata/modules/histogram.h"
  52
  53 #include <gtest/gtest.h>
  54
  55 #include "gromacs/analysisdata/analysisdata.h"
  56
  57 #include "gromacs/analysisdata/tests/datatest.h"
  58 #include "testutils/testasserts.h"
  59
  60 using gmx::test::AnalysisDataTestInput;
  61
  62 namespace
  63 {
  64
  65 /********************************************************************
  66  * Tests for gmx::AnalysisHistogramSettings.
  67  *
  68  * These tests check that gmx::AnalysisHistogramSettings objects can be
  69  * initialized from various types of values, and that the bin positions are
  70  * computed correctly based on the input values.
  71  */
  72
  73 TEST(AnalysisHistogramSettingsTest, InitializesFromBins)
  74 {
  75     gmx::AnalysisHistogramSettings settings(
  76             gmx::histogramFromBins(1.0, 5, 0.5));
  77     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
  78     EXPECT_EQ(5, settings.binCount());
  79     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
  80     EXPECT_FLOAT_EQ(3.5, settings.lastEdge());
  81 }
  82
  83
  84 TEST(AnalysisHistogramSettingsTest, InitializesFromBinsWithIntegerBins)
  85 {
  86     gmx::AnalysisHistogramSettings settings(
  87             gmx::histogramFromBins(1.0, 5, 0.5).integerBins());
  88     EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
  89     EXPECT_EQ(5, settings.binCount());
  90     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
  91     EXPECT_FLOAT_EQ(3.25, settings.lastEdge());
  92 }
  93
  94
  95 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinCount)
  96 {
  97     gmx::AnalysisHistogramSettings settings(
  98             gmx::histogramFromRange(1.0, 4.0).binCount(6));
  99     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
 100     EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
 101     EXPECT_EQ(6, settings.binCount());
 102     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 103 }
 104
 105
 106 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinWidth)
 107 {
 108     gmx::AnalysisHistogramSettings settings(
 109             gmx::histogramFromRange(1.0, 4.0).binWidth(0.5));
 110     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
 111     EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
 112     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 113     EXPECT_EQ(6, settings.binCount());
 114 }
 115
 116
 117 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinCountAndIntegerBins)
 118 {
 119     gmx::AnalysisHistogramSettings settings(
 120             gmx::histogramFromRange(1.0, 4.0).binCount(7).integerBins());
 121     EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
 122     EXPECT_FLOAT_EQ(4.25, settings.lastEdge());
 123     EXPECT_EQ(7, settings.binCount());
 124     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 125 }
 126
 127
 128 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithBinWidthAndIntegerBins)
 129 {
 130     gmx::AnalysisHistogramSettings settings(
 131             gmx::histogramFromRange(1.0, 4.0).binWidth(0.5).integerBins());
 132     EXPECT_FLOAT_EQ(0.75, settings.firstEdge());
 133     EXPECT_FLOAT_EQ(4.25, settings.lastEdge());
 134     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 135     EXPECT_EQ(7, settings.binCount());
 136 }
 137
 138
 139 TEST(AnalysisHistogramSettingsTest, InitializesFromRangeWithRoundedRange)
 140 {
 141     gmx::AnalysisHistogramSettings settings(
 142             gmx::histogramFromRange(1.2, 3.8).binWidth(0.5).roundRange());
 143     EXPECT_FLOAT_EQ(1.0, settings.firstEdge());
 144     EXPECT_FLOAT_EQ(4.0, settings.lastEdge());
 145     EXPECT_FLOAT_EQ(0.5, settings.binWidth());
 146     EXPECT_EQ(6, settings.binCount());
 147 }
 148
 149
 150 /********************************************************************
 151  * Tests for gmx::AnalysisDataSimpleHistogramModule.
 152  */
 153
 154 //! Test fixture for gmx::AnalysisDataSimpleHistogramModule.
 155 typedef gmx::test::AnalysisDataTestFixture SimpleHistogramModuleTest;
 156
 157 // Input data for gmx::AnalysisDataSimpleHistogramModule tests.
 158 class SimpleInputData
 159 {
 160     public:
 161         static const AnalysisDataTestInput &get()
 162         {
 163 #ifndef STATIC_ANON_NAMESPACE_BUG
 164             static SimpleInputData singleton;
 165             return singleton.data_;
 166 #else
 167             static SimpleInputData singleton_histogram;
 168             return singleton_histogram.data_;
 169 #endif
 170         }
 171
 172         SimpleInputData() : data_(1, true)
 173         {
 174             using gmx::test::AnalysisDataTestInputFrame;
 175             data_.setColumnCount(0, 1);
 176             AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
 177             frame1.addPointSetWithValues(0, 0, 0.7);
 178             frame1.addPointSetWithValues(0, 0, 1.1);
 179             frame1.addPointSetWithValues(0, 0, 2.3);
 180             frame1.addPointSetWithValues(0, 0, 2.9);
 181             AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
 182             frame2.addPointSetWithValues(0, 0, 1.3);
 183             frame2.addPointSetWithValues(0, 0, 2.2);
 184             AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
 185             frame3.addPointSetWithValues(0, 0, 3.3);
 186             frame3.addPointSetWithValues(0, 0, 1.2);
 187             frame3.addPointSetWithValues(0, 0, 1.3);
 188         }
 189
 190     private:
 191         AnalysisDataTestInput  data_;
 192 };
 193
 194 TEST_F(SimpleHistogramModuleTest, ComputesCorrectly)
 195 {
 196     const AnalysisDataTestInput &input = SimpleInputData::get();
 197     gmx::AnalysisData            data;
 198     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 199
 200     gmx::AnalysisDataSimpleHistogramModulePointer module(
 201             new gmx::AnalysisDataSimpleHistogramModule(
 202                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 203     data.addModule(module);
 204
 205     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 206     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 207     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 208     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 209                                                   &module->averager()));
 210     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 211     ASSERT_NO_THROW_GMX(module->averager().done());
 212 }
 213
 214
 215 TEST_F(SimpleHistogramModuleTest, ComputesCorrectlyWithAll)
 216 {
 217     const AnalysisDataTestInput &input = SimpleInputData::get();
 218     gmx::AnalysisData            data;
 219     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 220
 221     gmx::AnalysisDataSimpleHistogramModulePointer module(
 222             new gmx::AnalysisDataSimpleHistogramModule(
 223                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 224     data.addModule(module);
 225
 226     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 227     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 228     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 229     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 230                                                   &module->averager()));
 231     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 232     ASSERT_NO_THROW_GMX(module->averager().done());
 233 }
 234
 235
 236 /********************************************************************
 237  * Tests for gmx::AnalysisDataWeightedHistogramModule.
 238  */
 239
 240 //! Test fixture for gmx::AnalysisDataWeightedHistogramModule.
 241 typedef gmx::test::AnalysisDataTestFixture WeightedHistogramModuleTest;
 242
 243 // Input data for both weighted histogram and bin average module tests.
 244 class WeightedSimpleInputData
 245 {
 246     public:
 247         static const AnalysisDataTestInput &get()
 248         {
 249 #ifndef STATIC_ANON_NAMESPACE_BUG
 250             static WeightedSimpleInputData singleton;
 251             return singleton.data_;
 252 #else
 253             static WeightedSimpleInputData singleton_histogram;
 254             return singleton_histogram.data_;
 255 #endif
 256         }
 257
 258         WeightedSimpleInputData() : data_(1, true)
 259         {
 260             using gmx::test::AnalysisDataTestInputFrame;
 261             data_.setColumnCount(0, 2);
 262             AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
 263             frame1.addPointSetWithValues(0, 0, 0.7, 0.5);
 264             frame1.addPointSetWithValues(0, 0, 1.1, 1.0);
 265             frame1.addPointSetWithValues(0, 0, 2.3, 1.0);
 266             frame1.addPointSetWithValues(0, 0, 2.9, 2.0);
 267             AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
 268             frame2.addPointSetWithValues(0, 0, 1.3, 1.0);
 269             frame2.addPointSetWithValues(0, 0, 2.2, 3.0);
 270             AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
 271             frame3.addPointSetWithValues(0, 0, 3.3, 0.5);
 272             frame3.addPointSetWithValues(0, 0, 1.2, 2.0);
 273             frame3.addPointSetWithValues(0, 0, 1.3, 1.0);
 274         }
 275
 276     private:
 277         AnalysisDataTestInput  data_;
 278 };
 279
 280 // Input data for both weighted histogram and bin average module tests.
 281 class WeightedDataSetInputData
 282 {
 283     public:
 284         static const AnalysisDataTestInput &get()
 285         {
 286 #ifndef STATIC_ANON_NAMESPACE_BUG
 287             static WeightedDataSetInputData singleton;
 288             return singleton.data_;
 289 #else
 290             static WeightedDataSetInputData singleton_histogram;
 291             return singleton_histogram.data_;
 292 #endif
 293         }
 294
 295         WeightedDataSetInputData() : data_(2, true)
 296         {
 297             using gmx::test::AnalysisDataTestInputFrame;
 298             data_.setColumnCount(0, 2);
 299             data_.setColumnCount(1, 2);
 300             AnalysisDataTestInputFrame &frame1 = data_.addFrame(1.0);
 301             frame1.addPointSetWithValues(0, 0, 0.7, 0.5);
 302             frame1.addPointSetWithValues(0, 0, 1.1, 1.0);
 303             frame1.addPointSetWithValues(1, 0, 2.3, 1.0);
 304             frame1.addPointSetWithValues(1, 0, 2.9, 2.0);
 305             AnalysisDataTestInputFrame &frame2 = data_.addFrame(2.0);
 306             frame2.addPointSetWithValues(0, 0, 1.3, 1.0);
 307             frame2.addPointSetWithValues(1, 0, 2.2, 3.0);
 308             AnalysisDataTestInputFrame &frame3 = data_.addFrame(3.0);
 309             frame3.addPointSetWithValues(0, 0, 3.3, 0.5);
 310             frame3.addPointSetWithValues(0, 0, 1.2, 2.0);
 311             frame3.addPointSetWithValues(1, 0, 1.3, 1.0);
 312         }
 313
 314     private:
 315         AnalysisDataTestInput  data_;
 316 };
 317
 318 TEST_F(WeightedHistogramModuleTest, ComputesCorrectly)
 319 {
 320     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 321     gmx::AnalysisData            data;
 322     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 323
 324     gmx::AnalysisDataWeightedHistogramModulePointer module(
 325             new gmx::AnalysisDataWeightedHistogramModule(
 326                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 327     data.addModule(module);
 328
 329     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 330     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 331     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 332     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 333                                                   &module->averager()));
 334     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 335     ASSERT_NO_THROW_GMX(module->averager().done());
 336 }
 337
 338
 339 TEST_F(WeightedHistogramModuleTest, ComputesCorrectlyWithAll)
 340 {
 341     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 342     gmx::AnalysisData            data;
 343     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 344
 345     gmx::AnalysisDataWeightedHistogramModulePointer module(
 346             new gmx::AnalysisDataWeightedHistogramModule(
 347                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 348     data.addModule(module);
 349
 350     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 351     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 352     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 353     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 354                                                   &module->averager()));
 355     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 356     ASSERT_NO_THROW_GMX(module->averager().done());
 357 }
 358
 359
 360 TEST_F(WeightedHistogramModuleTest, HandlesMultipleDataSets)
 361 {
 362     const AnalysisDataTestInput &input = WeightedDataSetInputData::get();
 363     gmx::AnalysisData            data;
 364     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 365
 366     gmx::AnalysisDataWeightedHistogramModulePointer module(
 367             new gmx::AnalysisDataWeightedHistogramModule(
 368                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 369     data.addModule(module);
 370
 371     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 372     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 373     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("Histogram", module.get()));
 374     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage",
 375                                                   &module->averager()));
 376     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 377     ASSERT_NO_THROW_GMX(module->averager().done());
 378 }
 379
 380
 381 /********************************************************************
 382  * Tests for gmx::AnalysisDataBinAverageModule.
 383  */
 384
 385 //! Test fixture for gmx::AnalysisDataBinAverageModule.
 386 typedef gmx::test::AnalysisDataTestFixture BinAverageModuleTest;
 387
 388 TEST_F(BinAverageModuleTest, ComputesCorrectly)
 389 {
 390     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 391     gmx::AnalysisData            data;
 392     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 393
 394     gmx::AnalysisDataBinAverageModulePointer module(
 395             new gmx::AnalysisDataBinAverageModule(
 396                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 397     data.addModule(module);
 398
 399     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 400     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 401     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
 402     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 403 }
 404
 405
 406 TEST_F(BinAverageModuleTest, ComputesCorrectlyWithAll)
 407 {
 408     const AnalysisDataTestInput &input = WeightedSimpleInputData::get();
 409     gmx::AnalysisData            data;
 410     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 411
 412     gmx::AnalysisDataBinAverageModulePointer module(
 413             new gmx::AnalysisDataBinAverageModule(
 414                     gmx::histogramFromRange(1.0, 3.0).binCount(4).includeAll()));
 415     data.addModule(module);
 416
 417     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 418     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 419     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
 420     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 421 }
 422
 423
 424 TEST_F(BinAverageModuleTest, HandlesMultipleDataSets)
 425 {
 426     const AnalysisDataTestInput &input = WeightedDataSetInputData::get();
 427     gmx::AnalysisData            data;
 428     ASSERT_NO_THROW_GMX(setupDataObject(input, &data));
 429
 430     gmx::AnalysisDataBinAverageModulePointer module(
 431             new gmx::AnalysisDataBinAverageModule(
 432                     gmx::histogramFromRange(1.0, 3.0).binCount(4)));
 433     data.addModule(module);
 434
 435     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 436     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 437     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("HistogramAverage", module.get()));
 438     ASSERT_NO_THROW_GMX(presentAllData(input, &data));
 439 }
 440
 441
 442 /********************************************************************
 443  * Tests for gmx::AbstractAverageHistogram.
 444  *
 445  * This class derives from gmx::AbstractAnalysisArrayData, and is tested using
 446  * corresponding facilities in gmx::test::AnalysisDataTestFixture.
 447  */
 448
 449 //! Test fixture for gmx::AbstractAverageHistogram.
 450 typedef gmx::test::AnalysisDataTestFixture AbstractAverageHistogramTest;
 451
 452 // Input data for gmx::AbstractAverageHistogram tests.
 453 class AverageInputData
 454 {
 455     public:
 456         static const AnalysisDataTestInput &get()
 457         {
 458 #ifndef STATIC_ANON_NAMESPACE_BUG
 459             static AverageInputData singleton;
 460             return singleton.data_;
 461 #else
 462             static AverageInputData singleton_histogram;
 463             return singleton_histogram.data_;
 464 #endif
 465         }
 466
 467         AverageInputData() : data_(1, false)
 468         {
 469             data_.setColumnCount(0, 1);
 470             data_.addFrameWithValueAndError(1.0,  2.0, 1.0);
 471             data_.addFrameWithValueAndError(1.5,  1.0, 1.0);
 472             data_.addFrameWithValueAndError(2.0,  3.0, 2.0);
 473             data_.addFrameWithValueAndError(2.5,  4.0, 2.0);
 474             data_.addFrameWithValueAndError(3.0,  2.0, 1.0);
 475             data_.addFrameWithValueAndError(3.5,  0.0, 3.0);
 476             data_.addFrameWithValueAndError(4.0,  1.0, 3.0);
 477         }
 478
 479     private:
 480         AnalysisDataTestInput  data_;
 481 };
 482
 483 /*! \brief
 484  * Mock object for testing gmx::AbstractAverageHistogram.
 485  *
 486  * Exposes necessary methods from gmx::AbstractAverageHistogram to use with
 487  * gmx::test::AnalysisDataTestFixture::setupArrayData().
 488  *
 489  * \ingroup module_analysisdata
 490  */
 491 class MockAverageHistogram : public gmx::AbstractAverageHistogram
 492 {
 493     public:
 494         //! Creates a histogram module with defined bin parameters.
 495         explicit MockAverageHistogram(const gmx::AnalysisHistogramSettings &settings)
 496             : AbstractAverageHistogram(settings)
 497         {
 498         }
 499
 500         using AbstractAverageHistogram::init;
 501         using AbstractAverageHistogram::setColumnCount;
 502         using AbstractAverageHistogram::setRowCount;
 503         using AbstractAverageHistogram::allocateValues;
 504         using AbstractAverageHistogram::value;
 505 };
 506
 507
 508 TEST_F(AbstractAverageHistogramTest, ClonesCorrectly)
 509 {
 510     const AnalysisDataTestInput &input = AverageInputData::get();
 511     MockAverageHistogram         data(
 512             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 513     setupArrayData(input, &data);
 514
 515     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 516     gmx::AverageHistogramPointer copy(data.clone());
 517     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy.get()));
 518     ASSERT_NO_THROW_GMX(copy->done());
 519     ASSERT_NO_THROW_GMX(data.done());
 520     gmx::AverageHistogramPointer copy2(data.clone());
 521     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, copy2.get()));
 522     ASSERT_NO_THROW_GMX(copy2->done());
 523 }
 524
 525
 526 TEST_F(AbstractAverageHistogramTest, ComputesCumulativeHistogram)
 527 {
 528     const AnalysisDataTestInput &input = AverageInputData::get();
 529     MockAverageHistogram         data(
 530             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 531     setupArrayData(input, &data);
 532
 533     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 534     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 535     ASSERT_NO_THROW_GMX(data.done());
 536
 537     gmx::AverageHistogramPointer cumulative(data.clone());
 538     cumulative->makeCumulative();
 539     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("CumulativeHistogram", cumulative.get()));
 540     ASSERT_NO_THROW_GMX(cumulative->done());
 541 }
 542
 543
 544 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidth)
 545 {
 546     const AnalysisDataTestInput &input = AverageInputData::get();
 547     MockAverageHistogram         data(
 548             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 549     setupArrayData(input, &data);
 550
 551     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 552     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 553     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(false));
 554     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 555     ASSERT_NO_THROW_GMX(data.done());
 556     ASSERT_NO_THROW_GMX(resampled->done());
 557 }
 558
 559
 560 TEST_F(AbstractAverageHistogramTest, ResamplesAtDoubleBinWidthWithIntegerBins)
 561 {
 562     const AnalysisDataTestInput &input = AverageInputData::get();
 563     MockAverageHistogram         data(
 564             gmx::histogramFromBins(1.0, input.frameCount(), 0.5).integerBins());
 565     setupArrayData(input, &data);
 566
 567     ASSERT_NO_THROW_GMX(addStaticCheckerModule(input, &data));
 568     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("InputData", &data));
 569     gmx::AverageHistogramPointer resampled(data.resampleDoubleBinWidth(true));
 570     ASSERT_NO_THROW_GMX(addReferenceCheckerModule("ResampledHistogram", resampled.get()));
 571     ASSERT_NO_THROW_GMX(data.done());
 572     ASSERT_NO_THROW_GMX(resampled->done());
 573 }
 574
 575 } // namespace