ReflectionIPData.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <boost/mp11.hpp>
 
#include "BaseLib/BoostMP11Utils.h"
#include "BaseLib/StrongType.h"
#include "MathLib/KelvinVector.h"
#include "ReflectionData.h"
 
namespace ProcessLib::Reflection
{
namespace detail
{
template <typename T>
struct is_raw_data : std::false_type
{
};
 
template <>
struct is_raw_data<double> : std::true_type
{
};
 
template <int N>
struct is_raw_data<Eigen::Matrix<double, N, 1, Eigen::ColMajor, N, 1>>
    : std::true_type
{
};
 
template <int N, int M>
struct is_raw_data<Eigen::Matrix<double, N, M, Eigen::RowMajor, N, M>>
    : std::true_type
{
};
 
template <typename T>
constexpr bool is_raw_data_v = is_raw_data<T>::value;
 
template <typename T>
struct NumberOfRows;
 
template <>
struct NumberOfRows<double> : std::integral_constant<unsigned, 1>
{
};
 
template <int N>
struct NumberOfRows<Eigen::Matrix<double, N, 1, Eigen::ColMajor, N, 1>>
    : std::integral_constant<unsigned, N>
{
};
 
template <int N, int M>
struct NumberOfRows<Eigen::Matrix<double, N, M, Eigen::RowMajor, N, M>>
    : std::integral_constant<unsigned, N>
{
};
 
template <typename T>
struct NumberOfColumns;
 
template <>
struct NumberOfColumns<double> : std::integral_constant<unsigned, 1>
{
};
 
template <int N>
struct NumberOfColumns<Eigen::Matrix<double, N, 1, Eigen::ColMajor, N, 1>>
    : std::integral_constant<unsigned, 1>
{
};
 
template <int N, int M>
struct NumberOfColumns<Eigen::Matrix<double, N, M, Eigen::RowMajor, N, M>>
    : std::integral_constant<unsigned, M>
{
};
 
template <typename T>
struct NumberOfComponents
    : std::integral_constant<unsigned,
                             NumberOfRows<T>::value * NumberOfColumns<T>::value>
{
};
 
template <typename T>
concept has_reflect = requires { T::reflect(); };
 
template <typename... Ts>
auto reflect(std::type_identity<std::tuple<Ts...>> /*unused*/)
{
    using namespace boost::mp11;
 
    // The types Ts... must be unique. Duplicate types are incompatible with the
    // concept of "reflected" I/O: they would lead to duplicate names for the
    // I/O data.
    static_assert(mp_is_set_v<mp_list<Ts...>>);
 
    return reflectWithoutName<std::tuple<Ts...>>(
        [](auto& tuple_) -> auto& { return std::get<Ts>(tuple_); }...);
}
 
template <has_reflect T>
auto reflect(std::type_identity<T> /*unused*/)
{
    return T::reflect();
}
 
template <typename T>
concept has_ioName = requires(T* t) { ioName(t); };
 
template <typename T, typename Tag>
auto reflect(std::type_identity<BaseLib::StrongType<T, Tag>> /*unused*/)
{
    using ST = BaseLib::StrongType<T, Tag>;
 
    auto accessor = [](auto& o) -> auto& { return *o; };
 
    // Maybe in the future we might want to lift the following two constraints.
    // But beware: that generalization has to be tested thoroughly such that we
    // don't accidentally produce I/O data without name and the like.
    static_assert(
        has_ioName<Tag>,
        /* We use ioName(Tag* tag), because it works with an incomplete type
         * Tag, as opposed to ioName(Tag tag), i.e. declaring
         *   std::string_view ioName(struct SomeTag*);
         * is possible, whereas
         *   std::string_view ioName(struct SomeTag);
         * is not.
         * This choice makes the code for every ioName() definition rather
         * compact.
         */
        "For I/O of StrongType<T, Tag> you have to define an ioName(Tag* tag) "
        "function returning the name used for I/O.");
    static_assert(
        is_raw_data_v<T>,
        "I/O of StrongTypes is supported only for StrongTypes wrapping 'raw "
        "data' such as double values, vectors and matrices.");
 
    return std::tuple{makeReflectionData<ST>(
        std::string{ioName(static_cast<Tag*>(nullptr))}, std::move(accessor))};
}
 
template <typename T>
concept is_reflectable = requires {
    ProcessLib::Reflection::detail::reflect(std::type_identity<T>{});
};

template <int Dim, typename Accessor_IPDataVecInLocAsm,
          typename Accessor_CurrentLevelFromIPDataVecElement>
struct GetFlattenedIPDataFromLocAsm
{
    static_assert(!std::is_reference_v<Accessor_IPDataVecInLocAsm>);
    static_assert(
        !std::is_reference_v<Accessor_CurrentLevelFromIPDataVecElement>);
 
    Accessor_IPDataVecInLocAsm accessor_ip_data_vec_in_loc_asm;
    Accessor_CurrentLevelFromIPDataVecElement
        accessor_current_level_from_ip_data_vec_element;
 
    template <typename LocAsm>
    std::vector<double> operator()(LocAsm const& loc_asm) const
    {
        using IPDataVector = std::remove_cvref_t<
            std::invoke_result_t<Accessor_IPDataVecInLocAsm, LocAsm const&>>;
        using IPDataVectorElement = typename IPDataVector::value_type;
 
        // the concrete IP data, e.g. double or Eigen::Vector
        using ConcreteIPData = std::remove_cvref_t<
            std::invoke_result_t<Accessor_CurrentLevelFromIPDataVecElement,
                                 IPDataVectorElement const&>>;
        static_assert(is_raw_data<ConcreteIPData>::value,
                      "This method only deals with raw data. The given "
                      "ConcreteIPData is not raw data.");
 
        constexpr unsigned num_rows = NumberOfRows<ConcreteIPData>::value;
        constexpr unsigned num_cols = NumberOfColumns<ConcreteIPData>::value;
        constexpr unsigned num_comp = num_rows * num_cols;
        auto const& ip_data_vector = accessor_ip_data_vec_in_loc_asm(loc_asm);
        auto const num_ips = ip_data_vector.size();
 
        std::vector<double> result(num_comp * num_ips);
 
        for (std::size_t ip = 0; ip < num_ips; ++ip)
        {
            auto const& ip_data_vector_element = ip_data_vector[ip];
            auto const& ip_data =
                accessor_current_level_from_ip_data_vec_element(
                    ip_data_vector_element);
 
            if constexpr (num_comp == 1)
            {
                // scalar
                result[ip] = ip_data;
            }
            else if constexpr (num_rows == MathLib::KelvinVector::
                                               kelvin_vector_dimensions(Dim) &&
                               num_cols == 1)
            {
                // Kelvin vector
                auto const converted =
                    MathLib::KelvinVector::kelvinVectorToSymmetricTensor(
                        ip_data);
 
                for (unsigned comp = 0; comp < num_comp; ++comp)
                {
                    result[ip * num_comp + comp] = converted[comp];
                }
            }
            else if constexpr (num_cols == MathLib::KelvinVector::
                                               kelvin_vector_dimensions(Dim) &&
                               num_rows == 1)
            {
                static_assert(
                    num_rows != 1 /* always false in this branch */,
                    "We support Kelvin column-vectors, but not Kelvin "
                    "row-vectors. The latter are unusual and confusion with "
                    "generic vectors might be possible.");
            }
            else if constexpr (num_rows == 1 || num_cols == 1)
            {
                // row or column vector
                for (unsigned comp = 0; comp < num_comp; ++comp)
                {
                    result[ip * num_comp + comp] = ip_data[comp];
                }
            }
            else
            {
                // matrix
                // row-major traversal
                for (unsigned row = 0; row < num_rows; ++row)
                {
                    for (unsigned col = 0; col < num_cols; ++col)
                    {
                        result[ip * num_comp + row * num_cols + col] =
                            ip_data(row, col);
                    }
                }
            }
        }
        return result;
    }
};
 
// Convenience function for template argument deduction with
// GetFlattenedIPDataFromLocAsm
template <int Dim, typename Accessor_IPDataVecInLocAsm,
          typename Accessor_CurrentLevelFromIPDataVecElement>
GetFlattenedIPDataFromLocAsm<
    Dim, std::remove_cvref_t<Accessor_IPDataVecInLocAsm>,
    std::remove_cvref_t<Accessor_CurrentLevelFromIPDataVecElement>>
getFlattenedIPDataFromLocAsm(
    Accessor_IPDataVecInLocAsm accessor_ip_data_vec_in_loc_asm,
    Accessor_CurrentLevelFromIPDataVecElement
        accessor_current_level_from_ip_data_vec_element)
{
    return {std::forward<Accessor_IPDataVecInLocAsm>(
                accessor_ip_data_vec_in_loc_asm),
            std::forward<Accessor_CurrentLevelFromIPDataVecElement>(
                accessor_current_level_from_ip_data_vec_element)};
}
 
// Convenience function for template argument deduction with
// GetFlattenedIPDataFromLocAsm. Overload of the function above with less
// arguments.
template <int Dim, typename Accessor_IPDataVecInLocAsm>
auto getFlattenedIPDataFromLocAsm(
    Accessor_IPDataVecInLocAsm&& accessor_ip_data_vec_in_loc_asm)
{
    return getFlattenedIPDataFromLocAsm<Dim>(
        std::forward<Accessor_IPDataVecInLocAsm>(
            accessor_ip_data_vec_in_loc_asm),
        std::identity{});
}

template <int Dim, typename Callback, typename ReflectionDataTuple,
          typename Accessor_IPDataVecInLocAsm,
          typename Accessor_CurrentLevelFromIPDataVecElement>
void forEachReflectedFlattenedIPDataAccessor(
    Callback const& callback, ReflectionDataTuple const& reflection_data,
    Accessor_IPDataVecInLocAsm const& accessor_ip_data_vec_in_loc_asm,
    Accessor_CurrentLevelFromIPDataVecElement const&
        accessor_current_level_from_ip_data_vec_element)
{
    static_assert(boost::mp11::mp_is_list_v<ReflectionDataTuple>,
                  "The passed reflection data is not a std::tuple.");
    static_assert(
        std::is_same_v<ReflectionDataTuple,
                       boost::mp11::mp_rename<ReflectionDataTuple, std::tuple>>,
        "The passed reflection data is not a std::tuple.");
 
    boost::mp11::tuple_for_each(
        reflection_data,
        [&accessor_ip_data_vec_in_loc_asm,
         &accessor_current_level_from_ip_data_vec_element,
         &callback]<typename Class, typename Accessor>(
            ReflectionData<Class, Accessor> const& refl_data)
        {
            using MemberRef = std::invoke_result_t<Accessor, Class const&>;
            using Member = std::remove_cvref_t<MemberRef>;
 
            auto accessor_member_from_ip_data_vec_element =
                [accessor_next_level = refl_data.accessor,
                 accessor_current_level_from_ip_data_vec_element](
                    auto const& ip_data_vec_element) -> Member const&
            {
                return accessor_next_level(
                    accessor_current_level_from_ip_data_vec_element(
                        ip_data_vec_element));
            };
 
            if constexpr (is_reflectable<Member>)
            {
                forEachReflectedFlattenedIPDataAccessor<Dim>(
                    callback, detail::reflect(std::type_identity<Member>{}),
                    accessor_ip_data_vec_in_loc_asm,
                    accessor_member_from_ip_data_vec_element);
            }
            else
            {
                static_assert(is_raw_data_v<Member>,
                              "The current member is not reflectable, so we "
                              "expect it to be raw data.");
 
                constexpr unsigned num_comp = NumberOfComponents<Member>::value;
 
                assert(!refl_data.name.empty());
                callback(refl_data.name, num_comp,
                         getFlattenedIPDataFromLocAsm<Dim>(
                             accessor_ip_data_vec_in_loc_asm,
                             accessor_member_from_ip_data_vec_element));
            }
        });
}
 
// Overload of the function above with less arguments
template <int Dim, typename Callback, typename ReflectionDataTuple,
          typename Accessor_IPDataVecInLocAsm>
void forEachReflectedFlattenedIPDataAccessor(
    Callback const& callback,
    ReflectionDataTuple const& reflection_data,
    Accessor_IPDataVecInLocAsm const& accessor_ip_data_vec_in_loc_asm)
{
    forEachReflectedFlattenedIPDataAccessor<Dim>(
        callback, reflection_data, accessor_ip_data_vec_in_loc_asm,
        std::identity{});
}
 
}  // namespace detail

template <int Dim, typename LocAsmIF, typename Callback, typename ReflData>
void forEachReflectedFlattenedIPDataAccessor(ReflData const& reflection_data,
                                             Callback const& callback)
{
    using namespace boost::mp11;
 
    static_assert(mp_is_list_v<ReflData>,
                  "The passed reflection data is not a std::tuple.");
    static_assert(std::is_same_v<ReflData, mp_rename<ReflData, std::tuple>>,
                  "The passed reflection data is not a std::tuple.");
 
    tuple_for_each(
        reflection_data,
        [&callback]<typename Class, typename Accessor>(
            ReflectionData<Class, Accessor> const& refl_data)
        {
            static_assert(std::is_same_v<Class, LocAsmIF>,
                          "The currently processed reflection data is not for "
                          "the given LocAsmIF but for a different class.");
 
            using AccessorResultRef =
                std::invoke_result_t<Accessor, Class const&>;
            using AccessorResult = std::remove_cvref_t<AccessorResultRef>;
 
            // AccessorResult must be a std::vector<SomeType, SomeAllocator>. We
            // check that, now.
            static_assert(
                mp_is_list_v<AccessorResult>);  // std::vector<SomeType,
                                                // SomeAllocator> is a list in
                                                // the Boost MP11 sense
            static_assert(
                std::is_same_v<AccessorResult,
                               mp_rename<AccessorResult, std::vector>>,
                "We expect a std::vector, here.");
            // Now, we know that AccessorResult is std::vector<Member>. To be
            // more specific, AccessorResult is a std::vector<IPData> and Member
            // is IPData.
            using Member = typename AccessorResult::value_type;
 
            auto accessor_ip_data_vec_in_loc_asm =
                [ip_data_vector_accessor =
                     refl_data.accessor](LocAsmIF const& loc_asm) -> auto const&
            { return ip_data_vector_accessor(loc_asm); };
 
            if constexpr (detail::is_reflectable<Member>)
            {
                detail::forEachReflectedFlattenedIPDataAccessor<Dim>(
                    callback,
                    detail::reflect(std::type_identity<Member>{}),
                    accessor_ip_data_vec_in_loc_asm);
            }
            else
            {
                static_assert(detail::is_raw_data_v<Member>,
                              "The current member is not reflectable, so we "
                              "expect it to be raw data.");
 
                constexpr unsigned num_comp =
                    detail::NumberOfComponents<Member>::value;
 
                assert(!refl_data.name.empty());
                callback(refl_data.name, num_comp,
                         detail::getFlattenedIPDataFromLocAsm<Dim>(
                             accessor_ip_data_vec_in_loc_asm));
            }
        });
}
}  // namespace ProcessLib::Reflection