Revert "Removed the trailing f in floating point numbers."

This reverts commit 95cbb93.

Author: wermos

core/include/detray/builders/bin_fillers.hpp

@@ -128,7 +128,7 @@ struct bin_associator {
         // Fill the surfaces into the grid by matching their contour onto the
         // grid bins
         bin_association(ctx, surfaces, transforms, masks, grid,
-                        darray<scalar_t, 2>{0.1, 0.1}, false);
+                        darray<scalar_t, 2>{0.1f, 0.1f}, false);
     }
 };
 

core/include/detray/builders/cuboid_portal_generator.hpp

@@ -117,7 +117,7 @@ class cuboid_portal_generator final
 
         // Max distance in case of infinite bounds
         constexpr scalar_type max_shift{
-            0.01 * std::numeric_limits<scalar_type>::max()};
+            0.01f * std::numeric_limits<scalar_type>::max()};
 
         // The bounding boxes around the module surfaces
         std::vector<aabb_t> boxes;
@@ -139,7 +139,7 @@ class cuboid_portal_generator final
         const point3_t box_max = world_box.template loc_max<point3_t>();
 
         // Get the half lengths for the rectangle sides and translation
-        const point3_t h_lengths = 0.5 * (box_max - box_min);
+        const point3_t h_lengths = 0.5f * (box_max - box_min);
         const scalar_type h_x{math::fabs(h_lengths[0])};
         const scalar_type h_y{math::fabs(h_lengths[1])};
         const scalar_type h_z{math::fabs(h_lengths[2])};
@@ -160,7 +160,7 @@ class cuboid_portal_generator final
                                                   h_x, h_y);
 
         // No rotation, but shift in z for both faces
-        vector3_t shift{0., 0.,
+        vector3_t shift{0.f, 0.f,
                         detail::is_invalid_value(h_z) ? max_shift : h_z};
         transforms.emplace_back(ctx, static_cast<vector3_t>(center + shift));
         transforms.emplace_back(ctx, static_cast<vector3_t>(center - shift));
@@ -183,9 +183,9 @@ class cuboid_portal_generator final
                                                   h_x, h_z);
 
         // Rotate by 90deg around x-axis, plus shift in y
-        shift = {0., detail::is_invalid_value(h_y) ? max_shift : h_y, 0.};
-        vector3_t new_x{1., 0., 0.};
-        vector3_t new_z{0., -1., 0.};
+        shift = {0.f, detail::is_invalid_value(h_y) ? max_shift : h_y, 0.f};
+        vector3_t new_x{1.f, 0.f, 0.f};
+        vector3_t new_z{0.f, -1.f, 0.f};
         transforms.emplace_back(ctx, static_cast<vector3_t>(center + shift),
                                 new_z, new_x);
         transforms.emplace_back(ctx, static_cast<vector3_t>(center - shift),
@@ -207,9 +207,9 @@ class cuboid_portal_generator final
                                                   h_z, h_y);
 
         // Rotate by 90deg around y-axis, plus shift in x
-        shift = {detail::is_invalid_value(h_x) ? max_shift : h_x, 0., 0.};
-        new_x = {0., 0., -1.};
-        new_z = {1., 0., 0.};
+        shift = {detail::is_invalid_value(h_x) ? max_shift : h_x, 0.f, 0.f};
+        new_x = {0.f, 0.f, -1.f};
+        new_z = {1.f, 0.f, 0.f};
         transforms.emplace_back(ctx, static_cast<vector3_t>(center + shift),
                                 new_z, new_x);
         transforms.emplace_back(ctx, static_cast<vector3_t>(center - shift),

core/include/detray/builders/cylinder_portal_generator.hpp

@@ -33,13 +33,13 @@ struct cylinder_portal_config {
     /// Autofit the lower/upper z extend and inner/outer radii
     bool m_do_autofit{true};
     /// Minimal envelope for the portals (used in autofitting)
-    scalar_t m_envelope{100. * unit<scalar_t>::um};
+    scalar_t m_envelope{100.f * unit<scalar_t>::um};
     /// Fixed inner radius during autofit
-    scalar_t m_fixed_inner_r{0.};
+    scalar_t m_fixed_inner_r{0.f};
     /// Fixed outer radius during autofit
-    scalar_t m_fixed_outer_r{0.};
+    scalar_t m_fixed_outer_r{0.f};
     /// Fixed length of the cylinder
-    scalar_t m_fixed_z{0.};
+    scalar_t m_fixed_z{0.f};
     /// The portal volumes links (north, south, east, west)
     std::vector<dindex> m_volume_links{dindex_invalid, dindex_invalid,
                                        dindex_invalid, dindex_invalid};
@@ -137,10 +137,10 @@ class cylinder_portal_generator final
     public:
     /// Save the boundaries of the cylinder after autofitting the portals
     struct boundaries {
-        scalar_t inner_radius{0.};
-        scalar_t outer_radius{0.};
-        scalar_t lower_z{0.};
-        scalar_t upper_z{0.};
+        scalar_t inner_radius{0.f};
+        scalar_t outer_radius{0.f};
+        scalar_t lower_z{0.f};
+        scalar_t upper_z{0.f};
     };
 
     /// Construct from configuration @param cfg
@@ -194,9 +194,9 @@ class cylinder_portal_generator final
 
         if (!m_cfg.do_autofit()) {
             // Without autofit, the portal bounds have to be given explicitly
-            assert(!(m_cfg.fixed_inner_radius() == 0. &&
-                     m_cfg.fixed_outer_radius() == 0.) ||
-                   m_cfg.fixed_half_length() != 0.);
+            assert(!(m_cfg.fixed_inner_radius() == 0.f &&
+                     m_cfg.fixed_outer_radius() == 0.f) ||
+                   m_cfg.fixed_half_length() != 0.f);
         } else {
             // Need surfaces in volume to do autofit
             assert(n_surfaces != 0u);
@@ -228,7 +228,7 @@ class cylinder_portal_generator final
             const point3_t box_max = world_box.template loc_max<point3_t>();
 
             // Get the half lengths for the cylinder height and disc translation
-            const point3_t h_lengths = 0.5 * (box_max - box_min);
+            const point3_t h_lengths = 0.5f * (box_max - box_min);
             const scalar_t h_x{math::fabs(h_lengths[0])};
             const scalar_t h_y{math::fabs(h_lengths[1])};
             const scalar_t h_z{math::fabs(h_lengths[2])};
@@ -243,13 +243,13 @@ class cylinder_portal_generator final
         }
 
         // Observe boundary conditions
-        if (m_cfg.fixed_inner_radius() > 0.) {
+        if (m_cfg.fixed_inner_radius() > 0.f) {
             inner_r = m_cfg.fixed_inner_radius();
         }
-        if (m_cfg.fixed_outer_radius() > 0.) {
+        if (m_cfg.fixed_outer_radius() > 0.f) {
             outer_r = m_cfg.fixed_outer_radius();
         }
-        if (m_cfg.fixed_half_length() > 0.) {
+        if (m_cfg.fixed_half_length() > 0.f) {
             lower_z = -m_cfg.fixed_half_length();
             upper_z = m_cfg.fixed_half_length();
         }
@@ -295,7 +295,7 @@ class cylinder_portal_generator final
         const scalar_t max_z{math::max(lower_z, upper_z)};
 
         // translation
-        const point3_t tsl{0., 0., 0.};
+        const point3_t tsl{0.f, 0.f, 0.f};
 
         // Add transform and mask data
         transforms.emplace_back(ctx, tsl);
@@ -335,7 +335,7 @@ class cylinder_portal_generator final
         const scalar_t max_r{math::max(inner_r, outer_r)};
 
         // translation
-        point3_t tsl{0., 0., z};
+        point3_t tsl{0.f, 0.f, z};
 
         // Add transform and mask data
         transforms.emplace_back(ctx, tsl);

core/include/detray/builders/detail/associator.hpp

@@ -38,11 +38,11 @@ struct center_of_gravity_rectangle {
         using point2_t = dpoint2D<algebra_t>;
 
         // Check if centre of gravity is inside bin
-        point2_t cgs = {0., 0.};
+        point2_t cgs = {0.f, 0.f};
         for (const auto &svtx : surface_contour) {
             cgs = cgs + svtx;
         }
-        cgs = 1. / static_cast<scalar_t>(surface_contour.size()) * cgs;
+        cgs = 1.f / static_cast<scalar_t>(surface_contour.size()) * cgs;
         scalar_t min_l0 = std::numeric_limits<scalar_t>::max();
         scalar_t max_l0 = -std::numeric_limits<scalar_t>::max();
         scalar_t min_l1 = std::numeric_limits<scalar_t>::max();
@@ -80,11 +80,11 @@ struct center_of_gravity_generic {
         using point2_t = dpoint2D<algebra_t>;
 
         // Check if centre of gravity is inside bin
-        point2_t cgs = {0., 0.};
+        point2_t cgs = {0.f, 0.f};
         for (const auto &svtx : surface_contour) {
             cgs = cgs + svtx;
         }
-        cgs = 1. / static_cast<scalar_t>(surface_contour.size()) * cgs;
+        cgs = 1.f / static_cast<scalar_t>(surface_contour.size()) * cgs;
 
         std::size_t i = 0u;
         std::size_t j = 0u;
@@ -126,14 +126,14 @@ struct edges_intersect_generic {
             scalar_t d = (pj[0] - pi[0]) * (pl[1] - pk[1]) -
                          (pj[1] - pi[1]) * (pl[0] - pk[0]);
 
-            if (d != 0.) {
+            if (d != 0.f) {
                 double r = ((pi[1] - pk[1]) * (pl[0] - pk[0]) -
                             (pi[0] - pk[0]) * (pl[1] - pk[1])) /
                            d;
                 double s = ((pi[1] - pk[1]) * (pj[0] - pi[0]) -
                             (pi[0] - pk[0]) * (pj[1] - pi[1])) /
                            d;
-                if (r >= 0. && r <= 1. && s >= 0. && s <= 1.) {
+                if (r >= 0.f && r <= 1.f && s >= 0.f && s <= 1.f) {
                     return true;
                 }
             }

core/include/detray/builders/detail/bin_association.hpp

@@ -200,7 +200,7 @@ static inline void bin_association(const context_t & /*context*/,
                                 phi_min = math::min(phi, phi_min);
                                 phi_max = math::max(phi, phi_max);
                                 surface_contour.push_back({vg[2], phi});
-                                if (phi < 0.) {
+                                if (phi < 0.f) {
                                     s_c_neg.push_back({vg[2], phi});
                                     z_min_neg = math::min(vg[2], z_min_neg);
                                     z_max_neg = math::max(vg[2], z_max_neg);
@@ -214,7 +214,7 @@ static inline void bin_association(const context_t & /*context*/,
                             std::vector<std::vector<point2_t>>
                                 surface_contours{};
                             if (phi_max - phi_min > constant<scalar_t>::pi &&
-                                phi_max * phi_min < 0.) {
+                                phi_max * phi_min < 0.f) {
                                 s_c_neg.push_back(
                                     {z_max_neg, -constant<scalar_t>::pi});
                                 s_c_neg.push_back(

core/include/detray/builders/detail/portal_accessor.hpp

@@ -32,8 +32,8 @@ auto get_cylinder_portals(const tracking_volume<detector_t> &vol) {
     std::vector<const typename detector_t::volume_type &> inner_pt{},
         outer_pt{}, lower_pt{}, upper_pr{};
 
-    std::map<const typename detector_t::surface_type &, scalar_t> radii{0.};
-    std::map<const typename detector_t::surface_type &, scalar_t> z_pos{0.};
+    std::map<const typename detector_t::surface_type &, scalar_t> radii{0.f};
+    std::map<const typename detector_t::surface_type &, scalar_t> z_pos{0.f};
 
     // Loop over all portals
     for (const auto &pt_desc : vol.portals()) {

core/include/detray/builders/detector_builder.hpp

@@ -123,16 +123,22 @@ class detector_builder {
 
             // TODO: Construct it correctly with the grid builder
             mask<cylinder3D, algebra_type> vgrid_dims{
+<<<<<<< HEAD
                 0u,     0.,   -constant<scalar_type>::pi,
                 -2000., 180., constant<scalar_type>::pi,
                 2000.};
+=======
+                0u,      0.f,   -constant<scalar_type>::pi,
+                -2000.f, 180.f, constant<scalar_type>::pi,
+                2000.f};
+>>>>>>> parent of 95cbb93f (Removed the trailing `f` in floating point numbers.)
             darray<std::size_t, 3> n_vgrid_bins{1u, 1u, 1u};
 
             darray<std::vector<scalar_type>, 3UL> bin_edges{
-                std::vector<scalar_type>{0., 180.},
+                std::vector<scalar_type>{0.f, 180.f},
                 std::vector<scalar_type>{-constant<scalar_type>::pi,
                                          constant<scalar_type>::pi},
-                std::vector<scalar_type>{-2000., 2000.}};
+                std::vector<scalar_type>{-2000.f, 2000.f}};
 
             grid_factory_type<vol_finder_t> vgrid_factory{};
             m_vol_finder = vgrid_factory.template new_grid<

core/include/detray/builders/homogeneous_material_generator.hpp

@@ -33,7 +33,7 @@ struct hom_material_config {
     /// Type of material to put on the portal surfaces
     material<scalar_t> m_portal_material{vacuum<scalar_t>{}};
     /// Minimal envelope for the portals (used in autofitting)
-    scalar_t m_thickness{1.5 * unit<scalar_t>::mm};
+    scalar_t m_thickness{1.5f * unit<scalar_t>::mm};
 
     /// Setters
     /// @{

core/include/detray/builders/material_map_generator.hpp

@@ -44,7 +44,7 @@ inline std::vector<material_slab<scalar_t>> generate_cyl_mat(
     // Make sure the cylinder bounds are centered around zero
     const scalar_t length{math::fabs(bounds[cylinder2D::e_upper_z] -
                                      bounds[cylinder2D::e_lower_z])};
-    scalar_t z{-0.5 * length};
+    scalar_t z{-0.5f * length};
     const scalar_t z_step{length / static_cast<scalar_t>(nbins - 1u)};
     for (std::size_t n = 0u; n < nbins; ++n) {
         ts.emplace_back(mat, static_cast<scalar_t>(scalor * z * z) + t);
@@ -92,9 +92,9 @@ struct material_map_config {
         /// Material to be filled into the maps
         material<scalar_t> mapped_material{silicon_tml<scalar_t>()};
         /// Minimal thickness of the material slabs in the material maps
-        scalar_t thickness{0.15 * unit<scalar_t>::mm};
+        scalar_t thickness{0.15f * unit<scalar_t>::mm};
         /// Scale factor for the material thickness calculation
-        scalar_t scalor{1.};
+        scalar_t scalor{1.f};
         /// How to vary the material thickness along the bins
         std::function<std::vector<material_slab<scalar_t>>(
             const std::vector<scalar_t> &, const std::size_t,

core/include/detray/geometry/coordinates/cartesian2D.hpp

@@ -59,7 +59,7 @@ struct cartesian2D {
     DETRAY_HOST_DEVICE static inline point3_type local_to_global(
         const transform3_type &trf, const mask_t & /*mask*/, const loc_point &p,
         const vector3_type & /*dir*/) {
-        return trf.point_to_global(point3_type{p[0], p[1], 0.});
+        return trf.point_to_global(point3_type{p[0], p[1], 0.f});
     }
 
     /// @returns the normal vector in global coordinates