test/device/vector_fixture.hpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 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 https://mozilla.org/MPL/2.0/.
0008
0009 #pragma once
0010
0011 // Project include(s).
0012 #include "detray/definitions/detail/qualifiers.hpp"
0013
0014 // Test include(s).
0015 #include "detray/test/device/device_fixture.hpp"
0016 #include "detray/test/framework/types.hpp"
0017
0018 // VecMem include(s).
0019 #include <vecmem/containers/data/vector_view.hpp>
0020 #include <vecmem/containers/device_vector.hpp>
0021 #include <vecmem/containers/vector.hpp>
0022 #include <vecmem/memory/memory_resource.hpp>
0023
0024 // GoogleTest include(s).
0025 #include <gtest/gtest.h>
0026
0027 // System include(s).
0028 #include <cmath>
0029 #include <memory>
0030
0031 namespace detray::test {
0032
0033 /// Data fixture for device vector test cases
0034 template <detray::concepts::algebra A>
0035 class vector_fixture : public device_fixture<dscalar<A>> {
0036   using scalar_t = dscalar<A>;
0037   using point2_t = dpoint2D<A>;
0038   using vector3_t = dvector3D<A>;
0039
0040   using result_t = scalar_t;
0041   using base_fixture = device_fixture<result_t>;
0042
0043  public:
0044   /// Constructor, setting up the inputs for all of the tests
0045   vector_fixture(vecmem::memory_resource& mr) : base_fixture(mr) {}
0046
0047  protected:
0048   /// Function setting things up for a test
0049   virtual void SetUp() override {
0050     // Set up the result vectors
0051     base_fixture::SetUp();
0052
0053     // Set up the input vectors.
0054     m_p1 = std::make_unique<vecmem::vector<point2_t>>(this->size(),
0055                                                       &this->resource());
0056     m_p2 = std::make_unique<vecmem::vector<point2_t>>(this->size(),
0057                                                       &this->resource());
0058
0059     m_v1 = std::make_unique<vecmem::vector<vector3_t>>(this->size(),
0060                                                        &this->resource());
0061     m_v2 = std::make_unique<vecmem::vector<vector3_t>>(this->size(),
0062                                                        &this->resource());
0063
0064     // Initialise the input and output vectors.
0065     for (std::size_t i = 0; i < this->size(); ++i) {
0066       m_p1->at(i) = {static_cast<scalar_t>(i * 0.5),
0067                      static_cast<scalar_t>((i + 1) * 1.0)};
0068       m_p2->at(i) = {static_cast<scalar_t>((i + 2) * 1.2),
0069                      static_cast<scalar_t>(i * 0.6)};
0070
0071       m_v1->at(i) = {static_cast<scalar_t>(i * 0.6),
0072                      static_cast<scalar_t>((i + 1) * 1.2),
0073                      static_cast<scalar_t>((i + 2) * 1.3)};
0074       m_v2->at(i) = {static_cast<scalar_t>((i + 1) * 1.8),
0075                      static_cast<scalar_t>(i * 2.3),
0076                      static_cast<scalar_t>((i + 2) * 3.4)};
0077     }
0078   }
0079
0080   /// Function tearing things down after the test
0081   virtual void TearDown() override {
0082     // Delete the vectors.
0083     m_p1.reset();
0084     m_p2.reset();
0085     m_v1.reset();
0086     m_v2.reset();
0087
0088     // Tear down the base class.
0089     base_fixture::TearDown();
0090   }
0091
0092   /// @name Inputs for the tests
0093   /// @{
0094
0095   std::unique_ptr<vecmem::vector<point2_t>> m_p1, m_p2;
0096   std::unique_ptr<vecmem::vector<vector3_t>> m_v1, m_v2;
0097
0098   /// @}
0099
0100 };  // class device_fixture
0101
0102 /// Functor running @c test_device_basics::vector_2d_ops
0103 template <detray::concepts::algebra A>
0104 class vector_2d_ops_functor {
0105   using scalar_t = dscalar<A>;
0106   using point2_t = dpoint2D<A>;
0107
0108  public:
0109   DETRAY_HOST_DEVICE void operator()(
0110       std::size_t i, vecmem::data::vector_view<const point2_t> a,
0111       vecmem::data::vector_view<const point2_t> b,
0112       vecmem::data::vector_view<scalar_t> output) const {
0113     // Create the VecMem vector(s).
0114     vecmem::device_vector<const point2_t> vec_a(a), vec_b(b);
0115     vecmem::device_vector<scalar_t> vec_output(output);
0116
0117     // Perform the operation.
0118     auto ii = static_cast<typename decltype(vec_output)::size_type>(i);
0119     vec_output[ii] = vector_2d_ops(vec_a[ii], vec_b[ii]);
0120   }
0121
0122  private:
0123   /// Perform various 2D vector operations, and produce a scalar output
0124   DETRAY_HOST_DEVICE
0125   scalar_t vector_2d_ops(point2_t a, point2_t b) const {
0126     point2_t c = a + b;
0127     point2_t c2 = c * 2.0;
0128
0129     scalar_t phi = detray::vector::phi(c2);
0130     scalar_t perp = detray::vector::perp(c2);
0131     scalar_t norm1 = detray::vector::norm(c2);
0132
0133     scalar_t dot = detray::vector::dot(a, b);
0134     point2_t norm2 = detray::vector::normalize(c);
0135     scalar_t norm3 = detray::vector::norm(norm2);
0136
0137     return (phi + perp + norm1 + dot + norm3);
0138   }
0139 };
0140
0141 /// Functor running @c test_device_basics::vector_3d_ops
0142 template <detray::concepts::algebra A>
0143 class vector_3d_ops_functor {
0144   using scalar_t = dscalar<A>;
0145   using vector3_t = dvector3D<A>;
0146
0147  public:
0148   DETRAY_HOST_DEVICE void operator()(
0149       std::size_t i, vecmem::data::vector_view<const vector3_t> a,
0150       vecmem::data::vector_view<const vector3_t> b,
0151       vecmem::data::vector_view<scalar_t> output) const {
0152     // Create the VecMem vector(s).
0153     vecmem::device_vector<const vector3_t> vec_a(a), vec_b(b);
0154     vecmem::device_vector<scalar_t> vec_output(output);
0155
0156     // Perform the operation.
0157     auto ii = static_cast<typename decltype(vec_output)::size_type>(i);
0158     vec_output[ii] = vector_3d_ops(vec_a[ii], vec_b[ii]);
0159   }
0160
0161  private:
0162   /// Perform various 3D vector operations, and produce a scalar output
0163   DETRAY_HOST_DEVICE
0164   scalar_t vector_3d_ops(vector3_t a, vector3_t b) const {
0165     vector3_t c = a + b;
0166     vector3_t c2 = c * 2.0;
0167
0168     scalar_t phi = detray::vector::phi(c2);
0169     scalar_t perp = detray::vector::perp(c2);
0170     scalar_t norm1 = detray::vector::norm(c2);
0171
0172     vector3_t d = detray::vector::cross(a, b);
0173
0174     scalar_t dot = detray::vector::dot(a, d);
0175     vector3_t norm2 = detray::vector::normalize(c);
0176     scalar_t norm3 = detray::vector::norm(norm2);
0177
0178     return (phi + perp + norm1 + dot + norm3);
0179   }
0180 };
0181
0182 }  // namespace detray::test