RadialBoundsTests.cpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file RadialBoundsTests.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/RadialBounds.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(RadialBoundsConstruction) {
  double minRadius(1.0), maxRadius(5.0), halfPhiSector(M_PI / 8.0);
  // test default construction
  // RadialBounds defaultConstructedRadialBounds;  should be deleted
  //
  BOOST_CHECK_EQUAL(RadialBounds(minRadius, maxRadius).type(),
                    SurfaceBounds::eDisc);
  //
  BOOST_CHECK_EQUAL(RadialBounds(minRadius, maxRadius, halfPhiSector).type(),
                    SurfaceBounds::eDisc);
  //
  RadialBounds original(minRadius, maxRadius);
  RadialBounds copied(original);
  BOOST_CHECK_EQUAL(copied, original);
}

// Streaning and recreation test
BOOST_AUTO_TEST_CASE(RadialBoundsRecreation) {
  double minRadius(1.0), maxRadius(5.0), halfPhiSector(M_PI / 8.0), avgPhi(0.1);
  RadialBounds original(minRadius, maxRadius, halfPhiSector, avgPhi);
  // const bool symmetric(false);
  auto valvector = original.values();
  std::array<double, RadialBounds::eSize> values;
  std::copy_n(valvector.begin(), RadialBounds::eSize, values.begin());
  RadialBounds recreated(values);
  BOOST_CHECK_EQUAL(original, recreated);
}

// Streaning and recreation test
BOOST_AUTO_TEST_CASE(RadialBoundsException) {
  double minRadius(1.0), maxRadius(5.0), halfPhiSector(M_PI / 8.0), avgPhi(0.1);

  // Negative inner radius
  BOOST_CHECK_THROW(RadialBounds(-minRadius, maxRadius, halfPhiSector, avgPhi),
                    std::logic_error);

  // Negative outer radius
  BOOST_CHECK_THROW(RadialBounds(minRadius, -maxRadius, halfPhiSector, avgPhi),
                    std::logic_error);

  // Negative inner and outer radius
  BOOST_CHECK_THROW(RadialBounds(-minRadius, -maxRadius, halfPhiSector, avgPhi),
                    std::logic_error);

  // Swapped radii
  BOOST_CHECK_THROW(RadialBounds(maxRadius, minRadius, halfPhiSector, avgPhi),
                    std::logic_error);

  // Out of bound phi sector
  BOOST_CHECK_THROW(RadialBounds(minRadius, -maxRadius, -5., avgPhi),
                    std::logic_error);

  // Out of bound phi position
  BOOST_CHECK_THROW(RadialBounds(minRadius, -maxRadius, halfPhiSector, 5.),
                    std::logic_error);
}

BOOST_AUTO_TEST_CASE(RadialBoundsProperties) {
  double minRadius(1.0), maxRadius(5.0), halfPhiSector(M_PI / 8.0);
  RadialBounds radialBoundsObject(minRadius, maxRadius, halfPhiSector);
  BOOST_CHECK_EQUAL(radialBoundsObject.type(), SurfaceBounds::eDisc);
  //
  Vector2D origin(0., 0.);
  Vector2D outside(30., 0.);
  Vector2D inSurface(2., 0.0);
  CHECK_CLOSE_REL(radialBoundsObject.distanceToBoundary(origin), 1.,
                  1e-6);  // makes sense
  CHECK_CLOSE_REL(radialBoundsObject.distanceToBoundary(outside), 25.,
                  1e-6);  // ok
  //
  boost::test_tools::output_test_stream dumpOuput;
  radialBoundsObject.toStream(dumpOuput);
  BOOST_CHECK(
      dumpOuput.is_equal("Acts::RadialBounds:  (innerRadius, outerRadius, "
                         "hPhiSector, averagePhi) = (1.0000000, "
                         "5.0000000, 0.3926991, 0.0000000)"));
  //
  BOOST_CHECK(radialBoundsObject.inside(inSurface, BoundaryCheck(true)));
  BOOST_CHECK(!radialBoundsObject.inside(outside, BoundaryCheck(true)));
  //
  BOOST_CHECK_EQUAL(radialBoundsObject.get(RadialBounds::eMinR), minRadius);
  //
  BOOST_CHECK_EQUAL(radialBoundsObject.get(RadialBounds::eMaxR), maxRadius);
  //
  BOOST_CHECK_EQUAL(radialBoundsObject.get(RadialBounds::eAveragePhi), 0.0);
  //
  BOOST_CHECK_EQUAL(radialBoundsObject.get(RadialBounds::eHalfPhiSector),
                    halfPhiSector);
}
BOOST_AUTO_TEST_CASE(RadialBoundsAssignment) {
  double minRadius(1.0), maxRadius(5.0), halfPhiSector(M_PI / 8.0);
  RadialBounds radialBoundsObject(minRadius, maxRadius, halfPhiSector);
  // operator == not implemented in this class
  //
  RadialBounds assignedRadialBoundsObject(10.1, 123.);
  assignedRadialBoundsObject = radialBoundsObject;
  BOOST_CHECK_EQUAL(assignedRadialBoundsObject, radialBoundsObject);
}

BOOST_AUTO_TEST_SUITE_END()

}  // namespace Test

}  // namespace Acts