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