Core/Surfaces/EllipseBoundsTests.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/EllipseBounds.hpp"
0016 #include "Acts/Surfaces/RectangleBounds.hpp"
0017 #include "Acts/Surfaces/SurfaceBounds.hpp"
0018
0019 #include <algorithm>
0020 #include <array>
0021 #include <cmath>
0022 #include <stdexcept>
0023 #include <vector>
0024
0025 namespace Acts {
0026
0027 namespace Test {
0028 BOOST_AUTO_TEST_SUITE(Surfaces)
0029
0030 /// Unit test for creating compliant/non-compliant EllipseBounds object
0031 BOOST_AUTO_TEST_CASE(EllipseBoundsConstruction) {
0032   double innerRx(10.), innerRy(15.), outerRx(25.), outerRy(30.),
0033       phiSector(M_PI / 2.), averagePhi(0.);
0034
0035   // test default construction
0036   // EllipseBounds defaultConstructedEllipseBounds;  //deleted
0037   //
0038   /// Test construction with dimensions
0039   BOOST_CHECK_EQUAL(
0040       EllipseBounds(innerRx, innerRy, outerRx, outerRy, phiSector, averagePhi)
0041           .type(),
0042       SurfaceBounds::eEllipse);
0043   //
0044   /// Copy constructor
0045   EllipseBounds original(innerRx, innerRy, outerRx, outerRy, phiSector,
0046                          averagePhi);
0047   EllipseBounds copied(original);
0048   BOOST_CHECK_EQUAL(copied, original);
0049 }
0050
0051 // Streaning and recreation test
0052 BOOST_AUTO_TEST_CASE(EllipseBoundsRecreation) {
0053   double innerRx(10.), innerRy(15.), outerRx(25.), outerRy(30.),
0054       phiSector(M_PI / 2.), averagePhi(0.);
0055   // const bool symmetric(false);
0056   EllipseBounds original(innerRx, innerRy, outerRx, outerRy, phiSector,
0057                          averagePhi);
0058   auto valvector = original.values();
0059   std::array<double, EllipseBounds::eSize> values{};
0060   std::copy_n(valvector.begin(), EllipseBounds::eSize, values.begin());
0061   EllipseBounds recreated(values);
0062   BOOST_CHECK_EQUAL(recreated, original);
0063 }
0064
0065 // Unit tests for AnnulusBounds exception throwing
0066 BOOST_AUTO_TEST_CASE(ConeBoundsExceptions) {
0067   double innerRx(10.), innerRy(15.), outerRx(25.), outerRy(30.),
0068       phiSector(M_PI / 2.), averagePhi(0.);
0069   // Exception for innerRx < 0
0070   BOOST_CHECK_THROW(
0071       EllipseBounds(-innerRx, innerRy, outerRx, outerRy, phiSector, averagePhi),
0072       std::logic_error);
0073   // Exception for innerRy < 0
0074   BOOST_CHECK_THROW(
0075       EllipseBounds(innerRx, -innerRy, outerRx, outerRy, phiSector, averagePhi),
0076       std::logic_error);
0077   // Exception for innerRx < 0 and innerRy < 0
0078   BOOST_CHECK_THROW(EllipseBounds(-innerRx, -innerRy, outerRx, outerRy,
0079                                   phiSector, averagePhi),
0080                     std::logic_error);
0081   // Exception for opening outerRx <= 0
0082   BOOST_CHECK_THROW(
0083       EllipseBounds(innerRx, innerRy, 0., outerRy, phiSector, averagePhi),
0084       std::logic_error);
0085   // Exception for opening outerRy <= 0
0086   BOOST_CHECK_THROW(
0087       EllipseBounds(innerRx, innerRy, outerRx, 0., phiSector, averagePhi),
0088       std::logic_error);
0089   // Exception for iouterRx < 0 and outerRy < 0
0090   BOOST_CHECK_THROW(EllipseBounds(innerRx, innerRy, -outerRx, -outerRy,
0091                                   phiSector, averagePhi),
0092                     std::logic_error);
0093   // Exception for innerRx > outerRx
0094   BOOST_CHECK_THROW(
0095       EllipseBounds(outerRx, innerRy, innerRx, outerRy, phiSector, averagePhi),
0096       std::logic_error);
0097   // Exception for innerRxy > outerRy
0098   BOOST_CHECK_THROW(
0099       EllipseBounds(innerRx, outerRy, outerRx, innerRy, phiSector, averagePhi),
0100       std::logic_error);
0101   // Exception for negative phiSector
0102   BOOST_CHECK_THROW(
0103       EllipseBounds(innerRx, innerRy, outerRx, outerRy, -phiSector, averagePhi),
0104       std::logic_error);
0105   // Exception for average phi out of bound
0106   BOOST_CHECK_THROW(
0107       EllipseBounds(innerRx, innerRy, outerRx, outerRy, phiSector, 4.),
0108       std::logic_error);
0109 }
0110
0111 /// Unit tests for EllipseBounds properties
0112 BOOST_AUTO_TEST_CASE(EllipseBoundsProperties) {
0113   double innerRx(10.), outerRx(15.), innerRy(15.), outerRy(20.), averagePhi(0.),
0114       phiSector(M_PI / 2.);
0115   /// Test clone
0116   EllipseBounds ellipseBoundsObject(innerRx, innerRy, outerRx, outerRy,
0117                                     phiSector, averagePhi);
0118   //
0119   /// Test type() (redundant; already used in constructor confirmation)
0120   BOOST_CHECK_EQUAL(ellipseBoundsObject.type(), SurfaceBounds::eEllipse);
0121   //
0122   // clone already tested
0123   //
0124   /// Test distanceToBoundary
0125   Vector2 origin(0., 0.);
0126   Vector2 outsideBy15(0., 30.);
0127   Vector2 inRectangle(17., 11.);
0128   //
0129   /// Test rMinX
0130   BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eInnerRx), innerRx);
0131   //
0132   /// Test rMinY
0133   BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eOuterRx), outerRx);
0134   //
0135   /// Test rMaxX
0136   BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eInnerRy), innerRy);
0137   //
0138   /// Test rMaxY
0139   BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eOuterRy), outerRy);
0140   //
0141   /// Test averagePhi
0142   BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eAveragePhi),
0143                     averagePhi);
0144   //
0145   /// Test vertices
0146   // std::vector<Vector2> expectedVertices{{15, 0}, {0, 20}, {-15, 0}, {0,
0147   // -20}}; const auto& actualVertices = ellipseBoundsObject.vertices(4);
0148   // BOOST_CHECK_EQUAL_COLLECTIONS(actualVertices.cbegin(),
0149   // actualVertices.cend(),
0150   //                              expectedVertices.cbegin(),
0151   //                              expectedVertices.cend());
0152   //
0153   /// Test boundingBox
0154   BOOST_CHECK_EQUAL(ellipseBoundsObject.boundingBox(),
0155                     RectangleBounds(15., 20.));
0156   //
0157   /// Test halfPhiSector
0158   BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eHalfPhiSector),
0159                     M_PI / 2.);
0160   //
0161   /// Test dump
0162   boost::test_tools::output_test_stream dumpOuput;
0163   ellipseBoundsObject.toStream(dumpOuput);
0164   BOOST_CHECK(dumpOuput.is_equal(
0165       "Acts::EllipseBounds:  (innerRadius0, outerRadius0, innerRadius1, "
0166       "outerRadius1, hPhiSector, averagePhi) = (10.0000000, 15.0000000, "
0167       "15.0000000, "
0168       "20.0000000, 0.0000000, 1.5707963, 0.0000000)"));
0169   //
0170   /// Test inside
0171   BOOST_CHECK(!ellipseBoundsObject.inside(inRectangle, BoundaryCheck(true)));
0172   // dont understand why this is so:
0173   BOOST_CHECK(!ellipseBoundsObject.inside(outsideBy15, BoundaryCheck(true)));
0174 }
0175 /// Unit test for testing EllipseBounds assignment
0176 BOOST_AUTO_TEST_CASE(EllipseBoundsAssignment) {
0177   double innerRx(10.), outerRx(15.), innerRy(15.), outerRy(20.), averagePhi(0.),
0178       phiSector(M_PI / 2.);
0179   EllipseBounds ellipseBoundsObject(innerRx, outerRx, innerRy, outerRy,
0180                                     averagePhi, phiSector);
0181   EllipseBounds similarlyConstructeEllipseBoundsObject(
0182       innerRx, outerRx, innerRy, outerRy, averagePhi, phiSector);
0183   /// Test operator ==
0184   BOOST_CHECK_EQUAL(ellipseBoundsObject,
0185                     similarlyConstructeEllipseBoundsObject);
0186   //
0187   /// Test assignment
0188   EllipseBounds assignedEllipseBoundsObject(11., 12., 17., 18., 1.);
0189   // object, in some sense
0190   assignedEllipseBoundsObject = ellipseBoundsObject;
0191   BOOST_CHECK_EQUAL(assignedEllipseBoundsObject, ellipseBoundsObject);
0192 }
0193
0194 BOOST_AUTO_TEST_SUITE_END()
0195
0196 }  // namespace Test
0197
0198 }  // namespace Acts