surface intersection specialization

[asalzburger]

As there are no polymorphic types in the detector, different surface masks are accessed by their tuple index, i.e. in the navigator this looks like this.

The code looks a bit clumsy, can this be unrolled at compile time?

@paulgessinger @krasznaa @stephenswat - any ides?

        /** Actual kernel method that updates the updates the intersections
         * 
         * @tparam surface_type the type of surfaces to be processed
         * @tparam links_type the type of the links held by the masks
         * @tparam mask_type_map a mapping between indices and mask columsn in the tuple
         * @tparam mask_container the type of the tupled mask container
         * 
         * @param sfi is the surface intersection to be updated
         * @param links is the associated object link to be updated
         * @param track is the track information 
         * @param trf is the transform of surface 
         * @param surface  is the surface to be intersected
         * @param mask_types is the mapping between mask types and tuple entry
         * @param masks is the associated (and split out) mask group
         * @param trust is a boolean flag whether you can trust the last estimate already
         *
         * @return a boolean indicating if the update was successful
         **/
        template <typename surface_type, typename links_type, typename mask_type_map, typename mask_container>
        bool update_intersection(surface_intersection &sfi,
                                 links_type &links,
                                 track<transform_type> &track,
                                 const transform_type &trf,
                                 const surface_type &surface,
                                 const mask_type_map &mask_types,
                                 const mask_container &masks,
                                 bool trust = false)
        {
            const auto &typed_mask_range = surface.mask();
            if (std::get<0>(typed_mask_range) == 0)
            {
                const auto &mask_group = std::get<0>(masks);
                return update_intersection_by_mask(sfi, links, track, trf, cart2, mask_group, std::get<1>(typed_mask_range));
            }
            else if (std::get<0>(typed_mask_range) == 1)
            {
                const auto &mask_group = std::get<1>(masks);
                return update_intersection_by_mask(sfi, links, track, trf, cart2, mask_group, std::get<1>(typed_mask_range));
            }
            else if (std::get<0>(typed_mask_range) == 2)
            {
                const auto &mask_group = std::get<2>(masks);
                return update_intersection_by_mask(sfi, links, track, trf, cyl2, mask_group, std::get<1>(typed_mask_range));
            }
            else if (std::get<0>(typed_mask_range) == 3)
            {
                const auto &mask_group = std::get<3>(masks);
                return update_intersection_by_mask(sfi, links, track, trf, cart2, mask_group, std::get<1>(typed_mask_range));
            }
            return false;
        }

[paulgessinger]

You mean that the ifs are resolved? I think if the contents of the mask are not constexpr, I'm not sure if it's possible.

[stephenswat]

This is the kind of thing you'd want to solve with a macro system, but I'm guessing we don't really want to be using C++'s non-syntactic macro system here. The cleanest thing I can think of right now (and that's not really saying much in this case) is to abstract the logic inside the if-else conditions into some templated function, roughly like this:

template <typename surface_type, typename links_type, typename mask_type_map, typename mask_container>
bool update_intersection(
    surface_intersection &sfi,
    links_type &links,
    track<transform_type> &track,
    const transform_type &trf,
    const surface_type &surface,
    const mask_type_map &mask_types,
    const mask_container &masks,
    bool trust = false
) {
    auto h = [&]<int N>(auto tmr) -> std::optional<bool> {
        if (std::get<0>(tmr) != N) {
            return {};
        }

        const auto &mask_group = std::get<N>(masks);

        if constexpr (N == 2) {
            return update_intersection_by_mask(sfi, links, track, trf, cyl2, mask_group, std::get<1>(tmr));
        } else {
            return update_intersection_by_mask(sfi, links, track, trf, cart2, mask_group, std::get<1>(tmr));
        }
    }

    const auto &tmr = surface.mask();

    return h<0>(tmr).value_or(h<1>(tmr).value_or(h<2>(tmr).value_or(h<3>(tmr).value_or(false))));
}

Edit: Rather, because C++ doesn't do lazy evaluation:

if (auto v = h<0>(tmr), v) {
    return *v;
} else if (auto v = h<1>(tmr), v) {
    return *v;
} else if (auto v = h<2>(tmr), v) {
    return *v;
} else if (auto v = h<3>(tmr), v) {
    return *v;
} else {
    return false;
}

[asalzburger]

Thanks, for the answer, if you want you can try out a PR and we see if this makes it a bit more handy.

My intention is to do minimum code changes when a new mask is implemented ...