Merge branch 'io-for-strong-type' into 'master'

Enable reflected I/O for StrongTypes

See merge request ogs/ogs!5004

BaseLib/BoostMP11Utils.h

@@ -0,0 +1,30 @@
+/**
+ * \file
+ * \copyright
+ * Copyright (c) 2012-2024, OpenGeoSys Community (http://www.opengeosys.org)
+ *            Distributed under a Modified BSD License.
+ *              See accompanying file LICENSE.txt or
+ *              http://www.opengeosys.org/project/license
+ */
+
+#pragma once
+
+#include <boost/mp11.hpp>
+
+namespace boost::mp11
+{
+// Alias to be used together with static_assert to improve possible compile
+// error messages.
+template <typename List, typename Elem>
+constexpr bool mp_contains_v = mp_contains<List, Elem>::value;
+
+// Alias to be used together with static_assert to improve possible compile
+// error messages
+template <typename Set>
+constexpr bool mp_is_list_v = mp_is_list<Set>::value;
+
+// Alias to be used together with static_assert to improve possible compile
+// error messages
+template <typename Set>
+constexpr bool mp_is_set_v = mp_is_set<Set>::value;
+}  // namespace boost::mp11

ProcessLib/Graph/Apply.h

@@ -229,14 +229,14 @@ auto applyImpl(Function&& f, Args&&... args) ->
         mp_transform<std::remove_cvref_t, FlattenedTuple>;
 
     static_assert(
-        boost::mp11::mp_is_set<FlattenedTupleOfPlainTypes>::value,
+        mp_is_set_v<FlattenedTupleOfPlainTypes>,
         "The types of all elements of all passed tuples must be unique.");
 
     using FunctionArgumentTypesPlain =
         typename detail::GetFunctionArgumentTypesPlain<FunctionPlain>::type;
 
     static_assert(
-        boost::mp11::mp_is_set<FunctionArgumentTypesPlain>::value,
+        mp_is_set_v<FunctionArgumentTypesPlain>,
         "The argument types of the function to be called must be unique.");
 
     return unpackAndInvoke(FunctionArgumentTypesPlain{},

ProcessLib/Graph/Get.h

@@ -11,6 +11,8 @@
 
 #include <boost/mp11.hpp>
 
+#include "BaseLib/BoostMP11Utils.h"
+
 namespace ProcessLib::Graph
 {
 namespace detail
@@ -43,16 +45,6 @@ struct GetFlattenedTupleTypes
 
     using type = boost::mp11::mp_flatten<std::tuple<Tuples...>>;
 };
-
-// Alias to be used together with static_assert to improve possible compile
-// error messages.
-template <typename List, typename Elem>
-constexpr bool mp_contains_v = boost::mp11::mp_contains<List, Elem>::value;
-
-// Alias to be used together with static_assert to improve possible compile
-// error messages
-template <typename Set>
-constexpr bool mp_is_set_v = boost::mp11::mp_is_set<Set>::value;
 }  // namespace detail
 
 /// Type-based access of an element of any of the passed tuples.
@@ -77,10 +69,10 @@ auto& get(Tuples&... ts)
         mp_transform<std::remove_cvref_t, FlattenedTuple>;
 
     static_assert(
-        detail::mp_is_set_v<FlattenedTupleOfPlainTypes>,
+        mp_is_set_v<FlattenedTupleOfPlainTypes>,
         "The types of all elements of all passed tuples must be unique.");
 
-    static_assert(detail::mp_contains_v<FlattenedTupleOfPlainTypes, T>,
+    static_assert(mp_contains_v<FlattenedTupleOfPlainTypes, T>,
                   "Type T must be inside any of the passed tuples.");
 
     return detail::getImpl<T>(ts...);

ProcessLib/Reflection/ReflectionIPData.h

@@ -12,41 +12,15 @@
 
 #include <boost/mp11.hpp>
 
+#include "BaseLib/BoostMP11Utils.h"
+#include "BaseLib/StrongType.h"
 #include "MathLib/KelvinVector.h"
 #include "ReflectionData.h"
 
 namespace ProcessLib::Reflection
 {
 namespace detail
 {
-template <typename T>
-concept has_reflect = requires { T::reflect(); };
-
-template <typename... Ts>
-auto reflect(std::type_identity<std::tuple<Ts...>>)
-{
-    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_); }...);
-}
-
-template <has_reflect T>
-auto reflect(std::type_identity<T>)
-{
-    return T::reflect();
-}
-
-template <typename T>
-concept is_reflectable = requires {
-    ProcessLib::Reflection::detail::reflect(std::type_identity<T>{});
-};
-
 /**
  * Raw data is data that will be read or written, e.g., double values or Eigen
  * vectors.
@@ -126,6 +100,79 @@ struct NumberOfComponents
 {
 };
 
+template <typename T>
+concept has_reflect = requires
+{
+    T::reflect();
+};
+
+template <typename... Ts>
+auto reflect(std::type_identity<std::tuple<Ts...>>)
+{
+    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_v<mp_list<Ts...>>);
+
+    return reflectWithoutName<std::tuple<Ts...>>(
+        [](auto& tuple_) -> auto& { return std::get<Ts>(tuple_); }...);
+}
+
+template <has_reflect T>
+auto reflect(std::type_identity<T>)
+{
+    return T::reflect();
+}
+
+template <typename T>
+concept has_ioName = requires(T* t)
+{
+    ioName(t);
+};
+
+template <typename T, typename Tag>
+auto reflect(std::type_identity<BaseLib::StrongType<T, Tag>>)
+{
+    using ST = BaseLib::StrongType<T, Tag>;
+
+    auto accessor = [](auto& o) -> auto&
+    {
+        return *o;
+    };
+
+    // Maybe in the future we might want to lift the following two constraints.
+    // But beware: that generalization has to be tested thoroughly such that we
+    // don't accidentally produce I/O data without name and the like.
+    static_assert(
+        has_ioName<Tag>,
+        /* We use ioName(Tag* tag), because it works with an incomplete type
+         * Tag, as opposed to ioName(Tag tag), i.e. declaring
+         *   std::string_view ioName(struct SomeTag*);
+         * is possible, whereas
+         *   std::string_view ioName(struct SomeTag);
+         * is not.
+         * This choice makes the code for every ioName() definition rather
+         * compact.
+         */
+        "For I/O of StrongType<T, Tag> you have to define an ioName(Tag* tag) "
+        "function returning the name used for I/O.");
+    static_assert(
+        is_raw_data_v<T>,
+        "I/O of StrongTypes is supported only for StrongTypes wrapping 'raw "
+        "data' such as double values, vectors and matrices.");
+
+    return std::tuple{makeReflectionData<ST>(
+        std::string{ioName(static_cast<Tag*>(nullptr))}, std::move(accessor))};
+}
+
+template <typename T>
+concept is_reflectable = requires
+{
+    ProcessLib::Reflection::detail::reflect(std::type_identity<T>{});
+};
+
 /** A function object taking a local assembler as its argument and returning a
  * <tt>std::vector\<double\></tt> of some specific "flattened" integration point
  * (IP) data.
@@ -328,6 +375,13 @@ void forEachReflectedFlattenedIPDataAccessor(
     Accessor_CurrentLevelFromIPDataVecElement const&
         accessor_current_level_from_ip_data_vec_element)
 {
+    static_assert(boost::mp11::mp_is_list_v<ReflectionDataTuple>,
+                  "The passed reflection data is not a std::tuple.");
+    static_assert(
+        std::is_same_v<ReflectionDataTuple,
+                       boost::mp11::mp_rename<ReflectionDataTuple, std::tuple>>,
+        "The passed reflection data is not a std::tuple.");
+
     boost::mp11::tuple_for_each(
         reflection_data,
         [&accessor_ip_data_vec_in_loc_asm,
@@ -357,12 +411,13 @@ void forEachReflectedFlattenedIPDataAccessor(
             }
             else
             {
-                static_assert(is_raw_data<Member>::value,
+                static_assert(is_raw_data_v<Member>,
                               "The current member is not reflectable, so we "
                               "expect it to be raw data.");
 
                 constexpr unsigned num_comp = NumberOfComponents<Member>::value;
 
+                assert(!refl_data.name.empty());
                 callback(refl_data.name, num_comp,
                          getFlattenedIPDataFromLocAsm<Dim>(
                              accessor_ip_data_vec_in_loc_asm,
@@ -401,7 +456,14 @@ template <int Dim, typename LocAsmIF, typename Callback, typename ReflData>
 void forEachReflectedFlattenedIPDataAccessor(ReflData const& reflection_data,
                                              Callback const& callback)
 {
-    boost::mp11::tuple_for_each(
+    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)
@@ -416,13 +478,13 @@ void forEachReflectedFlattenedIPDataAccessor(ReflData const& reflection_data,
 
             // AccessorResult must be a std::vector<SomeType, SomeAllocator>. We
             // check that, now.
-            static_assert(boost::mp11::mp_is_list<AccessorResult>::
-                              value);  // std::vector<SomeType, SomeAllocator>
-                                       // is a list in the Boost MP11 sense
             static_assert(
-                std::is_same_v<
-                    AccessorResult,
-                    boost::mp11::mp_rename<AccessorResult, std::vector>>,
+                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
@@ -432,7 +494,9 @@ void forEachReflectedFlattenedIPDataAccessor(ReflData const& reflection_data,
             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); };
+            {
+                return ip_data_vector_accessor(loc_asm);
+            };
 
             if constexpr (detail::is_reflectable<Member>)
             {
@@ -443,13 +507,14 @@ void forEachReflectedFlattenedIPDataAccessor(ReflData const& reflection_data,
             }
             else
             {
-                static_assert(detail::is_raw_data<Member>::value,
+                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));

ProcessLib/RichardsMechanics/RichardsMechanicsFEM-impl.h

@@ -809,8 +809,8 @@ void RichardsMechanicsLocalAssembler<ShapeFunctionDisplacement,
 
     auto const mu = liquid_phase.property(MPL::PropertyType::viscosity)
                         .template value<double>(variables, x_position, t, dt);
-    std::get<ProcessLib::ThermoRichardsMechanics::LiquidViscosityData>(CD)
-        .viscosity = mu;
+    *std::get<ProcessLib::ThermoRichardsMechanics::LiquidViscosityData>(CD) =
+        mu;
 
     // Swelling and possibly volumetric strain rate update.
     updateSwellingStressAndVolumetricStrain<DisplacementDim>(
@@ -1141,9 +1141,8 @@ void RichardsMechanicsLocalAssembler<ShapeFunctionDisplacement,
                 DisplacementDim>>(CD)
                 .Ki;
         double const mu =
-            std::get<ProcessLib::ThermoRichardsMechanics::LiquidViscosityData>(
-                CD)
-                .viscosity;
+            *std::get<ProcessLib::ThermoRichardsMechanics::LiquidViscosityData>(
+                CD);
 
         GlobalDimMatrixType const rho_Ki_over_mu = K_intrinsic * rho_LR / mu;
 

ProcessLib/ThermoRichardsMechanics/ConstitutiveCommon/DarcyLaw.cpp

@@ -10,8 +10,6 @@
 
 #include "DarcyLaw.h"
 
-#include "MaterialLib/MPL/Utils/FormEigenTensor.h"
-
 namespace ProcessLib::ThermoRichardsMechanics
 {
 template <int DisplacementDim>
@@ -23,10 +21,10 @@ void DarcyLawModel<DisplacementDim>::eval(
     ThermoOsmosisData<DisplacementDim> const& th_osmosis_data,
     DarcyLawData<DisplacementDim>& out) const
 {
-    out.v_darcy = perm_data.Ki / mu_L_data.viscosity *
-                      (perm_data.k_rel *
-                       (p_cap_data.grad_p_cap + rho_L_data.rho_LR * b_)) +
-                  th_osmosis_data.seepage_velocity_contribution;
+    *out = perm_data.Ki / mu_L_data() *
+               (perm_data.k_rel *
+                (p_cap_data.grad_p_cap + rho_L_data.rho_LR * b_)) +
+           th_osmosis_data.seepage_velocity_contribution;
 }
 
 template struct DarcyLawModel<2>;

ProcessLib/ThermoRichardsMechanics/ConstitutiveCommon/DarcyLaw.h

@@ -10,6 +10,7 @@
 
 #pragma once
 
+#include "BaseLib/StrongType.h"
 #include "LiquidDensity.h"
 #include "LiquidViscosity.h"
 #include "PermeabilityData.h"
@@ -19,18 +20,13 @@
 namespace ProcessLib::ThermoRichardsMechanics
 {
 template <int DisplacementDim>
-struct DarcyLawData
-{
-    Eigen::Vector<double, DisplacementDim> v_darcy;
-
-    static auto reflect()
-    {
-        using Self = DarcyLawData<DisplacementDim>;
+using DarcyLawData = BaseLib::StrongType<Eigen::Vector<double, DisplacementDim>,
+                                         struct DarcyLawDataTag>;
 
-        return ProcessLib::Reflection::reflectWithName("velocity",
-                                                       &Self::v_darcy);
-    }
-};
+constexpr std::string_view ioName(struct DarcyLawDataTag*)
+{
+    return "velocity";
+}
 
 template <int DisplacementDim>
 struct DarcyLawModel