LineBoundsTests.cpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file LineBoundsTests.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/Surfaces/LineBounds.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(LineBoundsConstruction) {
  double radius(0.5), halfz(10.);
  LineBounds lineBounds(radius, halfz);
  BOOST_CHECK_EQUAL(lineBounds.type(), SurfaceBounds::eLine);
  LineBounds copyConstructedLineBounds(lineBounds);  // implicit
  BOOST_CHECK_EQUAL(copyConstructedLineBounds.type(), SurfaceBounds::eLine);
}

BOOST_AUTO_TEST_CASE(LineBoundsRecreation) {
  double nominalRadius{0.5};
  double nominalHalfLength{20.};
  LineBounds original(nominalRadius, nominalHalfLength);
  LineBounds recreated(original);
  auto valvector = original.values();
  std::array<double, LineBounds::eSize> values;
  std::copy_n(valvector.begin(), LineBounds::eSize, values.begin());
  BOOST_CHECK_EQUAL(original, recreated);
}

BOOST_AUTO_TEST_CASE(LineBoundsExceptions) {
  double nominalRadius{0.5};
  double nominalHalfLength{20.};
  // Negative radius
  BOOST_CHECK_THROW(LineBounds(-nominalRadius, nominalHalfLength),
                    std::logic_error);
  // Negative half length
  BOOST_CHECK_THROW(LineBounds(nominalRadius, -nominalHalfLength),
                    std::logic_error);

  // Negative radius and half length
  BOOST_CHECK_THROW(LineBounds(-nominalRadius, -nominalHalfLength),
                    std::logic_error);
}

BOOST_AUTO_TEST_CASE(LineBoundsAssignment) {
  double nominalRadius{0.5};
  double nominalHalfLength{20.};
  LineBounds lineBoundsObject(nominalRadius, nominalHalfLength);
  LineBounds assignedLineBounds = lineBoundsObject;
  BOOST_CHECK_EQUAL(assignedLineBounds, lineBoundsObject);
}

BOOST_AUTO_TEST_CASE(LineBoundsProperties) {
  // LineBounds object of radius 0.5 and halfz 20
  double nominalRadius{0.5};
  double nominalHalfLength{20.};
  LineBounds lineBoundsObject(nominalRadius, nominalHalfLength);

  BOOST_CHECK_EQUAL(lineBoundsObject.type(), SurfaceBounds::eLine);

  const Vector2D origin{0., 0.};
  const Vector2D atRadius{0.5, 10.};
  const Vector2D beyondEnd{0.0, 30.0};
  const Vector2D unitZ{0.0, 1.0};
  const Vector2D unitR{1.0, 0.0};
  const BoundaryCheck trueBoundaryCheckWithTolerance(true, true, 0.1, 0.1);
  // This fails because the bounds are not inclusive.
  BOOST_CHECK(
      !lineBoundsObject.inside(atRadius, trueBoundaryCheckWithTolerance));
  BOOST_CHECK(
      !lineBoundsObject.inside(beyondEnd, trueBoundaryCheckWithTolerance));
  BOOST_CHECK(lineBoundsObject.inside(unitZ, trueBoundaryCheckWithTolerance));
  BOOST_CHECK(!lineBoundsObject.inside(unitR, trueBoundaryCheckWithTolerance));


  BOOST_CHECK(lineBoundsObject.inside(Vector2D{-0.2, 10},
                                      trueBoundaryCheckWithTolerance));
  BOOST_CHECK(!lineBoundsObject.inside(Vector2D{-0.8, 10},
                                       trueBoundaryCheckWithTolerance));

  BOOST_CHECK_EQUAL(lineBoundsObject.get(LineBounds::eR), nominalRadius);

  BOOST_CHECK_EQUAL(lineBoundsObject.get(LineBounds::eHalfLengthZ),
                    nominalHalfLength);

  boost::test_tools::output_test_stream dumpOuput;
  lineBoundsObject.toStream(dumpOuput);
  BOOST_CHECK(dumpOuput.is_equal(
      "Acts::LineBounds: (radius, halflengthInZ) = (0.5000000, 20.0000000)"));
}

BOOST_AUTO_TEST_SUITE_END()

}  // namespace Test

}  // namespace Acts