fittable_type_generator.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file fittable_type_generator.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include <variant>
#include "Acts/Utilities/ParameterDefinitions.hpp"

#include <type_traits>

// clang-format off
#include <boost/hana/append.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/range.hpp>
#include <boost/hana/remove_at.hpp>
#include <boost/hana/transform.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/filter.hpp>
// This include is technically not needed for this file, but removing it
// introduces some form of order dependency on subsequent include.
#include <boost/hana/set.hpp>
#include <boost/hana/type.hpp>
// clang-format on

namespace Acts {

namespace detail {

namespace hana = boost::hana;

template <size_t W>
constexpr auto unique_ordered_sublists() {
  using namespace hana::literals;
  // generate an empty tuple to start off
  constexpr auto combinations = hana::make_tuple(hana::make_tuple());
  // generate range over which to fold
  constexpr auto w_range =
      hana::to_tuple(hana::make_range(0_c, hana::size_c<W>));
  // main fold expression. This successively adds variations to `state` and
  // then
  // returns the result.
  constexpr auto comb2 =
      hana::fold_left(w_range, combinations, [](auto state, auto i) {
        auto mapped = hana::transform(
            state, [i](auto c_i) { return hana::append(c_i, i); });
        return hana::concat(state, mapped);
      });
  // we need to pop off the initial empty tuple, which isn't really valid
  return hana::remove_at(comb2, 0_c);
}

template <template <ParID_t...> class meas_meta, size_t W>
constexpr auto type_generator() {
  // generate sublists
  constexpr auto sublists = unique_ordered_sublists<W>();
  // map each sublist (tuple of paramater indices) into a measurement using
  // the provided `meas_meta` metafunction.
  constexpr auto measurements_h = hana::transform(sublists, [](auto s) {
    return hana::unpack(s, [](auto... i) {
      return hana::type_c<
          typename meas_meta<ParID_t(decltype(i)::value)...>::type>;
    });
  });
  // return tuple of measurements
  return measurements_h;
}

template <template <ParID_t...> class meas_meta, size_t W>
using type_generator_t = typename decltype(hana::unpack(
    type_generator<meas_meta, W>(), hana::template_<std::variant>))::type;

}  // namespace detail
}  // namespace Acts