ops.H File Reference

Combination-Reduction operation for a parallel run. More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	eqOp2< T1, T2 >
class	eqOp< T >
class	plusEqOp2< T1, T2 >
class	plusEqOp< T >
class	minusEqOp2< T1, T2 >
class	minusEqOp< T >
class	multiplyEqOp2< T1, T2 >
class	multiplyEqOp< T >
class	divideEqOp2< T1, T2 >
class	divideEqOp< T >
class	eqSqrOp2< T1, T2 >
class	eqSqrOp< T >
class	eqMagOp2< T1, T2 >
class	eqMagOp< T >
class	plusEqMagSqrOp2< T1, T2 >
class	plusEqMagSqrOp< T >
class	maxEqOp2< T1, T2 >
class	maxEqOp< T >
class	minEqOp2< T1, T2 >
class	minEqOp< T >
class	minMagSqrEqOp2< T1, T2 >
class	minMagSqrEqOp< T >
class	maxMagSqrEqOp2< T1, T2 >
class	maxMagSqrEqOp< T >
class	andEqOp2< T1, T2 >
class	andEqOp< T >
class	orEqOp2< T1, T2 >
class	orEqOp< T >
class	notEqOp2< T1, T2 >
class	notEqOp< T >
class	eqMinusOp2< T1, T2 >
class	eqMinusOp< T >
class	nopEqOp2< T1, T2 >
class	nopEqOp< T >
class	sumOp3< T, T1, T2 >
class	sumOp2< T1, T2 >
class	sumOp< T >
class	plusOp3< T, T1, T2 >
class	plusOp2< T1, T2 >
class	plusOp< T >
class	minusOp3< T, T1, T2 >
class	minusOp2< T1, T2 >
class	minusOp< T >
class	multiplyOp3< T, T1, T2 >
class	multiplyOp2< T1, T2 >
class	multiplyOp< T >
class	divideOp3< T, T1, T2 >
class	divideOp2< T1, T2 >
class	divideOp< T >
class	cmptMultiplyOp3< T, T1, T2 >
class	cmptMultiplyOp2< T1, T2 >
class	cmptMultiplyOp< T >
class	cmptPowOp3< T, T1, T2 >
class	cmptPowOp2< T1, T2 >
class	cmptPowOp< T >
class	cmptDivideOp3< T, T1, T2 >
class	cmptDivideOp2< T1, T2 >
class	cmptDivideOp< T >
class	stabiliseOp3< T, T1, T2 >
class	stabiliseOp2< T1, T2 >
class	stabiliseOp< T >
class	maxOp3< T, T1, T2 >
class	maxOp2< T1, T2 >
class	maxOp< T >
class	minOp3< T, T1, T2 >
class	minOp2< T1, T2 >
class	minOp< T >
class	minMagSqrOp3< T, T1, T2 >
class	minMagSqrOp2< T1, T2 >
class	minMagSqrOp< T >
class	maxMagSqrOp3< T, T1, T2 >
class	maxMagSqrOp2< T1, T2 >
class	maxMagSqrOp< T >
class	minModOp3< T, T1, T2 >
class	minModOp2< T1, T2 >
class	minModOp< T >
class	andOp3< T, T1, T2 >
class	andOp2< T1, T2 >
class	andOp< T >
class	orOp3< T, T1, T2 >
class	orOp2< T1, T2 >
class	orOp< T >
class	notOp3< T, T1, T2 >
class	notOp2< T1, T2 >
class	notOp< T >
class	eqEqOp3< T, T1, T2 >
class	eqEqOp2< T1, T2 >
class	eqEqOp< T >
class	lessOp3< T, T1, T2 >
class	lessOp2< T1, T2 >
class	lessOp< T >
class	lessEqOp3< T, T1, T2 >
class	lessEqOp2< T1, T2 >
class	lessEqOp< T >
class	greaterOp3< T, T1, T2 >
class	greaterOp2< T1, T2 >
class	greaterOp< T >
class	greaterEqOp3< T, T1, T2 >
class	greaterEqOp2< T1, T2 >
class	greaterEqOp< T >
class	multiplyWeightedOp< Type, CombineOp >

Namespaces
	Foam
	Namespace for OpenFOAM.

Macros
#define	EqOp(opName, op)
#define	WARNRETURN
#define	Op(opName, op)
#define	weightedOp(opName, op)

Detailed Description

Combination-Reduction operation for a parallel run.

Original source file ops.H

InClass Foam::Pstream

The information from all nodes is collected on the master node, combined using the given combination function and the result is broadcast to all nodes

Definition in file ops.H.

Macro Definition Documentation

EqOp

#define EqOp	(		opName,
			op
	)

Value:

\
template<class T1, class T2>                                                   \
class opName##Op2                                                              \
{                                                                              \
public:                                                                        \
                                                                               \
    void operator()(T1& x, const T2& y) const                                  \
    {                                                                          \
        op;                                                                    \
    }                                                                          \
};                                                                             \
                                                                               \
template<class T>                                                              \
class opName##Op                                                               \
{                                                                              \
public:                                                                        \
                                                                               \
    void operator()(T& x, const T& y) const                                    \
    {                                                                          \
        op;                                                                    \
    }                                                                          \
};

Definition at line 46 of file ops.H.

WARNRETURN

#define WARNRETURN

Definition at line 98 of file ops.H.

Op

#define Op	(		opName,
			op
	)

Definition at line 101 of file ops.H.

Referenced by fieldsExpression::calcGeoFieldOp(), fieldsExpression::fold(), fieldsExpression::foldA(), fieldsExpression::foldAB(), fieldsExpression::opAndStore(), Foam::prismOp(), Foam::quadOp(), Foam::tetCutTet(), and Foam::triCutTri().

weightedOp

#define weightedOp	(		opName,
			op
	)

Value:

\
    template<class Type, class CombineOp>                                      \
    class opName##WeightedOp                                                   \
    {                                                                          \
        const CombineOp& cop_;                                                 \
                                                                               \
        public:                                                                \
                                                                               \
            opName##WeightedOp(const CombineOp& cop)                           \
            :                                                                  \
                cop_(cop)                                                      \
            {}                                                                 \
                                                                               \
            void operator()                                                    \
            (                                                                  \
                Type& x,                                                       \
                const label index,                                             \
                const Type& y,                                                 \
                const scalar weight                                            \
            ) const                                                            \
            {                                                                  \
                cop_(x, op);                                                   \
            }                                                                  \
    };                                                                         \

Definition at line 137 of file ops.H.