ThermodynamicForcesView.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <Eigen/Core>
#include <boost/mp11.hpp>
 
namespace MaterialLib::Solids::MFront
{
struct OGSMFrontThermodynamicForcesData
{
    std::vector<double> data;
};

template <int DisplacementDim, typename TDynForces>
class OGSMFrontThermodynamicForcesView
{
    static_assert(boost::mp11::mp_is_set<TDynForces>::value,
                  "The types in the list TDynForces are not unique.");

    template <typename Variable>
    struct SizeOf
        : boost::mp11::mp_size_t<Variable::template size<DisplacementDim>()>
    {
    };

    template <typename Force>
    static constexpr std::size_t dataOffset()
    {
        using namespace boost::mp11;
        static_assert(mp_contains<TDynForces, Force>::value,
                      "The type Force is not in the list TDynForces.");
 
        using ForceIndex = mp_find<TDynForces, Force>;
 
        using ForcesHead = mp_take<TDynForces, ForceIndex>;
 
        using Sizes = mp_transform<SizeOf, ForcesHead>;
 
        return mp_apply<mp_plus, Sizes>::value;
    }

    template <typename Force, typename DataVector>
    static constexpr auto asEigenMap(DataVector& data)
    {
        static_assert(Force::template size<DisplacementDim>() != 1,
                      "Use asDouble for the single component case.");
 
        assert(data.size() == data_size_all_forces);
 
        constexpr std::size_t data_offset = dataOffset<Force>();
 
        constexpr std::size_t rows = Force::template rows<DisplacementDim>();
        constexpr std::size_t cols = Force::template cols<DisplacementDim>();
        constexpr auto order = cols == 1 ? Eigen::ColMajor : Eigen::RowMajor;
 
        using MatrixType =
            std::conditional_t<std::is_const_v<DataVector>,
                               const Eigen::Matrix<double, rows, cols, order>,
                               Eigen::Matrix<double, rows, cols, order>>;
 
        return Eigen::Map<MatrixType>(data.data() + data_offset);
    }

    template <typename Force, typename DataVector>
    static constexpr auto& asDouble(DataVector& data)
    {
        static_assert(Force::template size<DisplacementDim>() == 1,
                      "Use asEigenMap for the multi component case.");
 
        assert(data.size() == data_size_all_forces);
 
        constexpr std::size_t data_offset = dataOffset<Force>();
 
        return data[data_offset];
    }
 
public:
    template <typename Force>
    auto block(Force force, OGSMFrontThermodynamicForcesData const& data) const
    {
        return block(force, data.data);
    }

    template <typename Force>
    auto block(Force, std::vector<double> const& data) const
    {
        constexpr std::size_t data_size =
            Force::template size<DisplacementDim>();
 
        if constexpr (data_size == 1)
        {
            return asDouble<Force>(data);
        }
        else
        {
            return asEigenMap<Force>(data);
        }
    }

    template <typename Force,
              std::enable_if_t<SizeOf<Force>::value == 1, bool> = true>
    double& block(Force force, OGSMFrontThermodynamicForcesData& data) const
    {
        return block(force, data.data);
    }

    template <typename Force,
              std::enable_if_t<SizeOf<Force>::value == 1, bool> = true>
    double& block(Force, std::vector<double>& data) const
    {
        return asDouble<Force>(data);
    }

    template <typename Force,
              std::enable_if_t<SizeOf<Force>::value != 1, bool> = true>
    auto block(Force force, OGSMFrontThermodynamicForcesData& data) const
    {
        return block(force, data.data);
    }

    template <typename Force,
              std::enable_if_t<SizeOf<Force>::value != 1, bool> = true>
    auto block(Force, std::vector<double>& data) const
    {
        return asEigenMap<Force>(data);
    }

    static constexpr std::size_t data_size_all_forces = boost::mp11::mp_apply<
        boost::mp11::mp_plus,
        boost::mp11::mp_transform<SizeOf, TDynForces>>::value;
};
}  // namespace MaterialLib::Solids::MFront