Pipes

Collaboration diagram for Pipes:

Namespaces
namespace	Kratos::Pipes
	Unix-inspired pipes in C++.

Classes
class	ModelPartFromModel
	Get a ModelPart from a Model by name. More...
struct	ProcessInfoFromModelPart
	Get the ProcessInfo of a ModelPart. More...
class	VariableFromProcessInfo< TVariable >
	Get a variable from ProcessInfo. More...
struct	TimeFromProcessInfo
	Get TIME from a ProcessInfo. More...
struct	StepFromProcessInfo
	Get STEP from a ProcessInfo. More...
class	Comparison< TValue, TOperator >
	Perform a comparison operation on the input as the left hand side. More...
class	IntervalPredicate< TValue >
	Pipe wrapper for Detail::IntervalUtility. More...
class	Modulo< TValue >
	Compute the mod of the input. More...
class	Add< TValue >
	Add a constant value to the input. More...
class	ConstPredicate< TInput >
	Return a bool regardless of the input. More...
class	ModelPredicatePipe< TPipe >
struct	Traits< TInput, TOutput >
	Metaclass containing type information every pipe must inherit from. More...
class	CompoundPipe< TInputPipe, TOutputPipe >
	A composable pipe that takes the output of one pipe and feeds its result into another. More...
class	SingleSegmentPipeline< TPipe >
	An adaptor class for pipelines consisting of a single segment. More...

Typedefs
using	ConstModelPredicate = ModelPredicatePipe< Pipes::SingleSegmentPipeline< Pipes::ConstPredicate< const Model & > > >
	Always returns the boolean value it was constructed with, regardless of the input Model.
using	TimeIntervalPredicate = ModelPredicatePipe< Pipes::Pipeline< Pipes::ModelPartFromModel, Pipes::ProcessInfoFromModelPart, Pipes::TimeFromProcessInfo, Pipes::IntervalPredicate< double > > >
	Check whether TIME is greater than the provided value.
using	StepIntervalPredicate = ModelPredicatePipe< Pipes::Pipeline< Pipes::ModelPartFromModel, Pipes::ProcessInfoFromModelPart, Pipes::StepFromProcessInfo, Pipes::IntervalPredicate< int > > >
	Check whether STEP in a ModelPart is within an interval.
using	PeriodicTimeIntervalPredicate = ModelPredicatePipe< Pipes::Pipeline< Pipes::ModelPartFromModel, Pipes::ProcessInfoFromModelPart, Pipes::TimeFromProcessInfo, Pipes::Add< double >, Pipes::Modulo< double >, Pipes::IntervalPredicate< double > > >
	Check whether TIME in a ModelPart is within a cyclic interval.
using	PeriodicStepIntervalPredicate = ModelPredicatePipe< Pipes::Pipeline< Pipes::ModelPartFromModel, Pipes::ProcessInfoFromModelPart, Pipes::StepFromProcessInfo, Pipes::Modulo< int >, Pipes::IntervalPredicate< int > > >
	Check whether STEP in a ModelPart is within a cyclic interval.
template<class TPipe >
using	IsPipe = std::integral_constant< bool, std::is_same_v< decltype(std::declval< const TPipe >().operator()(std::declval< typename TPipe::InputType >())), typename TPipe::OutputType > &&!std::is_same_v< typename TPipe::InputType, void > &&!std::is_same_v< typename TPipe::OutputType, void > >
	Bool constant checking whether TPipe satisfies the requirements of a pipe.
template<class ... TPipes>
using	Pipeline = decltype((...|std::declval< TPipes >()))
	Convenience type alias for complex pipes.

Functions
template<class TInput , class TPipe , std::enable_if_t< IsPipe< TPipe >::value &&std::is_convertible_v< TInput, typename TPipe::InputType >, bool > = true>
TPipe::OutputType	operator>> (TInput &&rInput, const TPipe &rPipe)
	Operator for calling operator() of the pipe.
template<class TInputPipe , class TOutputPipe , std::enable_if_t< IsPipe< TInputPipe >::value &&IsPipe< TOutputPipe >::value, bool > = true>
CompoundPipe< TInputPipe, TOutputPipe >	operator| (TInputPipe &&rInputPipe, TOutputPipe &&rOutputPipe)
	Construct a pipe that takes the output of an input pipe and feeds it into an output pipe.
template<class TInputPipe , class TOutputPipe , std::enable_if_t< IsPipe< TInputPipe >::value &&IsPipe< TOutputPipe >::value, bool > = true>
CompoundPipe< TInputPipe, TOutputPipe >	operator| (const TInputPipe &rInputPipe, const TOutputPipe &rOutputPipe)
	Construct a pipe that takes the output of an input pipe and feeds it into an output pipe.

Detailed Description

Typedef Documentation

ConstModelPredicate

using ConstModelPredicate = ModelPredicatePipe<Pipes::SingleSegmentPipeline< Pipes::ConstPredicate<const Model&> > >

Always returns the boolean value it was constructed with, regardless of the input Model.

Model => true/false 

. Required parameters:

[
    {"value" : <bool>}
]

IsPipe

template<class TPipe >

using IsPipe = std::integral_constant<bool, std::is_same_v<decltype(std::declval<const TPipe>().operator()(std::declval<typename TPipe::InputType>())), typename TPipe::OutputType> && !std::is_same_v<typename TPipe::InputType,void> && !std::is_same_v<typename TPipe::OutputType,void> >

Bool constant checking whether TPipe satisfies the requirements of a pipe.

Pipe requirements:

• has non-void member aliases InputType and OutputType
• has member function with the following signature OutputType operator()(InputType) const
• is default, move, and copy constructible

  Todo:

  @matekelemen

PeriodicStepIntervalPredicate

using PeriodicStepIntervalPredicate = ModelPredicatePipe<Pipes::Pipeline< Pipes::ModelPartFromModel, Pipes::ProcessInfoFromModelPart, Pipes::StepFromProcessInfo, Pipes::Modulo<int>, Pipes::IntervalPredicate<int> > >

Check whether STEP in a ModelPart is within a cyclic interval.

Model => ModelPart => ProcessInfo => STEP => Modulo => DiscreteIntervalUtility::IsInInterval 

. Required parameters (other settings ignored):

[
   {"model_part_name" : ""},           // <== model part from model
   {},                                 // <== process info from model part
   {},                                 // <== step from process info
   {"mod" : 0},                        // <== modulo
   {"interval" : ["Begin", "End"]}     // <== interval utility
]

Example with

{"mod" : 12, "interval" : [3, 6]} 

TIME:   12          24          36          48          60
... ----|-----------|-----------|-----------|-----------|---- ...
           ++++        ++++        ++++        ++++        ++

Note

See DiscreteIntervalUtility for details.

PeriodicTimeIntervalPredicate

using PeriodicTimeIntervalPredicate = ModelPredicatePipe<Pipes::Pipeline< Pipes::ModelPartFromModel, Pipes::ProcessInfoFromModelPart, Pipes::TimeFromProcessInfo, Pipes::Add<double>, Pipes::Modulo<double>, Pipes::IntervalPredicate<double> > >

Check whether TIME in a ModelPart is within a cyclic interval.

Model => ModelPart => ProcessInfo => TIME => Add => Modulo => IntervalUtility::IsInInterval 

. Required parameters (other settings ignored):

[
   {"model_part_name" : ""},           // <== model part from model
   {},                                 // <== process info from model part
   {},                                 // <== time from process info
   {"value" : 0},                      // <== apply an offset
   {"mod" : 0},                        // <== modulo
   {"interval" : ["Begin", "End"]}     // <== interval utility
]

Example with

{"mod" : 12.0, "interval" : [3.0, 6.0]} 

TIME:   12          24          36          48          60
... ----|-----------|-----------|-----------|-----------|---- ...
           ++++        ++++        ++++        ++++        ++

Note

See IntervalUtility for details.

The offset can be used to handle tricky cases with module and floating point representations.

Pipeline

template<class ... TPipes>

using Pipeline = decltype((... | std::declval<TPipes>()))

Convenience type alias for complex pipes.

StepIntervalPredicate

using StepIntervalPredicate = ModelPredicatePipe<Pipes::Pipeline< Pipes::ModelPartFromModel, Pipes::ProcessInfoFromModelPart, Pipes::StepFromProcessInfo, Pipes::IntervalPredicate<int> > >

Check whether STEP in a ModelPart is within an interval.

Model => ModelPart => ProcessInfo => STEP => DiscreteIntervalUtility::IsIninterval 

. Required parameters (other settings ignored):

[
   {"model_part_name" : ""},           // <== model part from model
   {},                                 // <== process info from model part
   {},                                 // <== step from process info
   {"interval" : ["Begin", "End"]}     // <== discrete interval utility
]

Note

See DiscreteIntervalUtility for details.

TimeIntervalPredicate

using TimeIntervalPredicate = ModelPredicatePipe<Pipes::Pipeline< Pipes::ModelPartFromModel, Pipes::ProcessInfoFromModelPart, Pipes::TimeFromProcessInfo, Pipes::IntervalPredicate<double> > >

Check whether TIME is greater than the provided value.

Model => ModelPart => ProcessInfo => TIME => std::less 

. Default parameters:

             [
                {"model_part_name" : ""},   // <== model part from model
                {},                         // <== process info from model part
                {},                         // <== time from process info
                {"rhs" : 0}                 // <== double comparison
             ]
             @code
  /
using TimeGreaterPredicate = ModelPredicatePipe<Pipes::Pipeline<
    Pipes::ModelPartFromModel,
    Pipes::ProcessInfoFromModelPart,
    Pipes::TimeFromProcessInfo,
    Pipes::Comparison<double,std::greater<double>>
>>;
 
 

Note

See IntervalUtility for details.

Function Documentation

operator>>()

template<class TInput , class TPipe , std::enable_if_t< IsPipe< TPipe >::value &&std::is_convertible_v< TInput, typename TPipe::InputType >, bool > = true>

TPipe::OutputType operator>>	(	TInput &&	rInput,
		const TPipe &	rPipe
	)

Operator for calling operator() of the pipe.

operator|() [1/2]

template<class TInputPipe , class TOutputPipe , std::enable_if_t< IsPipe< TInputPipe >::value &&IsPipe< TOutputPipe >::value, bool > = true>

CompoundPipe< TInputPipe, TOutputPipe > operator|	(	const TInputPipe &	rInputPipe,
		const TOutputPipe &	rOutputPipe
	)

Construct a pipe that takes the output of an input pipe and feeds it into an output pipe.

operator|() [2/2]

template<class TInputPipe , class TOutputPipe , std::enable_if_t< IsPipe< TInputPipe >::value &&IsPipe< TOutputPipe >::value, bool > = true>

CompoundPipe< TInputPipe, TOutputPipe > operator|	(	TInputPipe &&	rInputPipe,
		TOutputPipe &&	rOutputPipe
	)

Construct a pipe that takes the output of an input pipe and feeds it into an output pipe.