ProcessLib::Graph Namespace Reference

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 253 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

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 59 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::LargeDeformation::ConstitutiveRelations::createConstitutiveModels(), ProcessLib::RichardsMechanics::createConstitutiveModels(), ProcessLib::SmallDeformation::ConstitutiveRelations::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 270 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 290 of file Apply.h.

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

Referenced by ProcessLib::LargeDeformation::ConstitutiveRelations::ConstitutiveSetting< DisplacementDim >::eval(), ProcessLib::SmallDeformation::ConstitutiveRelations::ConstitutiveSetting< DisplacementDim >::eval(), 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 53 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...);
}

References ProcessLib::Graph::detail::getImpl(), boost::mp11::mp_contains_v, and boost::mp11::mp_is_set_v.

Referenced by ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsLocalAssembler< ShapeFunctionDisplacement, ShapeFunction, DisplacementDim, ConstitutiveTraits >::assembleWithJacobianSingleIP(), ProcessLib::Graph::detail::unpackAndInvoke(), ProcessLib::Graph::detail::unpackAndInvoke(), ProcessLib::Graph::detail::unpackAndInvoke(), ProcessLib::Graph::detail::unpackAndInvoke(), and ProcessLib::Graph::detail::unpackAndInvoke().

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 109 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::LargeDeformation::ConstitutiveRelations::checkCorrectModelEvalOrder(), ProcessLib::SmallDeformation::ConstitutiveRelations::checkCorrectModelEvalOrder(), ProcessLib::ThermoRichardsMechanics::ConstitutiveStress_StrainTemperature::checkCorrectModelEvalOrder(), and ProcessLib::ThermoRichardsMechanics::ConstitutiveStressSaturation_StrainPressureTemperature::checkCorrectModelEvalOrder().