unit_tests/io/io_json_payload.cpp

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 // Project include(s)
0010 #include "detray/definitions/geometry.hpp"
0011 #include "detray/definitions/grid_axis.hpp"
0012 #include "detray/definitions/units.hpp"
0013
0014 // Detray IO include(s)
0015 #include "detray/io/json/json_io.hpp"
0016
0017 // GTest include(s)
0018 #include <gtest/gtest.h>
0019
0020 /// This tests the json io for the general file header information
0021 GTEST_TEST(io, json_header_payload) {
0022   detray::io::header_payload<bool> h;
0023   h.common.version = "v0.0.1";
0024   h.common.detector = "test_detector";
0025   h.common.tag = "test_file";
0026   h.common.date = "01.01.2023";
0027
0028   nlohmann::ordered_json j;
0029   j["header"] = h;
0030
0031   detray::io::header_payload<bool> ph = j["header"];
0032
0033   EXPECT_EQ(h.common.version, ph.common.version);
0034   EXPECT_EQ(h.common.detector, ph.common.detector);
0035   EXPECT_EQ(h.common.tag, ph.common.tag);
0036   EXPECT_EQ(h.common.date, ph.common.date);
0037 }
0038
0039 /// This tests the json io for a single index link
0040 GTEST_TEST(io, single_link_payload) {
0041   detray::io::single_link_payload sl;
0042   sl.link = 3u;
0043
0044   nlohmann::ordered_json j;
0045   j["single_link"] = sl;
0046
0047   detray::io::single_link_payload psl = j["single_link"];
0048
0049   EXPECT_EQ(sl.link, psl.link);
0050 }
0051
0052 /// This tests the json io for a transform3
0053 GTEST_TEST(io, json_algebra_payload) {
0054   detray::io::transform_payload p;
0055   p.tr = {100.f, 200.f, 300.f};
0056   p.rot = {1.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 1.f};
0057
0058   nlohmann::ordered_json j;
0059   j["transform"] = p;
0060
0061   detray::io::transform_payload pt = j["transform"];
0062
0063   EXPECT_EQ(p.tr, pt.tr);
0064   EXPECT_EQ(p.rot, pt.rot);
0065 }
0066
0067 /// This tests the json io for a grid axis
0068 GTEST_TEST(io, json_axis_payload) {
0069   detray::io::axis_payload ea;
0070   ea.binning = detray::axis::binning::e_regular;
0071   ea.bounds = detray::axis::bounds::e_circular;
0072   ea.label = detray::axis::label::e_phi;
0073   ea.edges = {-detray::constant<detray::io::scalar>::pi,
0074               detray::constant<detray::io::scalar>::pi};
0075   ea.bins = 10UL;
0076
0077   nlohmann::ordered_json je;
0078   je["axis"] = ea;
0079
0080   detray::io::axis_payload pea = je["axis"];
0081
0082   EXPECT_EQ(ea.binning, pea.binning);
0083   EXPECT_EQ(ea.bounds, pea.bounds);
0084   EXPECT_EQ(ea.edges, pea.edges);
0085
0086   EXPECT_EQ(ea.bins, pea.bins);
0087
0088   detray::io::axis_payload va;
0089   va.binning = detray::axis::binning::e_irregular;
0090   va.bounds = detray::axis::bounds::e_closed;
0091   va.label = detray::axis::label::e_r;
0092   va.edges = {0.f, 1.f, 4.f, 5.f, 8.f, 10.f};
0093   va.bins = va.edges.size() - 1UL;
0094
0095   nlohmann::ordered_json jv;
0096   jv["axis"] = va;
0097
0098   detray::io::axis_payload pva = jv["axis"];
0099
0100   EXPECT_EQ(va.binning, pva.binning);
0101   EXPECT_EQ(va.bounds, pva.bounds);
0102   EXPECT_EQ(va.label, pva.label);
0103   EXPECT_EQ(va.edges, pva.edges);
0104   EXPECT_EQ(va.bins, pva.bins);
0105 }
0106
0107 /// This tests the json io for a grid bin
0108 GTEST_TEST(io, json_bin_payload) {
0109   detray::io::grid_bin_payload<> b;
0110   b.loc_index = std::vector<unsigned int>{1u, 0u, 2u};
0111   b.content = std::vector<std::size_t>{0u, 1u, 2u, 3u};
0112
0113   nlohmann::ordered_json jbin;
0114   jbin["bin"] = b;
0115
0116   detray::io::grid_bin_payload<> pb = jbin["bin"];
0117
0118   EXPECT_EQ(b.loc_index.size(), pb.loc_index.size());
0119   EXPECT_EQ(b.content.size(), pb.content.size());
0120 }
0121
0122 /// This tests the json io for a grid
0123 GTEST_TEST(io, json_grid_payload) {
0124   std::vector<detray::io::grid_bin_payload<>> bins = {
0125       {{0u, 1u}, {0u, 2u}}, {{1u, 1u}, {1u, 2u}}, {{2u, 1u}, {2u, 2u}}};
0126
0127   detray::io::axis_payload a0{detray::axis::binning::e_regular,
0128                               detray::axis::bounds::e_circular,
0129                               detray::axis::label::e_phi, 3u,
0130                               std::vector<detray::io::scalar>{
0131                                   -detray::constant<detray::io::scalar>::pi,
0132                                   detray::constant<detray::io::scalar>::pi}};
0133
0134   detray::io::axis_payload a1{
0135       detray::axis::binning::e_regular, detray::axis::bounds::e_closed,
0136       detray::axis::label::e_r, 2u, std::vector<detray::io::scalar>{0.f, 2.f}};
0137
0138   detray::io::grid_payload<> g;
0139   g.grid_link = {detray::io::grid_payload<>::grid_type::polar2_grid, 12u};
0140   g.owner_link = {2u};
0141   g.axes = {a0, a1};
0142   g.bins = bins;
0143
0144   nlohmann::ordered_json j;
0145   j["grid"] = g;
0146
0147   detray::io::grid_payload<> pg = j["grid"];
0148
0149   EXPECT_EQ(g.grid_link.type, pg.grid_link.type);
0150   EXPECT_EQ(g.grid_link.index, pg.grid_link.index);
0151   EXPECT_EQ(g.axes.size(), pg.axes.size());
0152   EXPECT_EQ(g.bins.size(), pg.bins.size());
0153 }
0154
0155 /// This tests the json io for a surface mask
0156 GTEST_TEST(io, json_mask_payload) {
0157   detray::io::single_link_payload sl;
0158   sl.link = 3u;
0159
0160   detray::io::mask_payload m;
0161   m.shape = detray::io::mask_payload::mask_shape::cylinder3;
0162   m.volume_link = sl;
0163   m.boundaries = {10.f, 100.f};
0164
0165   nlohmann::ordered_json j;
0166   j["mask"] = m;
0167
0168   detray::io::mask_payload pm = j["mask"];
0169
0170   EXPECT_EQ(m.shape, pm.shape);
0171   EXPECT_EQ(m.volume_link.link, pm.volume_link.link);
0172   EXPECT_EQ(m.boundaries, pm.boundaries);
0173 }
0174
0175 /// This tests the json io for a surface material link
0176 GTEST_TEST(io, json_material_link_payload) {
0177   detray::io::material_link_payload m;
0178   m.type = detray::io::material_link_payload::type_id::slab;
0179   m.index = 2u;
0180
0181   nlohmann::ordered_json j;
0182   j["material"] = m;
0183
0184   detray::io::material_link_payload pm = j["material"];
0185
0186   EXPECT_EQ(m.type, pm.type);
0187   EXPECT_EQ(m.index, pm.index);
0188 }
0189
0190 /// This tests the json payload for a surface (descriptor + data)
0191 GTEST_TEST(io, json_surface_payload) {
0192   detray::io::surface_payload s;
0193
0194   detray::io::transform_payload t;
0195   t.tr = {100.f, 200.f, 300.f};
0196   t.rot = {1.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 1.f};
0197
0198   detray::io::mask_payload m;
0199   detray::io::single_link_payload sl;
0200   sl.link = 1u;
0201   m.shape = detray::io::mask_payload::mask_shape::trapezoid2;
0202   m.volume_link = sl;
0203   m.boundaries = {10.f, 20.f, 34.f, 1.4f};
0204
0205   detray::io::material_link_payload mat;
0206   mat.type = detray::io::material_link_payload::type_id::slab;
0207   mat.index = 2u;
0208
0209   s.transform = t;
0210   s.masks = std::vector{m};
0211   s.type = detray::surface_id::e_passive;
0212   s.material = mat;
0213
0214   nlohmann::ordered_json j;
0215   j["surface"] = s;
0216
0217   detray::io::surface_payload ps = j["surface"];
0218
0219   EXPECT_EQ(s.transform.tr, ps.transform.tr);
0220   EXPECT_EQ(s.transform.rot, ps.transform.rot);
0221
0222   const auto& mask = s.masks.front();
0223   const auto& pmask = ps.masks.front();
0224   EXPECT_EQ(mask.shape, pmask.shape);
0225   EXPECT_EQ(mask.volume_link.link, pmask.volume_link.link);
0226   EXPECT_EQ(mask.boundaries, pmask.boundaries);
0227
0228   EXPECT_EQ(s.type, ps.type);
0229
0230   EXPECT_EQ(s.material.value().type, ps.material.value().type);
0231   EXPECT_EQ(s.material.value().index, ps.material.value().index);
0232 }
0233
0234 /// This tests the json io for a surface material link
0235 GTEST_TEST(io, acc_links_payload) {
0236   detray::io::acc_links_payload l;
0237   l.type = detray::io::acc_links_payload::type_id::cylinder2_grid;
0238   l.index = 2u;
0239
0240   nlohmann::ordered_json j;
0241   j["acc_link"] = l;
0242
0243   detray::io::acc_links_payload pl = j["acc_link"];
0244
0245   EXPECT_EQ(l.type, pl.type);
0246   EXPECT_EQ(l.index, pl.index);
0247 }
0248
0249 /// This tests the json payload for a volume (descriptor + data (transform,
0250 /// surfaces)
0251 GTEST_TEST(io, json_volume_payload) {
0252   detray::io::transform_payload t;
0253   t.tr = {100.f, 200.f, 300.f};
0254   t.rot = {1.f, 0.f, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 1.f};
0255
0256   detray::io::single_link_payload sl;
0257   sl.link = 1u;
0258
0259   detray::io::acc_links_payload al;
0260   al.type = detray::io::acc_links_payload::type_id::cylinder2_grid;
0261   al.index = 2u;
0262
0263   detray::io::surface_payload s;
0264
0265   detray::io::mask_payload m;
0266   m.shape = detray::io::mask_payload::mask_shape::trapezoid2;
0267   m.volume_link = sl;
0268   m.boundaries = {10.f, 20.f, 34.f, 1.4f};
0269
0270   detray::io::material_link_payload mat;
0271   mat.type = detray::io::material_link_payload::type_id::slab;
0272   mat.index = 2u;
0273
0274   s.transform = t;
0275   s.masks = {m};
0276   s.type = detray::surface_id::e_portal;
0277   s.material = mat;
0278
0279   detray::io::volume_payload v;
0280   v.name = "volume";
0281   v.type = detray::volume_id::e_cylinder;
0282   sl.link = 2u;
0283   v.index = sl;
0284   v.transform = t;
0285   v.surfaces = {s};
0286   v.acc_links = {al};
0287
0288   nlohmann::ordered_json j;
0289   j["volume"] = v;
0290
0291   detray::io::volume_payload pv = j["volume"];
0292
0293   EXPECT_EQ(v.name, pv.name);
0294   EXPECT_EQ(v.index.link, pv.index.link);
0295   EXPECT_EQ(v.transform.tr, v.transform.tr);
0296   EXPECT_EQ(v.transform.rot, v.transform.rot);
0297   EXPECT_EQ(v.type, pv.type);
0298   EXPECT_EQ(v.surfaces.size(), pv.surfaces.size());
0299   EXPECT_EQ(v.acc_links->size(), pv.acc_links->size());
0300 }
0301
0302 /// This tests the json io for a material slab/rod
0303 GTEST_TEST(io, json_surface_material_payload) {
0304   detray::io::surface_material_payload m;
0305   m.type = detray::io::surface_material_payload::mat_type::slab;
0306   m.index_in_coll = 21u;
0307   m.surface.link = 5u;
0308   m.thickness = 1.2f;
0309   m.mat.params = {1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f};
0310
0311   nlohmann::ordered_json j;
0312   j["material"] = m;
0313
0314   detray::io::surface_material_payload pm = j["material"];
0315
0316   EXPECT_EQ(m.type, pm.type);
0317   EXPECT_EQ(m.index_in_coll, pm.index_in_coll);
0318   EXPECT_EQ(m.surface.link, pm.surface.link);
0319   EXPECT_EQ(m.thickness, pm.thickness);
0320   EXPECT_EQ(m.mat.params, pm.mat.params);
0321 }
0322
0323 /// This tests the json io for a material slab
0324 GTEST_TEST(io, json_detector_payload) {
0325   detray::io::detector_payload d;
0326   d.volumes = {detray::io::volume_payload{}, detray::io::volume_payload{}};
0327
0328   nlohmann::ordered_json j;
0329   j["detector"] = d;
0330
0331   detray::io::detector_payload pd = j["detector"];
0332
0333   EXPECT_EQ(d.volumes.size(), pd.volumes.size());
0334 }