Classes
struct	GetFlattenedIPDataFromLocAsm
struct	is_raw_data
struct	is_raw_data< double >
struct	is_raw_data< Eigen::Matrix< double, N, 1, Eigen::ColMajor, N, 1 > >
struct	is_raw_data< Eigen::Matrix< double, N, M, Eigen::RowMajor, N, M > >
struct	NumberOfColumns
struct	NumberOfColumns< double >
struct	NumberOfColumns< Eigen::Matrix< double, N, 1, Eigen::ColMajor, N, 1 > >
struct	NumberOfColumns< Eigen::Matrix< double, N, M, Eigen::RowMajor, N, M > >
struct	NumberOfComponents
struct	NumberOfRows
struct	NumberOfRows< double >
struct	NumberOfRows< Eigen::Matrix< double, N, 1, Eigen::ColMajor, N, 1 > >
struct	NumberOfRows< Eigen::Matrix< double, N, M, Eigen::RowMajor, N, M > >

Functions
template<typename... Ts>
auto	reflect (std::type_identity< std::tuple< Ts... > >)
template<has_reflect T>
auto	reflect (std::type_identity< T >)
template<typename T, typename Tag>
auto	reflect (std::type_identity< BaseLib::StrongType< T, Tag > >)
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)
template<int Dim, typename Accessor_IPDataVecInLocAsm>
auto	getFlattenedIPDataFromLocAsm (Accessor_IPDataVecInLocAsm &&accessor_ip_data_vec_in_loc_asm)
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)
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)
template<int dim, typename IPData, typename Accessor>
void	setIPData (double const *values, std::vector< IPData > &ip_data_vector, Accessor const &accessor)
template<int dim, typename IPData, typename Accessor_CurrentLevelFromIPData, typename Class, typename Accessor>
bool	setIPDataIfNameMatches (std::string_view const name, double const *values, std::vector< IPData > &ip_data_vector, Accessor_CurrentLevelFromIPData const &accessor, ReflectionData< Class, Accessor > const &refl_data)
template<int dim, typename IPData, typename Accessor_CurrentLevelFromIPData, typename... Classes, typename... Accessors, std::size_t... Idcs>
bool	reflectSetIPData (std::string_view const name, double const *values, std::vector< IPData > &ip_data_vector, Accessor_CurrentLevelFromIPData const &accessor, std::tuple< ReflectionData< Classes, Accessors >... > const &refl_data, std::index_sequence< Idcs... >)
template<int dim, typename IPData, typename Accessor_CurrentLevelFromIPData, typename... Classes, typename... Accessors>
bool	reflectSetIPData (std::string_view const name, double const *values, std::vector< IPData > &ip_data_vector, Accessor_CurrentLevelFromIPData const &accessor, std::tuple< ReflectionData< Classes, Accessors >... > const &refl_data)

Variables
template<typename T>
constexpr bool	is_raw_data_v = is_raw_data<T>::value

Function Documentation

◆ forEachReflectedFlattenedIPDataAccessor() [1/2]

template<int Dim, typename Callback, typename ReflectionDataTuple, typename Accessor_IPDataVecInLocAsm>

void ProcessLib::Reflection::detail::forEachReflectedFlattenedIPDataAccessor	(	Callback const &	callback,
		ReflectionDataTuple const &	reflection_data,
		Accessor_IPDataVecInLocAsm const &	accessor_ip_data_vec_in_loc_asm )

Definition at line 425 of file ReflectionIPData.h.

{
    forEachReflectedFlattenedIPDataAccessor<Dim>(
        callback, reflection_data, accessor_ip_data_vec_in_loc_asm,
        std::identity{});
}

References forEachReflectedFlattenedIPDataAccessor().

◆ forEachReflectedFlattenedIPDataAccessor() [2/2]

template<int Dim, typename Callback, typename ReflectionDataTuple, typename Accessor_IPDataVecInLocAsm, typename Accessor_CurrentLevelFromIPDataVecElement>

void ProcessLib::Reflection::detail::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 )

Calls the given callback for each flattened IP data accessor obtained recursively from the given reflection data.

The callback function must take (i) the name of the IP data (std::string), (ii) their number of components (unsigned) and a flattened IP data accessor of type ProcessLib::Reflection::detail::GetFlattenedIPDataFromLocAsm as arguments.

See also: ProcessLib::Reflection::detail::GetFlattenedIPDataFromLocAsm for details, also on the template parameters.

Definition at line 365 of file ReflectionIPData.h.

{
    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));
            }
        });
}

References ProcessLib::Reflection::ReflectionData< Class, Accessor >::accessor, forEachReflectedFlattenedIPDataAccessor(), getFlattenedIPDataFromLocAsm(), is_raw_data_v, boost::mp11::mp_is_list_v, ProcessLib::Reflection::ReflectionData< Class, Accessor >::name, and reflect().

Referenced by forEachReflectedFlattenedIPDataAccessor(), forEachReflectedFlattenedIPDataAccessor(), and ProcessLib::Reflection::forEachReflectedFlattenedIPDataAccessor().

◆ getFlattenedIPDataFromLocAsm() [1/2]

template<int Dim, typename Accessor_IPDataVecInLocAsm>

auto ProcessLib::Reflection::detail::getFlattenedIPDataFromLocAsm ( Accessor_IPDataVecInLocAsm && accessor_ip_data_vec_in_loc_asm )

Definition at line 343 of file ReflectionIPData.h.

{
    return getFlattenedIPDataFromLocAsm<Dim>(
        std::forward<Accessor_IPDataVecInLocAsm>(
            accessor_ip_data_vec_in_loc_asm),
        std::identity{});
}

References getFlattenedIPDataFromLocAsm().

◆ getFlattenedIPDataFromLocAsm() [2/2]

template<int Dim, typename Accessor_IPDataVecInLocAsm, typename Accessor_CurrentLevelFromIPDataVecElement>

GetFlattenedIPDataFromLocAsm< Dim, std::remove_cvref_t< Accessor_IPDataVecInLocAsm >, std::remove_cvref_t< Accessor_CurrentLevelFromIPDataVecElement > > ProcessLib::Reflection::detail::getFlattenedIPDataFromLocAsm	(	Accessor_IPDataVecInLocAsm	accessor_ip_data_vec_in_loc_asm,
		Accessor_CurrentLevelFromIPDataVecElement	accessor_current_level_from_ip_data_vec_element )

Definition at line 328 of file ReflectionIPData.h.

{
    return {std::forward<Accessor_IPDataVecInLocAsm>(
                accessor_ip_data_vec_in_loc_asm),
            std::forward<Accessor_CurrentLevelFromIPDataVecElement>(
                accessor_current_level_from_ip_data_vec_element)};
}

Referenced by forEachReflectedFlattenedIPDataAccessor(), ProcessLib::Reflection::forEachReflectedFlattenedIPDataAccessor(), and getFlattenedIPDataFromLocAsm().

◆ reflect() [1/3]

template<typename T, typename Tag>

auto ProcessLib::Reflection::detail::reflect ( std::type_identity< BaseLib::StrongType< T, Tag > > )

Definition at line 129 of file ReflectionIPData.h.

{
    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))};
}

References is_raw_data_v, and ProcessLib::Reflection::makeReflectionData().

◆ reflect() [2/3]

template<typename... Ts>

auto ProcessLib::Reflection::detail::reflect ( std::type_identity< std::tuple< Ts... > > )

Definition at line 103 of file ReflectionIPData.h.

{
    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_); }...);
}

References boost::mp11::mp_is_set_v, and ProcessLib::Reflection::reflectWithoutName().

Referenced by forEachReflectedFlattenedIPDataAccessor(), ProcessLib::Reflection::forEachReflectedFlattenedIPDataAccessor(), ProcessLib::Reflection::reflectSetIPData(), and setIPDataIfNameMatches().

◆ reflect() [3/3]

template<has_reflect T>

auto ProcessLib::Reflection::detail::reflect ( std::type_identity< T > )

Definition at line 117 of file ReflectionIPData.h.

{
    return T::reflect();
}

◆ reflectSetIPData() [1/2]

template<int dim, typename IPData, typename Accessor_CurrentLevelFromIPData, typename... Classes, typename... Accessors>

bool ProcessLib::Reflection::detail::reflectSetIPData	(	std::string_view const	name,
		double const *	values,
		std::vector< IPData > &	ip_data_vector,
		Accessor_CurrentLevelFromIPData const &	accessor,
		std::tuple< ReflectionData< Classes, Accessors >... > const &	refl_data )

Definition at line 141 of file ReflectionSetIPData.h.

{
    return reflectSetIPData<dim>(
        name, values, ip_data_vector, accessor, refl_data,
        std::make_index_sequence<sizeof...(Classes)>{});
}

References reflectSetIPData().

◆ reflectSetIPData() [2/2]

template<int dim, typename IPData, typename Accessor_CurrentLevelFromIPData, typename... Classes, typename... Accessors, std::size_t... Idcs>

bool ProcessLib::Reflection::detail::reflectSetIPData	(	std::string_view const	name,
		double const *	values,
		std::vector< IPData > &	ip_data_vector,
		Accessor_CurrentLevelFromIPData const &	accessor,
		std::tuple< ReflectionData< Classes, Accessors >... > const &	refl_data,
		std::index_sequence< Idcs... >	)

Definition at line 125 of file ReflectionSetIPData.h.

{
    // uses short-circuit evaluation of the fold || ... to stop after the first
    // match
    return ((setIPDataIfNameMatches<dim>(name, values, ip_data_vector, accessor,
                                         std::get<Idcs>(refl_data))) ||
            ...);
}

References setIPDataIfNameMatches().

Referenced by reflectSetIPData(), ProcessLib::Reflection::reflectSetIPData(), and setIPDataIfNameMatches().

◆ setIPData()

template<int dim, typename IPData, typename Accessor>

void ProcessLib::Reflection::detail::setIPData	(	double const *	values,
		std::vector< IPData > &	ip_data_vector,
		Accessor const &	accessor )

Definition at line 17 of file ReflectionSetIPData.h.

{
    using AccessorResult = std::invoke_result_t<Accessor, IPData&>;
    using AccessorResultStripped = std::remove_cvref_t<AccessorResult>;
 
    static_assert(is_raw_data_v<AccessorResultStripped>,
                  "This method only deals with raw data. The given "
                  "AccessorResultStripped is not raw data.");
 
    constexpr auto num_comp = NumberOfComponents<AccessorResultStripped>::value;
 
    auto const num_int_pts = ip_data_vector.size();
 
    if constexpr (num_comp == 1)
    {
        // scalar
        for (unsigned ip = 0; ip < num_int_pts; ++ip)
        {
            accessor(ip_data_vector[ip]) = values[ip];
        }
    }
    else
    {
        constexpr auto num_rows = NumberOfRows<AccessorResultStripped>::value;
        constexpr auto num_cols =
            NumberOfColumns<AccessorResultStripped>::value;
        constexpr auto kv_size =
            MathLib::KelvinVector::kelvin_vector_dimensions(dim);
 
        auto const values_mat =
            Eigen::Map<Eigen::Matrix<double, num_comp, Eigen::Dynamic,
                                     Eigen::ColMajor> const>(values, num_comp,
                                                             num_int_pts);
 
        for (unsigned ip = 0; ip < num_int_pts; ++ip)
        {
            if constexpr (num_cols == 1 || num_rows == 1)
            {
                // vector
                if constexpr (num_comp == kv_size)
                {
                    // Kelvin vector
                    accessor(ip_data_vector[ip]) =
                        MathLib::KelvinVector::symmetricTensorToKelvinVector(
                            values_mat.col(ip));
                }
                else
                {
                    // other vector
                    accessor(ip_data_vector[ip]) = values_mat.col(ip);
                }
            }
            else
            {
                // matrix
                accessor(ip_data_vector[ip]) =
                    values_mat.col(ip).template reshaped<Eigen::RowMajor>(
                        num_rows, num_cols);
            }
        }
    }
}

References is_raw_data_v, MathLib::KelvinVector::kelvin_vector_dimensions(), and MathLib::KelvinVector::symmetricTensorToKelvinVector().

Referenced by setIPDataIfNameMatches().

◆ setIPDataIfNameMatches()

template<int dim, typename IPData, typename Accessor_CurrentLevelFromIPData, typename Class, typename Accessor>

bool ProcessLib::Reflection::detail::setIPDataIfNameMatches	(	std::string_view const	name,
		double const *	values,
		std::vector< IPData > &	ip_data_vector,
		Accessor_CurrentLevelFromIPData const &	accessor,
		ReflectionData< Class, Accessor > const &	refl_data )

Definition at line 86 of file ReflectionSetIPData.h.

{
    auto const accessor_next_level = refl_data.accessor;
 
    using MemberRef = std::invoke_result_t<Accessor, Class&>;
    using Member = std::remove_cvref_t<MemberRef>;
 
    auto const accessor_field_from_ip_data =
        [accessor, accessor_next_level](IPData& ip_data) -> Member&
    { return accessor_next_level(accessor(ip_data)); };
 
    if constexpr (detail::is_reflectable<Member>)
    {
        return reflectSetIPData<dim>(
            name, values, ip_data_vector, accessor_field_from_ip_data,
            detail::reflect(std::type_identity<Member>{}));
    }
    else
    {
        static_assert(detail::is_raw_data_v<Member>,
                      "The current member is not reflectable, so we "
                      "expect it to be raw data.");
 
        if (refl_data.name != name)
        {
            return false;
        }
 
        setIPData<dim>(values, ip_data_vector, accessor_field_from_ip_data);
 
        return true;
    }
}

References ProcessLib::Reflection::ReflectionData< Class, Accessor >::accessor, is_raw_data_v, ProcessLib::Reflection::ReflectionData< Class, Accessor >::name, reflect(), reflectSetIPData(), and setIPData().

Referenced by reflectSetIPData().

Variable Documentation

◆ is_raw_data_v

template<typename T>

bool ProcessLib::Reflection::detail::is_raw_data_v = is_raw_data<T>::value

constexpr

Definition at line 47 of file ReflectionIPData.h.

Referenced by forEachReflectedFlattenedIPDataAccessor(), ProcessLib::Reflection::forEachReflectedFlattenedIPDataAccessor(), reflect(), setIPData(), and setIPDataIfNameMatches().

Classes

Functions

Variables