Plugins/Json/VolumeBoundsJsonConverterTests.cpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2022 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 http://mozilla.org/MPL/2.0/.
0008
0009 #include <boost/test/unit_test.hpp>
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Definitions/Units.hpp"
0013 #include "Acts/Geometry/ConeVolumeBounds.hpp"
0014 #include "Acts/Geometry/CuboidVolumeBounds.hpp"
0015 #include "Acts/Geometry/CutoutCylinderVolumeBounds.hpp"
0016 #include "Acts/Geometry/CylinderVolumeBounds.hpp"
0017 #include "Acts/Geometry/GenericCuboidVolumeBounds.hpp"
0018 #include "Acts/Geometry/TrapezoidVolumeBounds.hpp"
0019 #include "Acts/Plugins/Json/VolumeBoundsJsonConverter.hpp"
0020
0021 #include <algorithm>
0022 #include <array>
0023 #include <cmath>
0024 #include <fstream>
0025 #include <memory>
0026 #include <string>
0027 #include <vector>
0028
0029 #include <nlohmann/json.hpp>
0030
0031 using namespace Acts;
0032
0033 BOOST_AUTO_TEST_SUITE(VolumeBoundsJsonConversion)
0034
0035 BOOST_AUTO_TEST_CASE(Cuboid) {
0036   std::ofstream out("CuboidVolumeBounds.json");
0037
0038   auto cuboidRef = std::make_shared<const CuboidVolumeBounds>(2., 4., 6.);
0039   nlohmann::json cuboidOut = VolumeBoundsJsonConverter::toJson(*cuboidRef);
0040   out << cuboidOut.dump(2);
0041   out.close();
0042
0043   // Read in json file
0044   auto in = std::ifstream("CuboidVolumeBounds.json",
0045                           std::ifstream::in | std::ifstream::binary);
0046   BOOST_CHECK(in.good());
0047   nlohmann::json cuboidIn;
0048   in >> cuboidIn;
0049   in.close();
0050
0051   auto cuboidTest =
0052       VolumeBoundsJsonConverter::fromJson<CuboidVolumeBounds>(cuboidIn);
0053   BOOST_CHECK(cuboidRef->values() == cuboidTest->values());
0054 }
0055
0056 BOOST_AUTO_TEST_CASE(Cylinder) {
0057   std::ofstream out("CylinderVolumeBounds.json");
0058
0059   auto cylinderRef =
0060       std::make_shared<const CylinderVolumeBounds>(10., 20., 30., M_PI / 4, 0);
0061   nlohmann::json cylinderOut = VolumeBoundsJsonConverter::toJson(*cylinderRef);
0062   out << cylinderOut.dump(2);
0063   out.close();
0064
0065   // Read in json file
0066   auto in = std::ifstream("CylinderVolumeBounds.json",
0067                           std::ifstream::in | std::ifstream::binary);
0068   BOOST_CHECK(in.good());
0069   nlohmann::json cylinderIn;
0070   in >> cylinderIn;
0071   in.close();
0072
0073   auto cylinderTest =
0074       VolumeBoundsJsonConverter::fromJson<CylinderVolumeBounds>(cylinderIn);
0075   BOOST_CHECK(cylinderRef->values() == cylinderTest->values());
0076 }
0077
0078 BOOST_AUTO_TEST_CASE(Cone) {
0079   std::ofstream out("ConeVolumeBounds.json");
0080
0081   auto coneRef = std::make_shared<const ConeVolumeBounds>(0., 0., 0.45, 0.050,
0082                                                           0.050, 0., M_PI);
0083   nlohmann::json coneOut = VolumeBoundsJsonConverter::toJson(*coneRef);
0084   out << coneOut.dump(2);
0085   out.close();
0086
0087   // Read in json file
0088   auto in = std::ifstream("ConeVolumeBounds.json",
0089                           std::ifstream::in | std::ifstream::binary);
0090   BOOST_CHECK(in.good());
0091   nlohmann::json coneIn;
0092   in >> coneIn;
0093   in.close();
0094
0095   auto coneTest = VolumeBoundsJsonConverter::fromJson<ConeVolumeBounds>(coneIn);
0096   BOOST_CHECK(coneRef->values() == coneTest->values());
0097 }
0098
0099 BOOST_AUTO_TEST_CASE(CutoutCylinder) {
0100   std::ofstream out("CutoutCylinderVolumeBounds.json");
0101
0102   auto cutoutCylinderRef =
0103       std::make_shared<const CutoutCylinderVolumeBounds>(5, 10, 15, 30, 25);
0104   nlohmann::json cutoutCylinderOut =
0105       VolumeBoundsJsonConverter::toJson(*cutoutCylinderRef);
0106   out << cutoutCylinderOut.dump(2);
0107   out.close();
0108
0109   // Read in json file
0110   auto in = std::ifstream("CutoutCylinderVolumeBounds.json",
0111                           std::ifstream::in | std::ifstream::binary);
0112   BOOST_CHECK(in.good());
0113   nlohmann::json cutoutCylinderIn;
0114   in >> cutoutCylinderIn;
0115   in.close();
0116
0117   auto cutoutCylinderTest =
0118       VolumeBoundsJsonConverter::fromJson<CutoutCylinderVolumeBounds>(
0119           cutoutCylinderIn);
0120   BOOST_CHECK(cutoutCylinderRef->values() == cutoutCylinderTest->values());
0121 }
0122
0123 BOOST_AUTO_TEST_CASE(GenericCuboid) {
0124   std::ofstream out("GenericCuboidVolumeBounds.json");
0125   std::array<Vector3, 8> vertices;
0126   vertices = {{{0, 0, 0},
0127                {2, 0, 0},
0128                {2, 1, 0},
0129                {0, 1, 0},
0130                {0, 0, 1},
0131                {2, 0, 1},
0132                {2, 1, 1},
0133                {0, 1, 1}}};
0134
0135   auto genericCuboidRef =
0136       std::make_shared<const GenericCuboidVolumeBounds>(vertices);
0137   nlohmann::json genericCuboidOut =
0138       VolumeBoundsJsonConverter::toJson(*genericCuboidRef);
0139   out << genericCuboidOut.dump(2);
0140   out.close();
0141
0142   // Read in json file
0143   auto in = std::ifstream("GenericCuboidVolumeBounds.json",
0144                           std::ifstream::in | std::ifstream::binary);
0145   BOOST_CHECK(in.good());
0146   nlohmann::json genericCuboidIn;
0147   in >> genericCuboidIn;
0148   in.close();
0149
0150   auto genericCuboidTest = VolumeBoundsJsonConverter::fromJson(genericCuboidIn);
0151   BOOST_CHECK(genericCuboidRef->values() == genericCuboidTest->values());
0152 }
0153
0154 BOOST_AUTO_TEST_CASE(Trapezoid) {
0155   std::ofstream out("TrapezoidVolumeBounds.json");
0156
0157   auto trapezoidRef =
0158       std::make_shared<const TrapezoidVolumeBounds>(2., 4., 6., 8.);
0159   nlohmann::json trapezoidOut =
0160       VolumeBoundsJsonConverter::toJson(*trapezoidRef);
0161   out << trapezoidOut.dump(2);
0162   out.close();
0163
0164   // Read in json file
0165   auto in = std::ifstream("TrapezoidVolumeBounds.json",
0166                           std::ifstream::in | std::ifstream::binary);
0167   BOOST_CHECK(in.good());
0168   nlohmann::json trapezoidIn;
0169   in >> trapezoidIn;
0170   in.close();
0171
0172   auto trapezoidTest =
0173       VolumeBoundsJsonConverter::fromJson<TrapezoidVolumeBounds>(trapezoidIn);
0174   BOOST_CHECK(trapezoidRef->values() == trapezoidTest->values());
0175 }
0176 BOOST_AUTO_TEST_SUITE_END()