ProcessLib::Graph Namespace Reference


namespace  detail


template<typename Function , typename... Tuples>
auto apply (Function &f, Tuples &... ts) -> typename detail::GetFunctionReturnType< std::decay_t< Function > >::type
template<typename Function , typename... Tuples>
auto eval (Function &f, Tuples &... ts) -> typename detail::GetFunctionReturnType< decltype(&Function::eval)>::type
template<typename Functions , typename... Tuples>
void evalAllInOrder (Functions &fs, Tuples &... ts)
template<typename Models , typename Inputs >
bool isEvalOrderCorrectRT ()
template<typename TupleOfModels , typename... Args>
TupleOfModels constructModels (Args &&... args)
template<typename T , typename... Tuples>
auto & get (Tuples &... ts)

Function Documentation

◆ apply()

template<typename Function , typename... Tuples>
auto ProcessLib::Graph::apply ( Function & f,
Tuples &... ts ) -> typename detail::GetFunctionReturnType<std::decay_t<Function>>::type

Invokes the passed function (object) f with arguments taken from the passed tuples.

The passed arguments are determined from their types. Therefore, both the argument types of the function and the member types of all passed tuples must be unique.

Definition at line 257 of file Apply.h.

260 static_assert(boost::mp11::mp_similar<std::tuple<>,
261 std::remove_cv_t<Tuples>...>::value,
262 "In the argument ts... there must be only std::tuple's.");
264 return detail::applyImpl(f, ts...);

References ProcessLib::Graph::detail::applyImpl().

◆ constructModels()

template<typename TupleOfModels , typename... Args>
TupleOfModels ProcessLib::Graph::constructModels ( Args &&... args)

Constructs a tuple of models.

Each model in the tuple is either

  1. constructed by calling a static create() method of the model's class,
  2. or by default construction if the former does not exist.

In case (1.) the arguments are passed via their data types from the passed args to the create() method.

Definition at line 69 of file ConstructModels.h.

71 return detail::constructModels(
72 std::type_identity<TupleOfModels>{},
73 std::forward_as_tuple(std::forward<Args>(args)...));

References ProcessLib::Graph::detail::constructModels().

Referenced by ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::createConstitutiveModels(), and ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::createConstitutiveModels().

◆ eval()

template<typename Function , typename... Tuples>
auto ProcessLib::Graph::eval ( Function & f,
Tuples &... ts ) -> typename detail::GetFunctionReturnType<decltype(&Function::eval)>::type

Invokes the eval() method of the passed object f with arguments taken from the passed tuples.

See also

Definition at line 274 of file Apply.h.

277 static_assert(boost::mp11::mp_similar<std::tuple<>,
278 std::remove_cv_t<Tuples>...>::value,
279 "In the argument ts... there must be only std::tuple's.");
281 return detail::applyImpl(&Function::eval, f, ts...);

References ProcessLib::Graph::detail::applyImpl().

◆ evalAllInOrder()

template<typename Functions , typename... Tuples>
void ProcessLib::Graph::evalAllInOrder ( Functions & fs,
Tuples &... ts )

Invokes the eval() method of the passed objects fs with arguments taken from the passed tuples.

fs must be a tuple of objects having an eval() method. The method invocation proceeds in the order of the objects in the tuple.

See also

Definition at line 294 of file Apply.h.

296 boost::mp11::tuple_for_each(fs, [&ts...](auto& f) { eval(f, ts...); });

Referenced by ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::ConstitutiveSetting< DisplacementDim >::eval(), and ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::ConstitutiveSetting< DisplacementDim >::eval().

◆ get()

template<typename T , typename... Tuples>
auto & ProcessLib::Graph::get ( Tuples &... ts)

Type-based access of an element of any of the passed tuples.

This function does essentially the same as std::get<T>(some_tuple), but for any number of passed tuples.

The type T must be present in the Tuples's member types exactly once. The passed Tuples's member types might be cvref qualified, but T must not.

Definition at line 67 of file Get.h.

69 using namespace boost::mp11;
71 static_assert(std::is_same_v<T, std::remove_cvref_t<T>>,
72 "The passed type T must not be cvref qualified.");
74 using FlattenedTuple = typename detail::GetFlattenedTupleTypes<
75 std::remove_cv_t<Tuples>...>::type;
76 using FlattenedTupleOfPlainTypes =
77 mp_transform<std::remove_cvref_t, FlattenedTuple>;
79 static_assert(
80 detail::mp_is_set_v<FlattenedTupleOfPlainTypes>,
81 "The types of all elements of all passed tuples must be unique.");
83 static_assert(detail::mp_contains_v<FlattenedTupleOfPlainTypes, T>,
84 "Type T must be inside any of the passed tuples.");
86 return detail::getImpl<T>(ts...);

◆ isEvalOrderCorrectRT()

template<typename Models , typename Inputs >
bool ProcessLib::Graph::isEvalOrderCorrectRT ( )

Checks at runtime if the given Models are evaluated in the right order if evaluated in the order in which they appear in the list of Models.

I.e., all input data of a model must have been computed before that model will be evaluated and no two models must compute the same data.

The passed Inputs are data that already have been computed before the first model is evaluated.

Definition at line 114 of file CheckEvalOrderRT.h.

116 using namespace boost::mp11;
118 static_assert(mp_is_list<Models>::value);
119 static_assert(mp_is_list<Inputs>::value);
121 // Wrap inputs. The elements of InputsWrapped are default constructible.
122 using InputsWrapped = mp_transform<mp_identity, Inputs>;
124 // "Holds" all data that has been computed successively by the invoked
125 // models.
126 std::unordered_set<std::type_index> computed_data;
128 // All inputs are considered "computed data".
129 mp_for_each<InputsWrapped>(
130 [&computed_data]<typename Input>(mp_identity<Input>)
131 { computed_data.emplace(typeid(Input)); });
133 return detail::isEvalOrderCorrectRT(mp_rename<Models, mp_list>{},
134 std::move(computed_data));

References ProcessLib::Graph::detail::isEvalOrderCorrectRT().

Referenced by ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::checkCorrectModelEvalOrder(), and ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::checkCorrectModelEvalOrder().