Namespaces
namespace	detail

Functions
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.

{
    static_assert(boost::mp11::mp_similar<std::tuple<>,
                                          std::remove_cv_t<Tuples>...>::value,
                  "In the argument ts... there must be only std::tuple's.");
 
    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

constructed by calling a static create() method of the model's class,
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.

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

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

Referenced by ProcessLib::RichardsMechanics::createConstitutiveModels(), 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: apply()

Definition at line 274 of file Apply.h.

{
    static_assert(boost::mp11::mp_similar<std::tuple<>,
                                          std::remove_cv_t<Tuples>...>::value,
                  "In the argument ts... there must be only std::tuple's.");
 
    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: eval()

Definition at line 294 of file Apply.h.

{
    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 59 of file Get.h.

{
    using namespace boost::mp11;
 
    static_assert(std::is_same_v<T, std::remove_cvref_t<T>>,
                  "The passed type T must not be cvref qualified.");
 
    using FlattenedTuple = typename detail::GetFlattenedTupleTypes<
        std::remove_cv_t<Tuples>...>::type;
    using FlattenedTupleOfPlainTypes =
        mp_transform<std::remove_cvref_t, FlattenedTuple>;
 
    static_assert(
        mp_is_set_v<FlattenedTupleOfPlainTypes>,
        "The types of all elements of all passed tuples must be unique.");
 
    static_assert(mp_contains_v<FlattenedTupleOfPlainTypes, T>,
                  "Type T must be inside any of the passed tuples.");
 
    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.

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

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

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

Namespaces