CylinderBoundsTests.cpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file CylinderBoundsTests.cpp

// This file is part of the Acts project.
//
// Copyright (C) 2017-2018 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include <boost/test/data/test_case.hpp>
#include <boost/test/tools/output_test_stream.hpp>
#include <boost/test/unit_test.hpp>

#include <limits>

#include "Acts/Surfaces/CylinderBounds.hpp"
#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
#include "Acts/Utilities/Definitions.hpp"

namespace Acts {

namespace Test {
BOOST_AUTO_TEST_SUITE(Surfaces)

BOOST_AUTO_TEST_CASE(CylinderBoundsConstruction) {
  // CylinderBounds defaultConstructedCylinderBounds;  // deleted
  double radius(0.5), halfz(10.), halfphi(M_PI / 2.0), averagePhi(M_PI / 2.0);
  BOOST_CHECK_EQUAL(CylinderBounds(radius, halfz).type(),
                    SurfaceBounds::eCylinder);
  BOOST_CHECK_EQUAL(CylinderBounds(radius, halfz, halfphi).type(),
                    SurfaceBounds::eCylinder);
  BOOST_CHECK_EQUAL(CylinderBounds(radius, halfz, halfphi, averagePhi).type(),
                    SurfaceBounds::eCylinder);
  //
  CylinderBounds cylinderBounds(radius, halfz);
  CylinderBounds copyConstructedCylinderBounds(cylinderBounds);
  BOOST_CHECK_EQUAL(copyConstructedCylinderBounds, cylinderBounds);
}

BOOST_AUTO_TEST_CASE(CylinderBoundsRecreation) {
  // CylinderBounds defaultConstructedCylinderBounds;  // deleted
  double radius(0.5), halfz(10.);
  // Test construction with radii and default sector
  auto original = CylinderBounds(radius, halfz);
  auto valvector = original.values();
  std::array<double, CylinderBounds::eSize> values;
  std::copy_n(valvector.begin(), CylinderBounds::eSize, values.begin());
  CylinderBounds recreated(values);
  BOOST_CHECK_EQUAL(original, recreated);
}

BOOST_AUTO_TEST_CASE(CylinderBoundsException) {
  double radius(0.5), halfz(10.), halfphi(M_PI / 2.0), averagePhi(M_PI / 2.0);

  // Negative radius
  BOOST_CHECK_THROW(CylinderBounds(-radius, halfz, halfphi, averagePhi),
                    std::logic_error);

  // Negative half length in z
  BOOST_CHECK_THROW(CylinderBounds(radius, -halfz, halfphi, averagePhi),
                    std::logic_error);

  // Negative half sector in phi
  BOOST_CHECK_THROW(CylinderBounds(radius, halfz, -halfphi, averagePhi),
                    std::logic_error);

  // Half sector in phi out of bounds
  BOOST_CHECK_THROW(CylinderBounds(radius, halfz, 4., averagePhi),
                    std::logic_error);

  // Phi position out of bounds
  BOOST_CHECK_THROW(CylinderBounds(radius, halfz, halfphi, 4.),
                    std::logic_error);
}

BOOST_AUTO_TEST_CASE_EXPECTED_FAILURES(CylinderBoundsProperties, 4)
BOOST_AUTO_TEST_CASE(CylinderBoundsProperties) {
  // CylinderBounds object of radius 0.5 and halfz 20
  double nominalRadius{0.5};
  double nominalHalfLength{20.};
  double halfphi(M_PI / 4.0);
  double averagePhi(0.0);
  CylinderBounds cylinderBoundsObject(nominalRadius, nominalHalfLength);
  CylinderBounds cylinderBoundsSegment(nominalRadius, nominalHalfLength,
                                       halfphi, averagePhi);

  BOOST_CHECK_EQUAL(cylinderBoundsObject.type(), SurfaceBounds::eCylinder);

  const Vector2D origin{0., 0.};
  const Vector2D atPiBy2{M_PI / 2., 0.0};
  const Vector2D atPi{M_PI, 0.0};
  const Vector2D beyondEnd{0, 30.0};
  const Vector2D unitZ{0.0, 1.0};
  const Vector2D unitPhi{1.0, 0.0};
  const BoundaryCheck trueBoundaryCheckWithTolerance(true, true, 0.1, 0.1);
  BOOST_CHECK(
      cylinderBoundsObject.inside(atPiBy2, trueBoundaryCheckWithTolerance));
  BOOST_CHECK(
      !cylinderBoundsSegment.inside(unitPhi, trueBoundaryCheckWithTolerance));
  BOOST_CHECK(
      cylinderBoundsObject.inside(origin, trueBoundaryCheckWithTolerance));

  const Vector3D origin3D{0., 0., 0.};
  BOOST_CHECK(
      !cylinderBoundsObject.inside3D(origin3D, trueBoundaryCheckWithTolerance));

  CHECK_CLOSE_REL(cylinderBoundsObject.distanceToBoundary(origin), 0.5,
                  1e-6);  // fail
  CHECK_CLOSE_REL(cylinderBoundsObject.distanceToBoundary(beyondEnd), 10.0,
                  1e-6);  // pass
  double sinPiBy8 = std::sin(M_PI / 8.);
  CHECK_CLOSE_REL(cylinderBoundsSegment.distanceToBoundary(atPi), sinPiBy8,
                  1e-6);  // pass
  CHECK_CLOSE_REL(cylinderBoundsSegment.distanceToBoundary(origin), 0.5,
                  1e-6);  // fail

  CHECK_CLOSE_REL(cylinderBoundsObject.get(CylinderBounds::eR), nominalRadius,
                  1e-6);

  CHECK_CLOSE_REL(cylinderBoundsObject.get(CylinderBounds::eAveragePhi),
                  averagePhi, 1e-6);

  CHECK_CLOSE_REL(cylinderBoundsSegment.get(CylinderBounds::eHalfPhiSector),
                  halfphi,
                  1e-6);  // fail

  CHECK_CLOSE_REL(cylinderBoundsObject.get(CylinderBounds::eHalfLengthZ),
                  nominalHalfLength, 1e-6);

  boost::test_tools::output_test_stream dumpOuput;
  cylinderBoundsObject.toStream(dumpOuput);
  BOOST_CHECK(dumpOuput.is_equal(
      "Acts::CylinderBounds: (radius, halfLengthZ, halfPhiSector, "
      "averagePhi) = (0.5000000, 20.0000000, 3.1415927, 0.0000000)"));
}
BOOST_AUTO_TEST_CASE(CylinderBoundsAssignment) {
  double nominalRadius{0.5};
  double nominalHalfLength{20.};
  CylinderBounds cylinderBoundsObject(nominalRadius, nominalHalfLength);
  CylinderBounds assignedCylinderBounds(10.5, 6.6);
  assignedCylinderBounds = cylinderBoundsObject;
  BOOST_CHECK_EQUAL(assignedCylinderBounds.get(CylinderBounds::eR),
                    cylinderBoundsObject.get(CylinderBounds::eR));
  BOOST_CHECK_EQUAL(assignedCylinderBounds, cylinderBoundsObject);
}

BOOST_AUTO_TEST_SUITE_END()

}  // namespace Test

}  // namespace Acts