src/gromacs/math/tests/coordinatetransformation.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2019,2020, 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 structure similarity measures rmsd and size-independent rho factor.
  38  *
  39  * \author Christian Blau <cblau@gwdg.de>
  40  * \ingroup module_math
  41  */
  42 #include "gmxpre.h"
  43
  44 #include "gromacs/math/coordinatetransformation.h"
  45
  46 #include <array>
  47
  48 #include <gmock/gmock.h>
  49 #include <gtest/gtest.h>
  50
  51 #include "gromacs/utility/arrayref.h"
  52 #include "gromacs/utility/real.h"
  53
  54 #include "testutils/testasserts.h"
  55 #include "testutils/testmatchers.h"
  56
  57 namespace gmx
  58 {
  59
  60 namespace test
  61 {
  62
  63 using ::testing::Pointwise;
  64 class TranslateAndScaleTest : public ::testing::Test
  65 {
  66 protected:
  67     RVec              identityScale_       = { 1, 1, 1 };
  68     RVec              identityTranslation_ = { 0, 0, 0 };
  69     std::vector<RVec> testVectors_         = { { 0, 0, 0 },
  70                                        { 1, 0, 0 },
  71                                        { 0, -1, -1 },
  72                                        { 1e10, 1e1, 1e-2 },
  73                                        { 3, -6, 2.5 } };
  74 };
  75
  76 class AffineTransformationTest : public ::testing::Test
  77 {
  78 protected:
  79     std::vector<RVec> testVectors_ = { { 0, 0, 0 },
  80                                        { 1, 0, 0 },
  81                                        { 0, -1, -1 },
  82                                        { 1e10, 1e1, 1e-2 },
  83                                        { 3, -6, 2.5 } };
  84 };
  85
  86
  87 TEST_F(TranslateAndScaleTest, identityTransformation)
  88 {
  89     TranslateAndScale translateAndScale(identityScale_, identityTranslation_);
  90     auto              toBeTransformed = testVectors_;
  91     translateAndScale(toBeTransformed);
  92     EXPECT_THAT(testVectors_, Pointwise(RVecEq(defaultFloatTolerance()), toBeTransformed));
  93 }
  94
  95 TEST_F(TranslateAndScaleTest, translationWithIdentityScaling)
  96 {
  97     TranslateAndScale translateAndScale(identityScale_, { 1, -1, 2 });
  98     translateAndScale(testVectors_);
  99     std::vector<RVec> expected = {
 100         { 1, -1, 2 }, { 2, -1, 2 }, { 1, -2, 1 }, { 1e10 + 1, 1e1 - 1, 1e-2 + 2 }, { 4, -7, 4.5 }
 101     };
 102     EXPECT_THAT(expected, Pointwise(RVecEq(defaultFloatTolerance()), testVectors_));
 103 }
 104
 105 TEST_F(TranslateAndScaleTest, scalingWithZeroTranslation)
 106 {
 107     TranslateAndScale translateAndScale({ -1e10, 2, 0 }, identityTranslation_);
 108     translateAndScale(testVectors_);
 109     std::vector<RVec> expected = {
 110         { 0, 0, 0 }, { -1e10, 0, 0 }, { 0, -2, 0 }, { -1e20, 2e1, 0 }, { -3e10, -12, 0 }
 111     };
 112     EXPECT_THAT(expected, Pointwise(RVecEq(defaultFloatTolerance()), testVectors_));
 113 }
 114
 115 TEST_F(TranslateAndScaleTest, translationAndScalingNonTrivial)
 116 {
 117     TranslateAndScale translateAndScale({ -1e10, 2, 0 }, { 1, -1, 2 });
 118     translateAndScale(testVectors_);
 119     std::vector<RVec> expected = {
 120         { -1e+10, -2, 0 }, { -2e+10, -2, 0 }, { -1e+10, -4, 0 }, { -1e+20, 18, 0 }, { -4e+10, -14, 0 }
 121     };
 122     EXPECT_THAT(expected, Pointwise(RVecEq(defaultFloatTolerance()), testVectors_));
 123 }
 124
 125 TEST_F(TranslateAndScaleTest, translationAndScalingNonTrivialSingeVector)
 126 {
 127     TranslateAndScale translateAndScale({ -1e10, 2, 0 }, { 1, -1, 2 });
 128     RVec              test(0, 0, 0);
 129     translateAndScale(&test);
 130
 131     EXPECT_REAL_EQ(-1e+10, test[XX]);
 132     EXPECT_REAL_EQ(-2, test[YY]);
 133     EXPECT_REAL_EQ(0, test[ZZ]);
 134 }
 135
 136 TEST_F(TranslateAndScaleTest, scalingIdentity)
 137 {
 138     ScaleCoordinates scale(identityScale_);
 139     auto             expected = testVectors_;
 140     scale(testVectors_);
 141     EXPECT_THAT(expected, Pointwise(RVecEq(defaultFloatTolerance()), testVectors_));
 142 }
 143
 144 TEST_F(TranslateAndScaleTest, scalingNonTrivial)
 145 {
 146     ScaleCoordinates  scale({ -100, 0.1, 0 });
 147     std::vector<RVec> expected = {
 148         { 0, 0, 0 }, { -100, 0, 0 }, { 0, -0.1, 0 }, { -1e12, 1e0, 0 }, { -300, -0.6, 0 }
 149     };
 150     scale(testVectors_);
 151     EXPECT_THAT(expected, Pointwise(RVecEq(defaultFloatTolerance()), testVectors_));
 152 }
 153
 154 TEST_F(TranslateAndScaleTest, scalingNonTrivialSingleVector)
 155 {
 156     ScaleCoordinates scale({ -100, 0.1, 0 });
 157     RVec             test(3, -6, 2.5);
 158     scale(&test);
 159
 160     EXPECT_REAL_EQ(-300, test[XX]);
 161     EXPECT_REAL_EQ(-0.6, test[YY]);
 162     EXPECT_REAL_EQ(0, test[ZZ]);
 163 }
 164
 165
 166 TEST_F(TranslateAndScaleTest, scalingInverseNoZero)
 167 {
 168     ScaleCoordinates scale({ -100, 0.1, 3 });
 169     auto             expected = testVectors_;
 170     scale(testVectors_);
 171     scale.inverseIgnoringZeroScale(testVectors_);
 172     EXPECT_THAT(expected, Pointwise(RVecEq(defaultFloatTolerance()), testVectors_));
 173 }
 174
 175 TEST_F(TranslateAndScaleTest, scalingInverseWithOneScaleDimensionZero)
 176 {
 177     ScaleCoordinates scale({ -100, 0.1, 0 });
 178     std::vector<RVec> expected = { { 0, 0, 0 }, { 1, 0, 0 }, { 0, -1, 0 }, { 1e10, 1e1, 0 }, { 3, -6, 0 } };
 179     scale(testVectors_);
 180     scale.inverseIgnoringZeroScale(testVectors_);
 181     EXPECT_THAT(expected, Pointwise(RVecEq(defaultFloatTolerance()), testVectors_));
 182 }
 183
 184 TEST_F(TranslateAndScaleTest, scalingInverseWithOneScaleDimensionZeroSingleVector)
 185 {
 186     ScaleCoordinates scale({ -100, 0.1, 0 });
 187     RVec             test(3, -6, 2.5);
 188
 189     scale(&test);
 190     scale.inverseIgnoringZeroScale(&test);
 191
 192     EXPECT_REAL_EQ(3, test[XX]);
 193     EXPECT_REAL_EQ(-6, test[YY]);
 194     EXPECT_REAL_EQ(0, test[ZZ]);
 195 }
 196
 197 TEST_F(AffineTransformationTest, identityTransformYieldsSameVectors)
 198 {
 199     const AffineTransformation identityTransformation(identityMatrix<real, 3>(), { 0, 0, 0 });
 200     for (const auto& vector : testVectors_)
 201     {
 202         RVec vectorTransformed = vector;
 203         identityTransformation(&vectorTransformed);
 204         EXPECT_REAL_EQ(vector[XX], vectorTransformed[XX]);
 205         EXPECT_REAL_EQ(vector[YY], vectorTransformed[YY]);
 206         EXPECT_REAL_EQ(vector[ZZ], vectorTransformed[ZZ]);
 207     }
 208 }
 209
 210 TEST_F(AffineTransformationTest, applyTransformationToVectors)
 211 {
 212     const Matrix3x3 transformMatrix({ 0.1, 1, 0.1, 0.4, 1, 0.6, 0.7, 0.8, 0.9 });
 213     const RVec      transformVector = { 1, -1e5, 1e4 };
 214
 215     const AffineTransformation affineTransformation(transformMatrix, transformVector);
 216
 217     const std::vector<RVec> expectedResult = { { 1, -100'000, 10'000 },
 218                                                { 1.1, -99999.6, 10000.7 },
 219                                                { -0.1, -100'002, 9998.3 },
 220                                                { 1e9, 3.9999e9, 7.00001e9 },
 221                                                { -4.45, -100'003, 9'999.5 } };
 222
 223     auto expected = expectedResult.begin();
 224     for (const auto& vector : testVectors_)
 225     {
 226         RVec vectorTransformed = vector;
 227         affineTransformation(&vectorTransformed);
 228         // need relaxed tolerance here, due to the number of operations involved
 229         EXPECT_REAL_EQ_TOL((*expected)[XX],
 230                            vectorTransformed[XX],
 231                            relativeToleranceAsFloatingPoint((*expected)[XX], 1e-5));
 232         EXPECT_REAL_EQ_TOL((*expected)[YY],
 233                            vectorTransformed[YY],
 234                            relativeToleranceAsFloatingPoint((*expected)[YY], 1e-5));
 235         EXPECT_REAL_EQ_TOL((*expected)[ZZ],
 236                            vectorTransformed[ZZ],
 237                            relativeToleranceAsFloatingPoint((*expected)[ZZ], 1e-5));
 238         ++expected;
 239     }
 240 }
 241
 242 } // namespace test
 243 } // namespace gmx