ProcessLib::Reflection Namespace Reference

Namespaces
namespace	detail

Classes
struct	ReflectionData

Functions
template<typename Class , typename Accessor >
auto	makeReflectionData (Accessor &&accessor)
template<typename Class , typename Accessor >
auto	makeReflectionData (std::string name, Accessor &&accessor)
template<typename Class , typename Member >
auto	makeReflectionData (Member Class::*member)
template<typename Class , typename Member >
auto	makeReflectionData (std::string name, Member Class::*member)
template<typename Class , typename Member >
auto	reflectWithName (std::string name, Member Class::*member)
template<typename Class , typename... Accessors>
auto	reflectWithoutName (Accessors &&... accessors)
template<typename Class , typename... Members>
auto	reflectWithoutName (Members Class::*... members)
template<int Dim, typename LocAsmIF , typename ReflData >
void	addReflectedSecondaryVariables (ReflData const &reflection_data, SecondaryVariableCollection &secondary_variables, NumLib::Extrapolator &extrapolator, std::vector< std::unique_ptr< LocAsmIF > > const &local_assemblers)
template<int Dim, typename LocAsmIF , typename ReflData >
void	addReflectedIntegrationPointWriters (ReflData const &reflection_data, std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > &integration_point_writers, unsigned const integration_order, std::vector< std::unique_ptr< LocAsmIF > > const &local_assemblers)
template<int Dim, typename LocAsmIF , typename Callback , typename ReflData >
void	forEachReflectedFlattenedIPDataAccessor (ReflData const &reflection_data, Callback const &callback)
template<int dim, typename IPData >
std::size_t	reflectSetIPData (std::string_view const name, double const *values, std::vector< IPData > &ip_data_vector)

Function Documentation

addReflectedIntegrationPointWriters()

template<int Dim, typename LocAsmIF , typename ReflData >

void ProcessLib::Reflection::addReflectedIntegrationPointWriters	(	ReflData const &	reflection_data,
		std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > &	integration_point_writers,
		unsigned const	integration_order,
		std::vector< std::unique_ptr< LocAsmIF > > const &	local_assemblers )

Adds IP data writers for all IP data obtained recursively from the given reflection_data to the given IP writer vector.

Definition at line 21 of file ReflectionForIPWriters.h.

{
    forEachReflectedFlattenedIPDataAccessor<Dim, LocAsmIF>(
        reflection_data,
        [&integration_point_writers, integration_order, &local_assemblers](
            std::string const& name,
            unsigned const num_comp,
            auto&& flattened_ip_data_accessor)
        {
            // TODO check if writer with such a name already exists.
            integration_point_writers.emplace_back(
                std::make_unique<MeshLib::IntegrationPointWriter>(
                    name + "_ip", num_comp, integration_order, local_assemblers,
                    flattened_ip_data_accessor));
        });
}

Referenced by ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::LargeDeformationProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::RichardsMechanicsProcess(), and ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::SmallDeformationProcess().

addReflectedSecondaryVariables()

template<int Dim, typename LocAsmIF , typename ReflData >

void ProcessLib::Reflection::addReflectedSecondaryVariables	(	ReflData const &	reflection_data,
		SecondaryVariableCollection &	secondary_variables,
		NumLib::Extrapolator &	extrapolator,
		std::vector< std::unique_ptr< LocAsmIF > > const &	local_assemblers )

Adds secondary variables for all IP data obtained recursively from the given reflection_data to the given secondary variable collection.

Definition at line 21 of file ReflectionForExtrapolation.h.

{
    forEachReflectedFlattenedIPDataAccessor<Dim, LocAsmIF>(
        reflection_data,
        [&secondary_variables, &local_assemblers, &extrapolator](
            std::string const& name,
            unsigned const num_comp,
            auto&& flattened_ip_data_accessor)
        {
            secondary_variables.addSecondaryVariable(
                name,
                makeExtrapolator2(num_comp, extrapolator, local_assemblers,
                                  flattened_ip_data_accessor));
        });
}

References ProcessLib::SecondaryVariableCollection::addSecondaryVariable(), and ProcessLib::makeExtrapolator2().

forEachReflectedFlattenedIPDataAccessor()

template<int Dim, typename LocAsmIF , typename Callback , typename ReflData >

void ProcessLib::Reflection::forEachReflectedFlattenedIPDataAccessor	(	ReflData const &	reflection_data,
		Callback const &	callback )

Calls the passed callback for each IP data accessor for the given LocAsmIF class.

The IP data accessors are obtained via reflection (i.e., via the static reflect() method.

The IP data accessors provide IP data as a flat std::vector<double>.

The callback must accept name, number of components and a function object with signature LocAsmIF const& -> std::vector<double> as its arguments.

Definition at line 456 of file ReflectionIPData.h.

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

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

Referenced by ProcessLib::computeCellAverages().

makeReflectionData() [1/4]

template<typename Class , typename Accessor >

auto ProcessLib::Reflection::makeReflectionData

(

Accessor &&

accessor

)

Definition at line 51 of file ReflectionData.h.

{
    return ReflectionData<Class, std::remove_cvref_t<Accessor>>{
        std::forward<Accessor>(accessor)};
}

Referenced by ProcessLib::LargeDeformation::DeformationGradientData< DisplacementDim >::reflect(), and reflectWithName().

makeReflectionData() [2/4]

template<typename Class , typename Member >

auto ProcessLib::Reflection::makeReflectionData

(

Member Class::*

member

)

Definition at line 65 of file ReflectionData.h.

{
    return makeReflectionData<Class>([member](auto& obj) -> auto&
                                     { return obj.*member; });
}

makeReflectionData() [3/4]

template<typename Class , typename Accessor >

auto ProcessLib::Reflection::makeReflectionData	(	std::string	name,
		Accessor &&	accessor )

Definition at line 58 of file ReflectionData.h.

{
    return ReflectionData<Class, std::remove_cvref_t<Accessor>>{
        std::move(name), std::forward<Accessor>(accessor)};
}

makeReflectionData() [4/4]

template<typename Class , typename Member >

auto ProcessLib::Reflection::makeReflectionData	(	std::string	name,
		Member Class::*	member )

Definition at line 72 of file ReflectionData.h.

{
    return makeReflectionData<Class>(
        std::move(name), [member](auto& obj) -> auto& { return obj.*member; });
}

reflectSetIPData()

template<int dim, typename IPData >

std::size_t ProcessLib::Reflection::reflectSetIPData	(	std::string_view const	name,
		double const *	values,
		std::vector< IPData > &	ip_data_vector )

Sets integration point data for the property with the given name to the passed values.

Possible candidate properties are obtained from IPData via some sort of reflection.

Returns

The number of integration points.

Definition at line 170 of file ReflectionSetIPData.h.

{
    detail::reflectSetIPData<dim>(
        name, values, ip_data_vector, std::identity{},
        detail::reflect(std::type_identity<IPData>{}));
 
    return ip_data_vector.size();
}

References ProcessLib::Reflection::detail::reflect().

reflectWithName()

template<typename Class , typename Member >

auto ProcessLib::Reflection::reflectWithName	(	std::string	name,
		Member Class::*	member )

Definition at line 79 of file ReflectionData.h.

{
    return std::tuple{makeReflectionData(std::move(name), member)};
}

References makeReflectionData().

Referenced by ProcessLib::ConstitutiveRelations::StrainData< DisplacementDim >::reflect(), ProcessLib::ConstitutiveRelations::StressData< DisplacementDim >::reflect(), ProcessLib::SmallDeformation::FreeEnergyDensityData::reflect(), ProcessLib::TH2M::ConstitutiveRelations::SaturationData::reflect(), ProcessLib::TH2M::ConstitutiveRelations::SwellingDataStateful< DisplacementDim >::reflect(), ProcessLib::TH2M::ConstitutiveRelations::TotalStressData< DisplacementDim >::reflect(), ProcessLib::ThermoRichardsMechanics::LiquidDensityData::reflect(), ProcessLib::ThermoRichardsMechanics::PorosityData::reflect(), ProcessLib::ThermoRichardsMechanics::SaturationData::reflect(), ProcessLib::ThermoRichardsMechanics::SolidDensityData::reflect(), ProcessLib::ThermoRichardsMechanics::TotalStressData< DisplacementDim >::reflect(), ProcessLib::ThermoRichardsMechanics::TransportPorosityData::reflect(), ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::MechanicalStrainData< DisplacementDim >::reflect(), ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::EffectiveStressData< DisplacementDim >::reflect(), and ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::SwellingDataStateful< DisplacementDim >::reflect().

reflectWithoutName() [1/2]

template<typename Class , typename... Accessors>

auto ProcessLib::Reflection::reflectWithoutName

(

Accessors &&...

accessors

)

Definition at line 85 of file ReflectionData.h.

{
    return std::tuple{
        makeReflectionData<Class>(std::forward<Accessors>(accessors))...};
}

Referenced by ProcessLib::LargeDeformation::LargeDeformationLocalAssemblerInterface< DisplacementDim >::getReflectionDataForOutput(), ProcessLib::RichardsMechanics::LocalAssemblerInterface< DisplacementDim >::getReflectionDataForOutput(), ProcessLib::SmallDeformation::SmallDeformationLocalAssemblerInterface< DisplacementDim >::getReflectionDataForOutput(), ProcessLib::TH2M::LocalAssemblerInterface< DisplacementDim >::getReflectionDataForOutput(), ProcessLib::ThermoRichardsMechanics::LocalAssemblerInterface< DisplacementDim, ConstitutiveTraits >::getReflectionDataForOutput(), ProcessLib::LargeDeformation::ConstitutiveRelations::StatefulData< DisplacementDim >::reflect(), ProcessLib::LargeDeformation::ConstitutiveRelations::OutputData< DisplacementDim >::reflect(), ProcessLib::SmallDeformation::ConstitutiveRelations::StatefulData< DisplacementDim >::reflect(), ProcessLib::SmallDeformation::ConstitutiveRelations::OutputData< DisplacementDim >::reflect(), ProcessLib::TH2M::ConstitutiveRelations::StatefulData< DisplacementDim >::reflect(), ProcessLib::TH2M::ConstitutiveRelations::OutputData< DisplacementDim >::reflect(), and ProcessLib::Reflection::detail::reflect().

reflectWithoutName() [2/2]

template<typename Class , typename... Members>

auto ProcessLib::Reflection::reflectWithoutName

(

Members Class::*...

members

)

Definition at line 92 of file ReflectionData.h.

{
    return std::tuple{makeReflectionData<Class>(members)...};
}