ProcessLib::Reflection::detail::GetFlattenedIPDataFromLocAsm< Dim, Accessor_IPDataVecInLocAsm, Accessor_CurrentLevelFromIPDataVecElement > Struct Template Reference

Detailed Description

template<int Dim, typename Accessor_IPDataVecInLocAsm, typename Accessor_CurrentLevelFromIPDataVecElement>
struct ProcessLib::Reflection::detail::GetFlattenedIPDataFromLocAsm< Dim, Accessor_IPDataVecInLocAsm, Accessor_CurrentLevelFromIPDataVecElement >

A function object taking a local assembler as its argument and returning a std::vector<double> of some specific "flattened" integration point (IP) data.

Template Parameters

Dim	the space dimension
Accessor_IPDataVecInLocAsm	see below
Accessor_CurrentLevelFromIPDataVecElement	see below

In OGS IP data is usually stored in the local assembler in the following way:

struct LocAsm
{
  std::vector<IPData1> ip_data1;
  std::vector<IPData2> ip_data2;
};

The types IPData1 and IPData2 might directly contain the IP data or might have struct members who contain the IP data, e.g.:

struct IPData1
{
  double scalar1;  // IPData1 directly holds IP data
  Eigen::Vector<double, 3> vector1;
};
 
struct IPData_Level2
{
  double scalar2;
  Eigen::Vector<double, 6> kelvin2;
};
 
struct IPData2
{
  IPData_Level2 level2;  // IPData2 does not directly hold IP data
};

Accessor_IPDataVecInLocAsm is a function object with signature LocAsm const& -> std::vector<IPData> const&.

Accessor_CurrentLevelFromIPDataVecElement is a function object with signature IPData const& -> double (or Eigen::Vector), where IPData is the "top level" struct contained in the std::vector<IPData>.

I.e. the first accessor takes us from the local assembler to the IP data vector and the second accessor takes us from an IP data vector element to the final IP data of type double or Eigen::Vector.

Note

This function object transforms Kelvin vector typed IP data to a ParaView compatible symmetric tensor representation.

Definition at line 233 of file ReflectionIPData.h.

#include <ReflectionIPData.h>

Public Member Functions
template<typename LocAsm>
std::vector< double >	operator() (LocAsm const &loc_asm) const

Public Attributes
Accessor_IPDataVecInLocAsm	accessor_ip_data_vec_in_loc_asm
Accessor_CurrentLevelFromIPDataVecElement	accessor_current_level_from_ip_data_vec_element

Member Function Documentation

operator()()

template<int Dim, typename Accessor_IPDataVecInLocAsm, typename Accessor_CurrentLevelFromIPDataVecElement>

template<typename LocAsm>

std::vector< double > ProcessLib::Reflection::detail::GetFlattenedIPDataFromLocAsm< Dim, Accessor_IPDataVecInLocAsm, Accessor_CurrentLevelFromIPDataVecElement >::operator() ( LocAsm const & loc_asm ) const

inline

Definition at line 244 of file ReflectionIPData.h.

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

References accessor_current_level_from_ip_data_vec_element, accessor_ip_data_vec_in_loc_asm, MathLib::KelvinVector::kelvin_vector_dimensions(), and MathLib::KelvinVector::kelvinVectorToSymmetricTensor().

Member Data Documentation

accessor_current_level_from_ip_data_vec_element

template<int Dim, typename Accessor_IPDataVecInLocAsm, typename Accessor_CurrentLevelFromIPDataVecElement>

Accessor_CurrentLevelFromIPDataVecElement ProcessLib::Reflection::detail::GetFlattenedIPDataFromLocAsm< Dim, Accessor_IPDataVecInLocAsm, Accessor_CurrentLevelFromIPDataVecElement >::accessor_current_level_from_ip_data_vec_element

Definition at line 241 of file ReflectionIPData.h.

Referenced by operator()().

accessor_ip_data_vec_in_loc_asm

template<int Dim, typename Accessor_IPDataVecInLocAsm, typename Accessor_CurrentLevelFromIPDataVecElement>

Accessor_IPDataVecInLocAsm ProcessLib::Reflection::detail::GetFlattenedIPDataFromLocAsm< Dim, Accessor_IPDataVecInLocAsm, Accessor_CurrentLevelFromIPDataVecElement >::accessor_ip_data_vec_in_loc_asm

Definition at line 239 of file ReflectionIPData.h.

Referenced by operator()().

---

The documentation for this struct was generated from the following file:

• ProcessLib/Reflection/ReflectionIPData.h