Core/Surfaces/TrapezoidBoundsTests.cpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2017-2018 CERN for the benefit of the Acts project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
0008
0009 #include <boost/test/data/test_case.hpp>
0010 #include <boost/test/tools/output_test_stream.hpp>
0011 #include <boost/test/unit_test.hpp>
0012
0013 #include "Acts/Definitions/Algebra.hpp"
0014 #include "Acts/Surfaces/BoundaryCheck.hpp"
0015 #include "Acts/Surfaces/RectangleBounds.hpp"
0016 #include "Acts/Surfaces/SurfaceBounds.hpp"
0017 #include "Acts/Surfaces/TrapezoidBounds.hpp"
0018
0019 #include <algorithm>
0020 #include <array>
0021 #include <ostream>
0022 #include <random>
0023 #include <stdexcept>
0024 #include <utility>
0025 #include <vector>
0026
0027 namespace bdata = boost::unit_test::data;
0028
0029 namespace Acts {
0030
0031 namespace Test {
0032 BOOST_AUTO_TEST_SUITE(Surfaces)
0033
0034 /// Unit test for creating compliant/non-compliant TrapezoidBounds object
0035 BOOST_AUTO_TEST_CASE(TrapezoidBoundsConstruction) {
0036   double minHalfX(1.), maxHalfX(6.), halfY(2.);
0037   //
0038   // default construction  deleted
0039   // TrapezoidBounds defaultConstructedTrapezoidBounds;
0040   //
0041   /// Test construction with defining half lengths
0042   BOOST_CHECK_EQUAL(TrapezoidBounds(minHalfX, maxHalfX, halfY).type(),
0043                     SurfaceBounds::eTrapezoid);
0044   /// Copy constructor
0045   TrapezoidBounds original(minHalfX, maxHalfX, halfY);
0046   TrapezoidBounds copied(original);
0047   BOOST_CHECK_EQUAL(copied, original);
0048 }
0049
0050 /// Unit test for creating compliant/non-compliant TrapezoidBounds object
0051 BOOST_AUTO_TEST_CASE(TrapezoidBoundsRecreated) {
0052   double minHalfX(1.), maxHalfX(6.), halfY(2.);
0053   /// Copy constructor
0054   TrapezoidBounds original(minHalfX, maxHalfX, halfY);
0055   // const bool symmetric(false);
0056   auto valvector = original.values();
0057   std::array<double, TrapezoidBounds::eSize> values{};
0058   std::copy_n(valvector.begin(), TrapezoidBounds::eSize, values.begin());
0059   TrapezoidBounds recreated(values);
0060   BOOST_CHECK_EQUAL(original, recreated);
0061 }
0062
0063 // Exception tests
0064 BOOST_AUTO_TEST_CASE(TrapezoidBoundsException) {
0065   double minHalfX(1.), maxHalfX(6.), halfY(2.);
0066
0067   // Negative x at min y
0068   BOOST_CHECK_THROW(TrapezoidBounds(-minHalfX, maxHalfX, halfY),
0069                     std::logic_error);
0070
0071   // Negative x at max y
0072   BOOST_CHECK_THROW(TrapezoidBounds(minHalfX, -maxHalfX, halfY),
0073                     std::logic_error);
0074
0075   // Negative x at miny and max y
0076   BOOST_CHECK_THROW(TrapezoidBounds(-minHalfX, -maxHalfX, halfY),
0077                     std::logic_error);
0078
0079   // Negative y
0080   BOOST_CHECK_THROW(TrapezoidBounds(minHalfX, maxHalfX, -halfY),
0081                     std::logic_error);
0082 }
0083
0084 /// Unit tests for TrapezoidBounds properties
0085 BOOST_AUTO_TEST_CASE(TrapezoidBoundsProperties) {
0086   double minHalfX(1.), maxHalfX(6.), halfY(2.);
0087   //
0088   TrapezoidBounds trapezoidBoundsObject(minHalfX, maxHalfX, halfY);
0089   //
0090   /// Test type() (redundant; already used in constructor confirmation)
0091   BOOST_CHECK_EQUAL(trapezoidBoundsObject.type(), SurfaceBounds::eTrapezoid);
0092   //
0093   /// Test minHalflengthX
0094   BOOST_CHECK_EQUAL(
0095       trapezoidBoundsObject.get(TrapezoidBounds::eHalfLengthXnegY), minHalfX);
0096   //
0097   /// Test maxHalfLengthX
0098   BOOST_CHECK_EQUAL(
0099       trapezoidBoundsObject.get(TrapezoidBounds::eHalfLengthXposY), maxHalfX);
0100   //
0101   /// Test halflengthY
0102   BOOST_CHECK_EQUAL(trapezoidBoundsObject.get(TrapezoidBounds::eHalfLengthY),
0103                     halfY);
0104   //
0105   /// Test distanceToBoundary
0106   Vector2 outside(30., 0.);
0107   Vector2 inRectangle(2., 0.5);
0108
0109   /// Test vertices
0110   std::vector<Vector2> expectedVertices{
0111       {-1., -2.}, {1., -2.}, {6., 2.}, {-6., 2.}};
0112   const auto& actualVertices = trapezoidBoundsObject.vertices();
0113   BOOST_CHECK_EQUAL_COLLECTIONS(actualVertices.cbegin(), actualVertices.cend(),
0114                                 expectedVertices.cbegin(),
0115                                 expectedVertices.cend());
0116   /**
0117   for (auto i: trapezoidBoundsObject.vertices()){
0118     std::cout<<i[0]<<", "<<i[1]<<std::endl;
0119   }**/
0120   //
0121   /// Test boundingBox
0122   BOOST_CHECK_EQUAL(trapezoidBoundsObject.boundingBox(),
0123                     RectangleBounds(6., 2.));
0124   //
0125
0126   //
0127   /// Test dump
0128   boost::test_tools::output_test_stream dumpOuput;
0129   trapezoidBoundsObject.toStream(dumpOuput);
0130   BOOST_CHECK(dumpOuput.is_equal(
0131       "Acts::TrapezoidBounds:  (halfXnegY, halfXposY, halfY, rotAngle) = "
0132       "(1.0000000, 6.0000000, 2.0000000, 0.0000000)"));
0133   //
0134   /// Test inside
0135   BOOST_CHECK(trapezoidBoundsObject.inside(inRectangle, BoundaryCheck(true)));
0136   BOOST_CHECK(!trapezoidBoundsObject.inside(outside, BoundaryCheck(true)));
0137
0138   const auto vertices = trapezoidBoundsObject.vertices();
0139   BoundaryCheck bc{true};
0140
0141   std::vector<Vector2> testPoints = {
0142       // inside
0143       {0, 1},
0144       {0, -1},
0145       {2, 0.5},
0146       {2, 0},
0147       {-2, 0},
0148       {-2, 0.5},
0149       {3, 1},
0150       {-3, 1},
0151       {4, 1},
0152       {-4, 1},
0153       {-6, 2},
0154
0155       // outside
0156       {0, 2.5},
0157       {0, -2.5},
0158       {2, 2.5},
0159       {-2, 2.5},
0160       {2, -2.5},
0161       {2, -2.5},
0162       {4, -1},
0163       {-4, -1},
0164       {-7, 0},
0165       {7, 0},
0166       {5, -3},
0167       {5, 3},
0168       {-5, -3},
0169       {-5, 3},
0170       {6, 2},
0171
0172   };
0173
0174   for (const auto& p : testPoints) {
0175     BOOST_TEST_CONTEXT("p=" << p.transpose()) {
0176       BOOST_CHECK_EQUAL(bc.isInside(p, vertices),
0177                         trapezoidBoundsObject.inside(p, bc));
0178     }
0179   }
0180 }
0181
0182 BOOST_DATA_TEST_CASE(
0183     TrapezoidInsideCheck,
0184     bdata::random(
0185         (bdata::engine = std::mt19937(), bdata::seed = 21,
0186          bdata::distribution = std::uniform_real_distribution<double>(-7, 7))) ^
0187         bdata::random((bdata::engine = std::mt19937(), bdata::seed = 22,
0188                        bdata::distribution =
0189                            std::uniform_real_distribution<double>(-3, 3))) ^
0190         bdata::xrange(1000) * bdata::make({0.0, 0.1, 0.2, 0.3}),
0191     x, y, index, tol) {
0192   (void)index;
0193   double minHalfX(1.), maxHalfX(6.), halfY(2.);
0194   static const TrapezoidBounds trapezoidBoundsObject(minHalfX, maxHalfX, halfY);
0195   static const auto vertices = trapezoidBoundsObject.vertices();
0196
0197   BoundaryCheck bc{true};
0198
0199   if (tol != 0.0) {
0200     bc = BoundaryCheck{true, true, tol, tol};
0201   }
0202
0203   BOOST_CHECK_EQUAL(bc.isInside({x, y}, vertices),
0204                     trapezoidBoundsObject.inside({x, y}, bc));
0205 }
0206
0207 /// Unit test for testing TrapezoidBounds assignment
0208 BOOST_AUTO_TEST_CASE(TrapezoidBoundsAssignment) {
0209   double minHalfX(1.), maxHalfX(6.), halfY(2.);
0210   TrapezoidBounds trapezoidBoundsObject(minHalfX, maxHalfX, halfY);
0211   // operator == not implemented in this class
0212   //
0213   /// Test assignment
0214   TrapezoidBounds assignedTrapezoidBoundsObject(10., 20., 14.2);
0215   assignedTrapezoidBoundsObject = trapezoidBoundsObject;
0216   BOOST_CHECK_EQUAL(assignedTrapezoidBoundsObject, trapezoidBoundsObject);
0217 }
0218
0219 BOOST_AUTO_TEST_SUITE_END()
0220
0221 }  // namespace Test
0222
0223 }  // namespace Acts