Detailed Description

template<int DisplacementDim, typename ForcesGradsCombinations>
class MaterialLib::Solids::MFront::OGSMFrontTangentOperatorBlocksView< DisplacementDim, ForcesGradsCombinations >

Provides convenient access to the individual blocks of MFront's tangent operator data.

Template Parameters

DisplacementDim	the displacement dimension
ForcesGradsCombinations	a list of pairs types corresponding to the tangent operator blocks' variables. See ForcesGradsCombinations template for details.

MFront's tangent operator blocks are stored in a single vector of double values. The implementer of an MFront behaviour can decide which blocks she wants to provide and in which order.

Definition at line 86 of file TangentOperatorBlocksView.h.

#include <TangentOperatorBlocksView.h>

Public Member Functions
	OGSMFrontTangentOperatorBlocksView (std::vector< std::pair< mgis::behaviour::Variable, mgis::behaviour::Variable > > const &to_blocks)
template<typename Force, typename GradOrExtStateVar>
auto	block (Force, GradOrExtStateVar, OGSMFrontTangentOperatorData const &data) const

Static Private Member Functions
static constexpr std::size_t	size (mgis::behaviour::Variable::Type vt)
template<typename Force, typename GradOrExtStateVar>
static constexpr std::size_t	blockIndex ()
	Computes the index of a tangent operator block in the offsets_ array.

Private Attributes
std::array< std::size_t, boost::mp11::mp_size< ForcesGradsCombinations >::value >	offsets_

Static Private Attributes
static constexpr std::size_t	invalid_offset_ = -1

Constructor & Destructor Documentation

◆ OGSMFrontTangentOperatorBlocksView()

template<int DisplacementDim, typename ForcesGradsCombinations>

MaterialLib::Solids::MFront::OGSMFrontTangentOperatorBlocksView< DisplacementDim, ForcesGradsCombinations >::OGSMFrontTangentOperatorBlocksView ( std::vector< std::pair< mgis::behaviour::Variable, mgis::behaviour::Variable > > const & to_blocks )

inlineexplicit

Constructs a view for the tangent operator blocks to_blocks of some MFront behaviour.

Definition at line 97 of file TangentOperatorBlocksView.h.

    {
        offsets_.fill(invalid_offset_);
 
        std::vector<bool> used_blocks(
            to_blocks.size(), false);  // checked after creation of all offsets.
 
        boost::mp11::mp_for_each<ForcesGradsCombinations>(
            [&to_blocks,
             &used_blocks,
             this]<typename Force, typename GradOrExtStateVar>(
                boost::mp11::mp_list<Force, GradOrExtStateVar>)
            {
                std::size_t data_offset = 0;
                for (auto [block, is_used] :
                     ranges::views::zip(to_blocks, used_blocks))
                {
                    auto const& [force, grad] = block;
                    if (force.name == Force::name &&
                        grad.name == GradOrExtStateVar::name)
                    {
                        auto constexpr block_idx =
                            blockIndex<Force, GradOrExtStateVar>();
                        offsets_[block_idx] = data_offset;
                        is_used = true;
                        return;
                    }
 
                    data_offset += size(force.type) * size(grad.type);
                }
            });
 
        // Indices of unused blocks.
        auto indices = ranges::views::enumerate(used_blocks) |
                       ranges::views::filter([](auto const& pair)
                                             { return !pair.second; }) |
                       ranges::views::keys;
 
        if (!indices.empty())
        {
            ERR("There are unused tangent operator blocks provided by MFront. "
                "Following blocks are unused:");
 
            for (auto const i : indices)
            {
                auto const& [force, grad] = to_blocks[i];
                ERR("\t{}/{}", force.name, grad.name);
            }
            OGS_FATAL("All tangent operator blocks must be used.");
        }
    }

References block(), blockIndex(), ERR(), invalid_offset_, offsets_, OGS_FATAL, and size().

Member Function Documentation

◆ block()

template<int DisplacementDim, typename ForcesGradsCombinations>

template<typename Force, typename GradOrExtStateVar>

auto MaterialLib::Solids::MFront::OGSMFrontTangentOperatorBlocksView< DisplacementDim, ForcesGradsCombinations >::block	(	Force	,
		GradOrExtStateVar	,
		OGSMFrontTangentOperatorData const &	data ) const

inline

Read access to the block dForce/dGradOrExtStateVar.

Returns an Eigen::Map, or a double value in the 1x1 case.

If the block is not provided by the MFront behavior, the returned data is all zero.

Definition at line 158 of file TangentOperatorBlocksView.h.

    {
        static_assert(
            boost::mp11::mp_contains<
                ForcesGradsCombinations,
                boost::mp11::mp_list<Force, GradOrExtStateVar>>::value,
            "Requested tangent block was not created in the "
            "OGSMFrontTangentOperatorBlocksView.");
 
        constexpr auto index = blockIndex<Force, GradOrExtStateVar>();
        const auto offset = offsets_[index];
 
        constexpr auto force_size = Force::template size<DisplacementDim>();
        constexpr auto grad_size =
            GradOrExtStateVar::template size<DisplacementDim>();
 
        if constexpr (grad_size == 1 && force_size == 1)
        {
            if (offset == invalid_offset_)
            {
                return 0.0;
            }
 
            return data.data[offset];
        }
        else
        {
            constexpr auto order =
                grad_size == 1 ? Eigen::ColMajor : Eigen::RowMajor;
 
            using Result = Eigen::Map<
                const Eigen::Matrix<double, force_size, grad_size, order>>;
 
            if (offset == invalid_offset_)
            {
                return Result{
                    detail::OGSMFrontTangentOperatorBlocksViewZeroes.data()};
            }
 
            return Result{data.data.data() + offset};
        }
    }

References blockIndex(), MaterialLib::Solids::MFront::OGSMFrontTangentOperatorData::data, invalid_offset_, offsets_, MaterialLib::Solids::MFront::detail::OGSMFrontTangentOperatorBlocksViewZeroes, and size().

Referenced by OGSMFrontTangentOperatorBlocksView().

◆ blockIndex()

template<int DisplacementDim, typename ForcesGradsCombinations>

template<typename Force, typename GradOrExtStateVar>

constexpr std::size_t MaterialLib::Solids::MFront::OGSMFrontTangentOperatorBlocksView< DisplacementDim, ForcesGradsCombinations >::blockIndex ( )

inlinestaticconstexprprivate

Computes the index of a tangent operator block in the offsets_ array.

Definition at line 239 of file TangentOperatorBlocksView.h.

    {
        return boost::mp11::mp_find<
            ForcesGradsCombinations,
            boost::mp11::mp_list<Force, GradOrExtStateVar>>::value;
    }

Referenced by OGSMFrontTangentOperatorBlocksView(), and block().

◆ size()

template<int DisplacementDim, typename ForcesGradsCombinations>

constexpr std::size_t MaterialLib::Solids::MFront::OGSMFrontTangentOperatorBlocksView< DisplacementDim, ForcesGradsCombinations >::size ( mgis::behaviour::Variable::Type vt )

inlinestaticconstexprprivate

Definition at line 204 of file TangentOperatorBlocksView.h.

    {
        using VT = mgis::behaviour::Variable::Type;
 
        switch (vt)
        {
            case VT::SCALAR:
                return 1;
            case VT::STENSOR:
                return MathLib::KelvinVector::kelvin_vector_dimensions(
                    DisplacementDim);
            case VT::VECTOR:
                return DisplacementDim;
            case VT::TENSOR:
                return MaterialPropertyLib::tensorSize(DisplacementDim);
            case VT::VECTOR_1D:
            case VT::VECTOR_2D:
            case VT::VECTOR_3D:
            case VT::STENSOR_1D:
            case VT::STENSOR_2D:
            case VT::STENSOR_3D:
            case VT::TENSOR_1D:
            case VT::TENSOR_2D:
            case VT::TENSOR_3D:
            case VT::HIGHER_ORDER_TENSOR:
            case VT::ARRAY:
                break;  // Unsupported variable types
        }
 
        OGS_FATAL("Unsupported MGIS variable type {}.",
                  BaseLib::to_underlying(vt));
    }