DiscTrapezoidBoundsTests.cpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file DiscTrapezoidBoundsTests.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 "Acts/Definitions/Algebra.hpp"
#include "Acts/Surfaces/BoundaryCheck.hpp"
#include "Acts/Surfaces/DiscTrapezoidBounds.hpp"
#include "Acts/Surfaces/SurfaceBounds.hpp"
#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"

#include <algorithm>
#include <array>
#include <stdexcept>
#include <vector>

namespace Acts {

namespace Test {
BOOST_AUTO_TEST_SUITE(Surfaces)


BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsConstruction) {
  double minHalfX(1.0), maxHalfX(5.0), rMin(2.0), rMax(6.0), averagePhi(0.0),
      stereo(0.1);
  //
  BOOST_CHECK_EQUAL(
      DiscTrapezoidBounds(minHalfX, maxHalfX, rMin, rMax, averagePhi).type(),
      SurfaceBounds::eDiscTrapezoid);
  //
  BOOST_CHECK_EQUAL(
      DiscTrapezoidBounds(minHalfX, maxHalfX, rMin, rMax, averagePhi, stereo)
          .type(),
      SurfaceBounds::eDiscTrapezoid);
  //
  DiscTrapezoidBounds original(minHalfX, maxHalfX, rMin, rMax, averagePhi);
  DiscTrapezoidBounds copied(original);
  BOOST_CHECK_EQUAL(copied.type(), SurfaceBounds::eDiscTrapezoid);
}

// Streaning and recreation test
BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsRecreation) {
  double minHalfX(1.0), maxHalfX(5.0), rMin(2.0), rMax(6.0), averagePhi(0.0),
      stereo(0.1);

  DiscTrapezoidBounds original(minHalfX, maxHalfX, rMin, rMax, averagePhi,
                               stereo);
  auto valvector = original.values();
  std::array<double, DiscTrapezoidBounds::eSize> values{};
  std::copy_n(valvector.begin(), DiscTrapezoidBounds::eSize, values.begin());
  DiscTrapezoidBounds recreated(values);
  BOOST_CHECK_EQUAL(recreated, original);
}

// Unit tests for AnnulusBounds exception throwing
BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsExceptions) {
  double minHalfX(1.0), maxHalfX(5.0), rMin(2.0), rMax(6.0), averagePhi(0.0),
      stereo(0.1);

  // Exception for opening neg min half x < 0
  BOOST_CHECK_THROW(
      DiscTrapezoidBounds(-minHalfX, maxHalfX, rMin, rMax, averagePhi, stereo),
      std::logic_error);

  // Exception for opening neg max half x < 0
  BOOST_CHECK_THROW(
      DiscTrapezoidBounds(minHalfX, -maxHalfX, rMin, rMax, averagePhi, stereo),
      std::logic_error);

  // Exception for opening neg min and max half x < 0
  BOOST_CHECK_THROW(
      DiscTrapezoidBounds(-minHalfX, -maxHalfX, rMin, rMax, averagePhi, stereo),
      std::logic_error);

  // Exception for opening neg r min
  BOOST_CHECK_THROW(
      DiscTrapezoidBounds(minHalfX, maxHalfX, -rMin, rMax, averagePhi, stereo),
      std::logic_error);

  // Exception for opening neg r max
  BOOST_CHECK_THROW(
      DiscTrapezoidBounds(minHalfX, maxHalfX, rMin, -rMax, averagePhi, stereo),
      std::logic_error);

  // Exception for opening neg r min and r max
  BOOST_CHECK_THROW(
      DiscTrapezoidBounds(minHalfX, maxHalfX, -rMin, -rMax, averagePhi, stereo),
      std::logic_error);

  // Exception for out of bound average phi
  BOOST_CHECK_THROW(
      DiscTrapezoidBounds(minHalfX, maxHalfX, rMin, rMax, 4., stereo),
      std::logic_error);
}

BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsProperties) {
  double minHalfX(1.0), maxHalfX(5.0), rMin(2.0), rMax(6.0),
      averagePhi(0.0) /*, stereo(0.1)*/;
  DiscTrapezoidBounds DiscTrapezoidBoundsObject(minHalfX, maxHalfX, rMin, rMax,
                                                averagePhi);
  //
  BOOST_CHECK_EQUAL(DiscTrapezoidBoundsObject.type(),
                    SurfaceBounds::eDiscTrapezoid);
  //
  Vector2 origin(0., 0.);
  Vector2 outside(30., 0.);
  Vector2 inSurface(2.5, 0.0);
  //
  boost::test_tools::output_test_stream dumpOuput;
  DiscTrapezoidBoundsObject.toStream(dumpOuput);
  BOOST_CHECK(dumpOuput.is_equal(
      "Acts::DiscTrapezoidBounds: (innerRadius, outerRadius, halfLengthXminR, "
      "halfLengthXmaxR, halfLengthY, halfPhiSector, averagePhi, rCenter, "
      "stereo) = "
      "(2.0000000, 6.0000000, 1.0000000, 5.0000000, 0.7922870, 0.9851108, "
      "0.0000000, 2.5243378, 0.0000000)"));
  //
  BOOST_CHECK(DiscTrapezoidBoundsObject.inside(inSurface, BoundaryCheck(true)));
  BOOST_CHECK(!DiscTrapezoidBoundsObject.inside(outside, BoundaryCheck(true)));
  //
  CHECK_CLOSE_REL(DiscTrapezoidBoundsObject.rMin(), rMin, 1e-6);
  //
  CHECK_CLOSE_REL(DiscTrapezoidBoundsObject.rMax(), rMax, 1e-6);
  //
  CHECK_SMALL(DiscTrapezoidBoundsObject.get(DiscTrapezoidBounds::eAveragePhi),
              1e-9);
  //
  CHECK_CLOSE_REL(DiscTrapezoidBoundsObject.rCenter(), 2.524337798, 1e-6);
  //
  CHECK_SMALL(DiscTrapezoidBoundsObject.stereo(), 1e-6);
  //
  CHECK_CLOSE_REL(
      DiscTrapezoidBoundsObject.get(DiscTrapezoidBounds::eHalfLengthXminR),
      minHalfX, 1e-6);
  //
  CHECK_CLOSE_REL(
      DiscTrapezoidBoundsObject.get(DiscTrapezoidBounds::eHalfLengthXmaxR),
      maxHalfX, 1e-6);
  //
  CHECK_CLOSE_REL(DiscTrapezoidBoundsObject.halfLengthY(), 0.792286991, 1e-6);
}
BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsAssignment) {
  double minHalfX(1.0), maxHalfX(5.0), rMin(2.0), rMax(6.0), averagePhi(0.0),
      stereo(0.1);
  DiscTrapezoidBounds DiscTrapezoidBoundsObject(minHalfX, maxHalfX, rMin, rMax,
                                                averagePhi, stereo);
  // operator == not implemented in this class
  //
  DiscTrapezoidBounds assignedDiscTrapezoidBoundsObject(2.1, 6.6, 3.4, 4.2, 0.3,
                                                        0.);
  assignedDiscTrapezoidBoundsObject = DiscTrapezoidBoundsObject;
  BOOST_CHECK_EQUAL(assignedDiscTrapezoidBoundsObject,
                    DiscTrapezoidBoundsObject);
}

BOOST_AUTO_TEST_SUITE_END()

}  // namespace Test

}  // namespace Acts