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<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 377 of file ReflectionIPData.h.

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

◆ 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 325 of file ReflectionIPData.h.

{
    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<Member>::value,
                              "The current member is not reflectable, so we "
                              "expect it to be raw data.");
 
                constexpr unsigned num_comp = NumberOfComponents<Member>::value;
 
                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, ProcessLib::Reflection::ReflectionData< Class, Accessor >::name, and reflect().

◆ 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 303 of file ReflectionIPData.h.

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

◆ 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 288 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)};
}

◆ reflect() [1/2]

template<typename... Ts>

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

Definition at line 26 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<mp_list<Ts...>>::value);
 
    return reflectWithoutName<std::tuple<Ts...>>(
        [](auto& tuple_) -> auto& { return std::get<Ts>(tuple_); }...);
}

References ProcessLib::Reflection::reflectWithoutName().

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

◆ reflect() [2/2]

template<has_reflect T>

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

Definition at line 40 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 148 of file ReflectionSetIPData.h.

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

◆ 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 132 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))) ||
            ...);
}

◆ 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 24 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 MathLib::KelvinVector::kelvin_vector_dimensions(), and MathLib::KelvinVector::symmetricTensorToKelvinVector().

◆ 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 93 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, ProcessLib::Reflection::ReflectionData< Class, Accessor >::name, and reflect().

Variable Documentation

◆ is_raw_data_v

template<typename T >

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

constexpr

Definition at line 80 of file ReflectionIPData.h.

Classes

Functions

Variables