backend/transformer/covariant_select.hpp

0001 /*
0002  * SPDX-PackageName: "covfie, a part of the ACTS project"
0003  * SPDX-FileCopyrightText: 2022 CERN
0004  * SPDX-License-Identifier: MPL-2.0
0005  */
0006
0007 #pragma once
0008
0009 #include <cstddef>
0010 #include <cstdint>
0011 #include <iostream>
0012 #include <variant>
0013
0014 #include <covfie/core/concepts.hpp>
0015 #include <covfie/core/definitions.hpp>
0016 #include <covfie/core/parameter_pack.hpp>
0017 #include <covfie/core/qualifiers.hpp>
0018 #include <covfie/core/utility/binary_io.hpp>
0019 #include <covfie/core/vector.hpp>
0020
0021 namespace covfie::backend {
0022 template <concepts::field_backend _backend_t, std::size_t... Is>
0023 struct covariant_select {
0024     using this_t = covariant_select<_backend_t, Is...>;
0025     static constexpr bool is_initial = false;
0026
0027     using backend_t = _backend_t;
0028
0029     using contravariant_input_t = typename backend_t::contravariant_input_t;
0030     using covariant_output_t = vector::array_vector_d<vector::vector_d<
0031         typename backend_t::covariant_output_t::scalar_t,
0032         sizeof...(Is)>>;
0033
0034     static_assert(
0035         sizeof...(Is) > 0, "covariant_select must select at least one element."
0036     );
0037     static_assert(
0038         ((Is < backend_t::covariant_output_t::dimensions) && ...),
0039         "covariant_select indices must be in range of the wrapped backend's "
0040         "covariant output dimensions."
0041     );
0042
0043     using configuration_t = std::monostate;
0044
0045     static constexpr uint32_t IO_MAGIC_HEADER = 0xAB020011;
0046
0047     struct owning_data_t {
0048         using parent_t = this_t;
0049
0050         owning_data_t() = default;
0051
0052         template <typename... Args>
0053         explicit owning_data_t(configuration_t, Args... args)
0054             : m_backend(std::forward<Args>(args)...)
0055         {
0056         }
0057
0058         explicit owning_data_t(
0059             const configuration_t &, typename backend_t::owning_data_t && b
0060         )
0061             : m_backend(std::forward<typename backend_t::owning_data_t>(b))
0062         {
0063         }
0064
0065         typename backend_t::owning_data_t & get_backend(void)
0066         {
0067             return m_backend;
0068         }
0069
0070         const typename backend_t::owning_data_t & get_backend(void) const
0071         {
0072             return m_backend;
0073         }
0074
0075         configuration_t get_configuration(void) const
0076         {
0077             return {};
0078         }
0079
0080         static owning_data_t read_binary(std::istream & fs)
0081         {
0082             auto be = decltype(m_backend)::read_binary(fs);
0083
0084             return owning_data_t(configuration_t{}, std::move(be));
0085         }
0086
0087         static void write_binary(std::ostream & fs, const owning_data_t & o)
0088         {
0089             decltype(m_backend)::write_binary(fs, o.m_backend);
0090         }
0091
0092         typename backend_t::owning_data_t m_backend;
0093     };
0094
0095     struct non_owning_data_t {
0096         using parent_t = this_t;
0097
0098         non_owning_data_t(const owning_data_t & src)
0099             : m_backend(src.m_backend)
0100         {
0101         }
0102
0103         COVFIE_HOST_DEVICE typename covariant_output_t::vector_t
0104         at(typename contravariant_input_t::vector_t c) const
0105         {
0106             decltype(auto) v = m_backend.at(c);
0107             return {
0108                 static_cast<typename covariant_output_t::scalar_t>(v[Is])...};
0109         }
0110
0111         typename backend_t::non_owning_data_t & get_backend(void)
0112         {
0113             return m_backend;
0114         }
0115
0116         const typename backend_t::non_owning_data_t & get_backend(void) const
0117         {
0118             return m_backend;
0119         }
0120
0121         typename backend_t::non_owning_data_t m_backend;
0122     };
0123 };
0124 }