OpenFOAM logo
Open Source CFD Toolkit

FieldFieldFunctions.H File Reference


Detailed Description

View FieldFieldFunctions.H
License
This file is part of OpenFOAM.

OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.

OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Generic FieldField type.

Definition in file FieldFieldFunctions.H.

Go to the source code of this file.

Namespaces

namespace  Foam

Defines

#define BINARY_FUNCTION(func)
#define TMP_UNARY_FUNCTION(returnType, func)
#define G_UNARY_FUNCTION(returnType, gFunc, func, rFunc)
#define UNARY_OPERATOR(op, opFunc)
#define BINARY_OPERATOR_FF(Type1, Type2, op, opFunc)
#define BINARY_OPERATOR_FTR(Type1, Type2, op, opFunc)
#define BINARY_OPERATOR_FT(Type1, Type2, op, opFunc)
#define BINARY_OPERATOR_TRF(Type1, Type2, op, opFunc)
#define BINARY_OPERATOR_TF(Type1, Type2, op, opFunc)
#define BINARY_OPERATOR_TRT(Type1, Type2, op, opFunc)
#define BINARY_OPERATOR_TTR(Type1, Type2, op, opFunc)
#define BINARY_OPERATOR_R(Type1, Type2, op, opFunc)
#define BINARY_TYPE_OPERATOR_TF(TYPE, op, opFunc)
#define BINARY_TYPE_OPERATOR_FT(TYPE, op, opFunc)
#define BINARY_TYPE_OPERATOR(TYPE, op, opFunc)
#define PRODUCT_OPERATOR(product, op, opFunc)

Functions

template<template< class > class Field, class Type>
void component (FieldField< Field, typename FieldField< Field, Type >::cmptType > &sf, const FieldField< Field, Type > &f, const direction d)
template<template< class > class Field, class Type>
void T (FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type, int r>
void pow (FieldField< Field, typename powProduct< Type, r >::type > &f, const FieldField< Field, Type > &vf)
template<template< class > class Field, class Type, int r>
tmp< FieldField< Field, typename
powProduct< Type, r >::type > > 
pow (const FieldField< Field, Type > &f, typename powProduct< Type, r >::type=pTraits< typename powProduct< Type, r >::type >::zero)
template<template< class > class Field, class Type, int r>
tmp< FieldField< Field, typename
powProduct< Type, r >::type > > 
pow (const tmp< FieldField< Field, Type > > &tf, typename powProduct< Type, r >::type=pTraits< typename powProduct< Type, r >::type >::zero)
template<template< class > class Field, class Type>
void sqr (FieldField< Field, typename outerProduct< Type, Type >::type > &f, const FieldField< Field, Type > &vf)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename
outerProduct< Type, Type
>::type > > 
sqr (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename
outerProduct< Type, Type
>::type > > 
sqr (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
void magSqr (FieldField< Field, scalar > &sf, const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, scalar > > magSqr (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, scalar > > magSqr (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
void mag (FieldField< Field, scalar > &sf, const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, scalar > > mag (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, scalar > > mag (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
void cmptAv (FieldField< Field, typename FieldField< Field, Type >::cmptType > &cf, const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename
FieldField< Field, Type
>::cmptType > > 
cmptAv (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, typename
FieldField< Field, Type
>::cmptType > > 
cmptAv (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
void cmptMag (FieldField< Field, Type > &cf, const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > cmptMag (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > cmptMag (const tmp< FieldField< Field, Type > > &tf)
template<template< class > class Field, class Type>
void max (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > max (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > max (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > max (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > max (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void max (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const Type &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > max (const FieldField< Field, Type > &f1, const Type &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > max (const tmp< FieldField< Field, Type > > &tf1, const Type &s)
template<template< class > class Field, class Type>
void min (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > min (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > min (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > min (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > min (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void min (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const Type &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > min (const FieldField< Field, Type > &f1, const Type &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > min (const tmp< FieldField< Field, Type > > &tf1, const Type &s)
template<template< class > class Field, class Type>
void scale (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > scale (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > scale (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > scale (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > scale (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void scale (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const Type &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > scale (const FieldField< Field, Type > &f1, const Type &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > scale (const tmp< FieldField< Field, Type > > &tf1, const Type &s)
template<template< class > class Field, class Type>
Type max (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type max (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type min (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type min (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type sum (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type sum (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
scalar sumMag (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
scalar sumMag (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type average (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type average (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type gMax (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type gMax (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type gMin (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type gMin (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type gSum (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type gSum (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
scalar gSumMag (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
scalar gSumMag (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
Type gAverage (const FieldField< Field, Type > &f)
template<template< class > class Field, class Type>
Type gAverage (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
void negate (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator- (const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator- (const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
void add (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator+ (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator+ (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator+ (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator+ (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void subtract (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator- (const FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator- (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator- (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, Type > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator- (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, Type > > &tf2)
template<template< class > class Field, class Type>
void divide (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const FieldField< Field, scalar > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator/ (const FieldField< Field, Type > &f1, const FieldField< Field, scalar > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator/ (const FieldField< Field, Type > &f1, const tmp< FieldField< Field, scalar > > &tf2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator/ (const tmp< FieldField< Field, Type > > &tf1, const FieldField< Field, scalar > &f2)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator/ (const tmp< FieldField< Field, Type > > &tf1, const tmp< FieldField< Field, scalar > > &tf2)
template<template< class > class Field, class Type>
void add (FieldField< Field, Type > &f, const Type &s, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator+ (const Type &s, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator+ (const Type &s, const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
void add (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const Type &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator+ (const FieldField< Field, Type > &f1, const Type &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator+ (const tmp< FieldField< Field, Type > > &tf1, const Type &s)
template<template< class > class Field, class Type>
void subtract (FieldField< Field, Type > &f, const Type &s, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator- (const Type &s, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator- (const Type &s, const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
void subtract (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const Type &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator- (const FieldField< Field, Type > &f1, const Type &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator- (const tmp< FieldField< Field, Type > > &tf1, const Type &s)
template<template< class > class Field, class Type>
void multiply (FieldField< Field, Type > &f, const scalar &s, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator * (const scalar &s, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator * (const scalar &s, const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type>
void multiply (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const scalar &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator * (const FieldField< Field, Type > &f1, const scalar &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator * (const tmp< FieldField< Field, Type > > &tf1, const scalar &s)
template<template< class > class Field, class Type>
void divide (FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const scalar &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator/ (const FieldField< Field, Type > &f1, const scalar &s)
template<template< class > class Field, class Type>
tmp< FieldField< Field, Type > > operator/ (const tmp< FieldField< Field, Type > > &tf1, const scalar &s)
template<template< class > class Field, class Type1, class Type2>
void outer (FieldField< Field, typename outerProduct< Type1, Type2 >::type > &f, const FieldField< Field, Type1 > &f1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
outerProduct< Type1, Type2
>::type > > 
operator * (const FieldField< Field, Type1 > &f1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
outerProduct< Type1, Type2
>::type > > 
operator * (const FieldField< Field, Type1 > &f1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
outerProduct< Type1, Type2
>::type > > 
operator * (const tmp< FieldField< Field, Type1 > > &tf1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
outerProduct< Type1, Type2
>::type > > 
operator * (const tmp< FieldField< Field, Type1 > > &tf1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
void outer (FieldField< Field, typename outerProduct< Type, Form >::type > &f, const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
tmp< FieldField< Field, typename
outerProduct< Type, Form
>::type > > 
operator * (const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
tmp< FieldField< Field, typename
outerProduct< Type, Form
>::type > > 
operator * (const tmp< FieldField< Field, Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
void outer (FieldField< Field, typename outerProduct< Form, Type >::type > &f, const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
tmp< FieldField< Field, typename
outerProduct< Form, Type
>::type > > 
operator * (const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
tmp< FieldField< Field, typename
outerProduct< Form, Type
>::type > > 
operator * (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type1, class Type2>
void cross (FieldField< Field, typename crossProduct< Type1, Type2 >::type > &f, const FieldField< Field, Type1 > &f1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
crossProduct< Type1, Type2
>::type > > 
operator^ (const FieldField< Field, Type1 > &f1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
crossProduct< Type1, Type2
>::type > > 
operator^ (const FieldField< Field, Type1 > &f1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
crossProduct< Type1, Type2
>::type > > 
operator^ (const tmp< FieldField< Field, Type1 > > &tf1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
crossProduct< Type1, Type2
>::type > > 
operator^ (const tmp< FieldField< Field, Type1 > > &tf1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
void cross (FieldField< Field, typename crossProduct< Type, Form >::type > &f, const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
tmp< FieldField< Field, typename
crossProduct< Type, Form
>::type > > 
operator^ (const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
tmp< FieldField< Field, typename
crossProduct< Type, Form
>::type > > 
operator^ (const tmp< FieldField< Field, Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
void cross (FieldField< Field, typename crossProduct< Form, Type >::type > &f, const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
tmp< FieldField< Field, typename
crossProduct< Form, Type
>::type > > 
operator^ (const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
tmp< FieldField< Field, typename
crossProduct< Form, Type
>::type > > 
operator^ (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type1, class Type2>
void dot (FieldField< Field, typename innerProduct< Type1, Type2 >::type > &f, const FieldField< Field, Type1 > &f1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
innerProduct< Type1, Type2
>::type > > 
operator & (const FieldField< Field, Type1 > &f1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
innerProduct< Type1, Type2
>::type > > 
operator & (const FieldField< Field, Type1 > &f1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
innerProduct< Type1, Type2
>::type > > 
operator & (const tmp< FieldField< Field, Type1 > > &tf1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
innerProduct< Type1, Type2
>::type > > 
operator & (const tmp< FieldField< Field, Type1 > > &tf1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
void dot (FieldField< Field, typename innerProduct< Type, Form >::type > &f, const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
tmp< FieldField< Field, typename
innerProduct< Type, Form
>::type > > 
operator & (const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
tmp< FieldField< Field, typename
innerProduct< Type, Form
>::type > > 
operator & (const tmp< FieldField< Field, Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
void dot (FieldField< Field, typename innerProduct< Form, Type >::type > &f, const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
tmp< FieldField< Field, typename
innerProduct< Form, Type
>::type > > 
operator & (const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
tmp< FieldField< Field, typename
innerProduct< Form, Type
>::type > > 
operator & (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< FieldField< Field, Type > > &tf1)
template<template< class > class Field, class Type1, class Type2>
void dotdot (FieldField< Field, typename scalarProduct< Type1, Type2 >::type > &f, const FieldField< Field, Type1 > &f1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
scalarProduct< Type1, Type2
>::type > > 
operator && (const FieldField< Field, Type1 > &f1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
scalarProduct< Type1, Type2
>::type > > 
operator && (const FieldField< Field, Type1 > &f1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
scalarProduct< Type1, Type2
>::type > > 
operator && (const tmp< FieldField< Field, Type1 > > &tf1, const FieldField< Field, Type2 > &f2)
template<template< class > class Field, class Type1, class Type2>
tmp< FieldField< Field, typename
scalarProduct< Type1, Type2
>::type > > 
operator && (const tmp< FieldField< Field, Type1 > > &tf1, const tmp< FieldField< Field, Type2 > > &tf2)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
void dotdot (FieldField< Field, typename scalarProduct< Type, Form >::type > &f, const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
tmp< FieldField< Field, typename
scalarProduct< Type, Form
>::type > > 
operator && (const FieldField< Field, Type > &f1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Type, class Form, class Cmpt, int nCmpt>
tmp< FieldField< Field, typename
scalarProduct< Type, Form
>::type > > 
operator && (const tmp< FieldField< Field, Type > > &tf1, const VectorSpace< Form, Cmpt, nCmpt > &vs)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
void dotdot (FieldField< Field, typename scalarProduct< Form, Type >::type > &f, const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
tmp< FieldField< Field, typename
scalarProduct< Form, Type
>::type > > 
operator && (const VectorSpace< Form, Cmpt, nCmpt > &vs, const FieldField< Field, Type > &f1)
template<template< class > class Field, class Form, class Cmpt, int nCmpt, class Type>
tmp< FieldField< Field, typename
scalarProduct< Form, Type
>::type > > 
operator && (const VectorSpace< Form, Cmpt, nCmpt > &vs, const tmp< FieldField< Field, Type > > &tf1)


Define Documentation

#define BINARY_FUNCTION func   ) 
 

Definition at line 155 of file FieldFieldFunctions.H.

#define BINARY_OPERATOR_FF Type1,
Type2,
op,
opFunc   ) 
 

Value:

\
template<template<class> class Field, class Type>                             \
void opFunc                                                                   \
(                                                                             \
    FieldField<Field, Type>& f,                                               \
    const FieldField<Field, Type1>& f1,                                       \
    const FieldField<Field, Type2>& f2                                        \
);                                                                            \
                                                                              \
template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const FieldField<Field, Type1>& f1,                                       \
    const FieldField<Field, Type2>& f2                                        \
);

Definition at line 305 of file FieldFieldFunctions.H.

#define BINARY_OPERATOR_FT Type1,
Type2,
op,
opFunc   ) 
 

Value:

template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const FieldField<Field, Type1>& f1,                                       \
    const tmp<FieldField<Field, Type2> >& tf2                                 \
);

Definition at line 330 of file FieldFieldFunctions.H.

#define BINARY_OPERATOR_FTR Type1,
Type2,
op,
opFunc   ) 
 

Value:

template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const FieldField<Field, Type1>& f1,                                       \
    const tmp<FieldField<Field, Type2> >& tf2                                 \
);

Definition at line 322 of file FieldFieldFunctions.H.

#define BINARY_OPERATOR_R Type1,
Type2,
op,
opFunc   ) 
 

Value:

BINARY_OPERATOR_FF(Type1, Type2, op, opFunc)                              \
    BINARY_OPERATOR_FTR(Type1, Type2, op, opFunc)                             \
    BINARY_OPERATOR_TRF(Type1, Type2, op, opFunc)                             \
    BINARY_OPERATOR_TRT(Type1, Type2, op, opFunc)

Definition at line 370 of file FieldFieldFunctions.H.

#define BINARY_OPERATOR_TF Type1,
Type2,
op,
opFunc   ) 
 

Value:

template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const tmp<FieldField<Field, Type1> >& tf1,                                \
    const FieldField<Field, Type2>& f2                                        \
);

Definition at line 346 of file FieldFieldFunctions.H.

#define BINARY_OPERATOR_TRF Type1,
Type2,
op,
opFunc   ) 
 

Value:

template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const tmp<FieldField<Field, Type1> >& tf1,                                \
    const FieldField<Field, Type2>& f2                                        \
);

Definition at line 338 of file FieldFieldFunctions.H.

#define BINARY_OPERATOR_TRT Type1,
Type2,
op,
opFunc   ) 
 

Value:

template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const tmp<FieldField<Field, Type1> >& tf1,                                \
    const tmp<FieldField<Field, Type2> >& tf2                                 \
);

Definition at line 354 of file FieldFieldFunctions.H.

#define BINARY_OPERATOR_TTR Type1,
Type2,
op,
opFunc   ) 
 

Value:

template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const tmp<FieldField<Field, Type1> >& tf1,                                \
    const tmp<FieldField<Field, Type2> >& tf2                                 \
);

Definition at line 362 of file FieldFieldFunctions.H.

#define BINARY_TYPE_OPERATOR TYPE,
op,
opFunc   ) 
 

Value:

BINARY_TYPE_OPERATOR_TF(TYPE, op, opFunc)                                 \
    BINARY_TYPE_OPERATOR_FT(TYPE, op, opFunc)

Definition at line 449 of file FieldFieldFunctions.H.

#define BINARY_TYPE_OPERATOR_FT TYPE,
op,
opFunc   ) 
 

Value:

\
template<template<class> class Field, class Type>                             \
void opFunc                                                                   \
(                                                                             \
    FieldField<Field, Type>& f,                                               \
    const FieldField<Field, Type>& f1,                                        \
    const TYPE& s                                                             \
);                                                                            \
                                                                              \
template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const FieldField<Field, Type>& f1,                                        \
    const TYPE& s                                                             \
);                                                                            \
                                                                              \
template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const tmp<FieldField<Field, Type> >& tf1,                                 \
    const TYPE& s                                                             \
);

Definition at line 425 of file FieldFieldFunctions.H.

#define BINARY_TYPE_OPERATOR_TF TYPE,
op,
opFunc   ) 
 

Value:

\
template<template<class> class Field, class Type>                             \
void opFunc                                                                   \
(                                                                             \
    FieldField<Field, Type>& f,                                               \
    const TYPE& s,                                                            \
    const FieldField<Field, Type>& f1                                         \
);                                                                            \
                                                                              \
template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const TYPE& s,                                                            \
    const FieldField<Field, Type>& f1                                         \
);                                                                            \
                                                                              \
template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const TYPE& s,                                                            \
    const tmp<FieldField<Field, Type> >& tf1                                  \
);

Definition at line 401 of file FieldFieldFunctions.H.

#define G_UNARY_FUNCTION returnType,
gFunc,
func,
rFunc   ) 
 

Value:

\
template<template<class> class Field, class Type>                             \
returnType gFunc(const FieldField<Field, Type>& f);                           \
TMP_UNARY_FUNCTION(returnType, gFunc)

Definition at line 255 of file FieldFieldFunctions.H.

#define PRODUCT_OPERATOR product,
op,
opFunc   ) 
 

Definition at line 464 of file FieldFieldFunctions.H.

#define TMP_UNARY_FUNCTION returnType,
func   ) 
 

Value:

\
template<template<class> class Field, class Type>                             \
returnType func(const tmp<FieldField<Field, Type> >& tf1);

Definition at line 222 of file FieldFieldFunctions.H.

#define UNARY_OPERATOR op,
opFunc   ) 
 

Value:

\
template<template<class> class Field, class Type>                             \
void opFunc                                                                   \
(                                                                             \
    FieldField<Field, Type>& f,                                               \
    const FieldField<Field, Type>& f1                                         \
);                                                                            \
                                                                              \
template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const FieldField<Field, Type>& f1                                         \
);                                                                            \
                                                                              \
template<template<class> class Field, class Type>                             \
tmp<FieldField<Field, Type> > operator op                                     \
(                                                                             \
    const tmp<FieldField<Field, Type> >& tf1                                  \
);

Definition at line 279 of file FieldFieldFunctions.H.


Function Documentation

void add FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const Type &  s
 

void add FieldField< Field, Type > &  f,
const Type &  s,
const FieldField< Field, Type > &  f1
 

void add FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const FieldField< Field, Type > &  f2
 

Referenced by polyMeshAdder::map().

Type average const tmp< FieldField< Field, Type > > &  tf1  ) 
 

Type average const FieldField< Field, Type > &  f  ) 
 

tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptAv const tmp< FieldField< Field, Type > > &  tf  ) 
 

tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptAv const FieldField< Field, Type > &  f  ) 
 

void cmptAv FieldField< Field, typename FieldField< Field, Type >::cmptType > &  cf,
const FieldField< Field, Type > &  f
 

tmp<FieldField<Field, Type> > cmptMag const tmp< FieldField< Field, Type > > &  tf  ) 
 

tmp<FieldField<Field, Type> > cmptMag const FieldField< Field, Type > &  f  ) 
 

void cmptMag FieldField< Field, Type > &  cf,
const FieldField< Field, Type > &  f
 

void component FieldField< Field, typename FieldField< Field, Type >::cmptType > &  sf,
const FieldField< Field, Type > &  f,
const direction  d
 

void cross FieldField< Field, typename crossProduct< Form, Type >::type > &  f,
const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const FieldField< Field, Type > &  f1
 

void cross FieldField< Field, typename crossProduct< Type, Form >::type > &  f,
const FieldField< Field, Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

void cross FieldField< Field, typename crossProduct< Type1, Type2 >::type > &  f,
const FieldField< Field, Type1 > &  f1,
const FieldField< Field, Type2 > &  f2
 

void divide FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const scalar &  s
 

void divide FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const FieldField< Field, scalar > &  f2
 

void dot FieldField< Field, typename innerProduct< Form, Type >::type > &  f,
const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const FieldField< Field, Type > &  f1
 

void dot FieldField< Field, typename innerProduct< Type, Form >::type > &  f,
const FieldField< Field, Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

void dot FieldField< Field, typename innerProduct< Type1, Type2 >::type > &  f,
const FieldField< Field, Type1 > &  f1,
const FieldField< Field, Type2 > &  f2
 

void dotdot FieldField< Field, typename scalarProduct< Form, Type >::type > &  f,
const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const FieldField< Field, Type > &  f1
 

void dotdot FieldField< Field, typename scalarProduct< Type, Form >::type > &  f,
const FieldField< Field, Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

void dotdot FieldField< Field, typename scalarProduct< Type1, Type2 >::type > &  f,
const FieldField< Field, Type1 > &  f1,
const FieldField< Field, Type2 > &  f2
 

Type gAverage const tmp< FieldField< Field, Type > > &  tf1  ) 
 

Type gAverage const FieldField< Field, Type > &  f  ) 
 

Type gMax const tmp< FieldField< Field, Type > > &  tf1  ) 
 

Type gMax const FieldField< Field, Type > &  f  ) 
 

Type gMin const tmp< FieldField< Field, Type > > &  tf1  ) 
 

Type gMin const FieldField< Field, Type > &  f  ) 
 

Type gSum const tmp< FieldField< Field, Type > > &  tf1  ) 
 

Type gSum const FieldField< Field, Type > &  f  ) 
 

scalar gSumMag const tmp< FieldField< Field, Type > > &  tf1  ) 
 

scalar gSumMag const FieldField< Field, Type > &  f  ) 
 

tmp<FieldField<Field, scalar> > mag const tmp< FieldField< Field, Type > > &  tf  ) 
 

tmp<FieldField<Field, scalar> > mag const FieldField< Field, Type > &  f  ) 
 

void mag FieldField< Field, scalar > &  sf,
const FieldField< Field, Type > &  f
 

tmp<FieldField<Field, scalar> > magSqr const tmp< FieldField< Field, Type > > &  tf  ) 
 

tmp<FieldField<Field, scalar> > magSqr const FieldField< Field, Type > &  f  ) 
 

void magSqr FieldField< Field, scalar > &  sf,
const FieldField< Field, Type > &  f
 

Type max const tmp< FieldField< Field, Type > > &  tf1  ) 
 

Type max const FieldField< Field, Type > &  f  ) 
 

tmp<FieldField<Field, Type> > max const tmp< FieldField< Field, Type > > &  tf1,
const Type &  s
 

tmp<FieldField<Field, Type> > max const FieldField< Field, Type > &  f1,
const Type &  s
 

void max FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const Type &  s
 

tmp<FieldField<Field, Type> > max const tmp< FieldField< Field, Type > > &  tf1,
const tmp< FieldField< Field, Type > > &  tf2
 

tmp<FieldField<Field, Type> > max const tmp< FieldField< Field, Type > > &  tf1,
const FieldField< Field, Type > &  f2
 

tmp<FieldField<Field, Type> > max const FieldField< Field, Type > &  f1,
const tmp< FieldField< Field, Type > > &  tf2
 

tmp<FieldField<Field, Type> > max const FieldField< Field, Type > &  f1,
const FieldField< Field, Type > &  f2
 

void max FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const FieldField< Field, Type > &  f2
 

Type min const tmp< FieldField< Field, Type > > &  tf1  ) 
 

Type min const FieldField< Field, Type > &  f  ) 
 

tmp<FieldField<Field, Type> > min const tmp< FieldField< Field, Type > > &  tf1,
const Type &  s
 

tmp<FieldField<Field, Type> > min const FieldField< Field, Type > &  f1,
const Type &  s
 

void min FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const Type &  s
 

tmp<FieldField<Field, Type> > min const tmp< FieldField< Field, Type > > &  tf1,
const tmp< FieldField< Field, Type > > &  tf2
 

tmp<FieldField<Field, Type> > min const tmp< FieldField< Field, Type > > &  tf1,
const FieldField< Field, Type > &  f2
 

tmp<FieldField<Field, Type> > min const FieldField< Field, Type > &  f1,
const tmp< FieldField< Field, Type > > &  tf2
 

tmp<FieldField<Field, Type> > min const FieldField< Field, Type > &  f1,
const FieldField< Field, Type > &  f2
 

void min FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const FieldField< Field, Type > &  f2
 

void multiply FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const scalar &  s
 

void multiply FieldField< Field, Type > &  f,
const scalar &  s,
const FieldField< Field, Type > &  f1
 

void negate FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1
 

tmp<FieldField<Field, typename innerProduct <Form, Type>::type> > operator & const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const tmp< FieldField< Field, Type > > &  tf1
 

tmp<FieldField<Field, typename innerProduct <Form, Type>::type> > operator & const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const FieldField< Field, Type > &  f1
 

tmp<FieldField<Field, typename innerProduct <Type, Form>::type> > operator & const tmp< FieldField< Field, Type > > &  tf1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<FieldField<Field, typename innerProduct <Type, Form>::type> > operator & const FieldField< Field, Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<FieldField<Field, typename innerProduct <Type1, Type2>::type> > operator & const tmp< FieldField< Field, Type1 > > &  tf1,
const tmp< FieldField< Field, Type2 > > &  tf2
 

tmp<FieldField<Field, typename innerProduct <Type1, Type2>::type> > operator & const tmp< FieldField< Field, Type1 > > &  tf1,
const FieldField< Field, Type2 > &  f2
 

tmp<FieldField<Field, typename innerProduct <Type1, Type2>::type> > operator & const FieldField< Field, Type1 > &  f1,
const tmp< FieldField< Field, Type2 > > &  tf2
 

tmp<FieldField<Field, typename innerProduct <Type1, Type2>::type> > operator & const FieldField< Field, Type1 > &  f1,
const FieldField< Field, Type2 > &  f2
 

tmp<FieldField<Field, typename scalarProduct <Form, Type>::type> > operator && const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const tmp< FieldField< Field, Type > > &  tf1
 

tmp<FieldField<Field, typename scalarProduct <Form, Type>::type> > operator && const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const FieldField< Field, Type > &  f1
 

tmp<FieldField<Field, typename scalarProduct <Type, Form>::type> > operator && const tmp< FieldField< Field, Type > > &  tf1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<FieldField<Field, typename scalarProduct <Type, Form>::type> > operator && const FieldField< Field, Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<FieldField<Field, typename scalarProduct <Type1, Type2>::type> > operator && const tmp< FieldField< Field, Type1 > > &  tf1,
const tmp< FieldField< Field, Type2 > > &  tf2
 

tmp<FieldField<Field, typename scalarProduct <Type1, Type2>::type> > operator && const tmp< FieldField< Field, Type1 > > &  tf1,
const FieldField< Field, Type2 > &  f2
 

tmp<FieldField<Field, typename scalarProduct <Type1, Type2>::type> > operator && const FieldField< Field, Type1 > &  f1,
const tmp< FieldField< Field, Type2 > > &  tf2
 

tmp<FieldField<Field, typename scalarProduct <Type1, Type2>::type> > operator && const FieldField< Field, Type1 > &  f1,
const FieldField< Field, Type2 > &  f2
 

tmp<FieldField<Field, typename outerProduct <Form, Type>::type> > operator * const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const tmp< FieldField< Field, Type > > &  tf1
 

tmp<FieldField<Field, typename outerProduct <Form, Type>::type> > operator * const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const FieldField< Field, Type > &  f1
 

tmp<FieldField<Field, typename outerProduct <Type, Form>::type> > operator * const tmp< FieldField< Field, Type > > &  tf1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<FieldField<Field, typename outerProduct <Type, Form>::type> > operator * const FieldField< Field, Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<FieldField<Field, typename outerProduct <Type1, Type2>::type> > operator * const tmp< FieldField< Field, Type1 > > &  tf1,
const tmp< FieldField< Field, Type2 > > &  tf2
 

tmp<FieldField<Field, typename outerProduct <Type1, Type2>::type> > operator * const tmp< FieldField< Field, Type1 > > &  tf1,
const FieldField< Field, Type2 > &  f2
 

tmp<FieldField<Field, typename outerProduct <Type1, Type2>::type> > operator * const FieldField< Field, Type1 > &  f1,
const tmp< FieldField< Field, Type2 > > &  tf2
 

tmp<FieldField<Field, typename outerProduct <Type1, Type2>::type> > operator * const FieldField< Field, Type1 > &  f1,
const FieldField< Field, Type2 > &  f2
 

tmp<FieldField<Field, Type> > operator * const tmp< FieldField< Field, Type > > &  tf1,
const scalar &  s
 

tmp<FieldField<Field, Type> > operator * const FieldField< Field, Type > &  f1,
const scalar &  s
 

tmp<FieldField<Field, Type> > operator * const scalar &  s,
const tmp< FieldField< Field, Type > > &  tf1
 

tmp<FieldField<Field, Type> > operator * const scalar &  s,
const FieldField< Field, Type > &  f1
 

tmp<FieldField<Field, Type> > operator+ const tmp< FieldField< Field, Type > > &  tf1,
const Type &  s
 

tmp<FieldField<Field, Type> > operator+ const FieldField< Field, Type > &  f1,
const Type &  s
 

tmp<FieldField<Field, Type> > operator+ const Type &  s,
const tmp< FieldField< Field, Type > > &  tf1
 

tmp<FieldField<Field, Type> > operator+ const Type &  s,
const FieldField< Field, Type > &  f1
 

tmp<FieldField<Field, Type> > operator+ const tmp< FieldField< Field, Type > > &  tf1,
const tmp< FieldField< Field, Type > > &  tf2
 

tmp<FieldField<Field, Type> > operator+ const tmp< FieldField< Field, Type > > &  tf1,
const FieldField< Field, Type > &  f2
 

tmp<FieldField<Field, Type> > operator+ const FieldField< Field, Type > &  f1,
const tmp< FieldField< Field, Type > > &  tf2
 

tmp<FieldField<Field, Type> > operator+ const FieldField< Field, Type > &  f1,
const FieldField< Field, Type > &  f2
 

tmp<FieldField<Field, Type> > operator- const tmp< FieldField< Field, Type > > &  tf1,
const Type &  s
 

tmp<FieldField<Field, Type> > operator- const FieldField< Field, Type > &  f1,
const Type &  s
 

tmp<FieldField<Field, Type> > operator- const Type &  s,
const tmp< FieldField< Field, Type > > &  tf1
 

tmp<FieldField<Field, Type> > operator- const Type &  s,
const FieldField< Field, Type > &  f1
 

tmp<FieldField<Field, Type> > operator- const tmp< FieldField< Field, Type > > &  tf1,
const tmp< FieldField< Field, Type > > &  tf2
 

tmp<FieldField<Field, Type> > operator- const tmp< FieldField< Field, Type > > &  tf1,
const FieldField< Field, Type > &  f2
 

tmp<FieldField<Field, Type> > operator- const FieldField< Field, Type > &  f1,
const tmp< FieldField< Field, Type > > &  tf2
 

tmp<FieldField<Field, Type> > operator- const FieldField< Field, Type > &  f1,
const FieldField< Field, Type > &  f2
 

tmp<FieldField<Field, Type> > operator- const tmp< FieldField< Field, Type > > &  tf1  ) 
 

tmp<FieldField<Field, Type> > operator- const FieldField< Field, Type > &  f1  ) 
 

tmp<FieldField<Field, Type> > operator/ const tmp< FieldField< Field, Type > > &  tf1,
const scalar &  s
 

tmp<FieldField<Field, Type> > operator/ const FieldField< Field, Type > &  f1,
const scalar &  s
 

tmp<FieldField<Field, Type> > operator/ const tmp< FieldField< Field, Type > > &  tf1,
const tmp< FieldField< Field, scalar > > &  tf2
 

tmp<FieldField<Field, Type> > operator/ const tmp< FieldField< Field, Type > > &  tf1,
const FieldField< Field, scalar > &  f2
 

tmp<FieldField<Field, Type> > operator/ const FieldField< Field, Type > &  f1,
const tmp< FieldField< Field, scalar > > &  tf2
 

tmp<FieldField<Field, Type> > operator/ const FieldField< Field, Type > &  f1,
const FieldField< Field, scalar > &  f2
 

tmp<FieldField<Field, typename crossProduct <Form, Type>::type> > operator^ const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const tmp< FieldField< Field, Type > > &  tf1
 

tmp<FieldField<Field, typename crossProduct <Form, Type>::type> > operator^ const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const FieldField< Field, Type > &  f1
 

tmp<FieldField<Field, typename crossProduct <Type, Form>::type> > operator^ const tmp< FieldField< Field, Type > > &  tf1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<FieldField<Field, typename crossProduct <Type, Form>::type> > operator^ const FieldField< Field, Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

tmp<FieldField<Field, typename crossProduct <Type1, Type2>::type> > operator^ const tmp< FieldField< Field, Type1 > > &  tf1,
const tmp< FieldField< Field, Type2 > > &  tf2
 

tmp<FieldField<Field, typename crossProduct <Type1, Type2>::type> > operator^ const tmp< FieldField< Field, Type1 > > &  tf1,
const FieldField< Field, Type2 > &  f2
 

tmp<FieldField<Field, typename crossProduct <Type1, Type2>::type> > operator^ const FieldField< Field, Type1 > &  f1,
const tmp< FieldField< Field, Type2 > > &  tf2
 

tmp<FieldField<Field, typename crossProduct <Type1, Type2>::type> > operator^ const FieldField< Field, Type1 > &  f1,
const FieldField< Field, Type2 > &  f2
 

void outer FieldField< Field, typename outerProduct< Form, Type >::type > &  f,
const VectorSpace< Form, Cmpt, nCmpt > &  vs,
const FieldField< Field, Type > &  f1
 

void outer FieldField< Field, typename outerProduct< Type, Form >::type > &  f,
const FieldField< Field, Type > &  f1,
const VectorSpace< Form, Cmpt, nCmpt > &  vs
 

void outer FieldField< Field, typename outerProduct< Type1, Type2 >::type > &  f,
const FieldField< Field, Type1 > &  f1,
const FieldField< Field, Type2 > &  f2
 

tmp<FieldField<Field, typename powProduct<Type, r>::type> > pow const tmp< FieldField< Field, Type > > &  tf,
typename powProduct< Type, r >::type  = pTraits< typename powProduct< Type, r >::type >::zero
 

tmp<FieldField<Field, typename powProduct<Type, r>::type> > pow const FieldField< Field, Type > &  f,
typename powProduct< Type, r >::type  = pTraits< typename powProduct< Type, r >::type >::zero
 

void pow FieldField< Field, typename powProduct< Type, r >::type > &  f,
const FieldField< Field, Type > &  vf
 

tmp<FieldField<Field, Type> > scale const tmp< FieldField< Field, Type > > &  tf1,
const Type &  s
 

tmp<FieldField<Field, Type> > scale const FieldField< Field, Type > &  f1,
const Type &  s
 

void scale FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const Type &  s
 

tmp<FieldField<Field, Type> > scale const tmp< FieldField< Field, Type > > &  tf1,
const tmp< FieldField< Field, Type > > &  tf2
 

tmp<FieldField<Field, Type> > scale const tmp< FieldField< Field, Type > > &  tf1,
const FieldField< Field, Type > &  f2
 

tmp<FieldField<Field, Type> > scale const FieldField< Field, Type > &  f1,
const tmp< FieldField< Field, Type > > &  tf2
 

tmp<FieldField<Field, Type> > scale const FieldField< Field, Type > &  f1,
const FieldField< Field, Type > &  f2
 

void scale FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const FieldField< Field, Type > &  f2
 

tmp<FieldField<Field, typename outerProduct<Type, Type>::type> > sqr const tmp< FieldField< Field, Type > > &  tf  ) 
 

tmp<FieldField<Field, typename outerProduct<Type, Type>::type> > sqr const FieldField< Field, Type > &  f  ) 
 

void sqr FieldField< Field, typename outerProduct< Type, Type >::type > &  f,
const FieldField< Field, Type > &  vf
 

void subtract FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const Type &  s
 

void subtract FieldField< Field, Type > &  f,
const Type &  s,
const FieldField< Field, Type > &  f1
 

void subtract FieldField< Field, Type > &  f,
const FieldField< Field, Type > &  f1,
const FieldField< Field, Type > &  f2
 

Type sum const tmp< FieldField< Field, Type > > &  tf1  ) 
 

Type sum const FieldField< Field, Type > &  f  ) 
 

scalar sumMag const tmp< FieldField< Field, Type > > &  tf1  ) 
 

scalar sumMag const FieldField< Field, Type > &  f  ) 
 

void T FieldField< Field, Type > &  f1,
const FieldField< Field, Type > &  f2
 

Referenced by specieThermo::A(), specieThermo::a(), LList< SLListBase, word >::append(), N2::B(), MB::B(), IDEA::B(), IC8H18::B(), H2O::B(), CH3OH::B(), C9H20::B(), C8H18::B(), C8H10::B(), C7H8::B(), C7H16::B(), C6H6::B(), C6H14::B(), C4H10O::B(), C3H8::B(), C3H6O::B(), C2H6O::B(), C2H6::B(), C2H5OH::B(), C16H34::B(), C14H30::B(), C13H28::B(), C12H26::B(), C10H22::B(), bC10H7CH3::B(), Ar::B(), aC10H7CH3::B(), tmp::clear(), autoPtr::clear(), List::clone(), Foam::component(), specieThermo::Cp(), janafThermo::cp(), hConstThermo::cp(), eConstThermo::cp(), N2::cp(), MB::cp(), IDEA::cp(), IC8H18::cp(), H2O::cp(), CH3OH::cp(), C9H20::cp(), C8H18::cp(), C8H10::cp(), C7H8::cp(), C7H16::cp(), C6H6::cp(), C6H14::cp(), C4H10O::cp(), C3H8::cp(), C3H6O::cp(), C2H6O::cp(), C2H6::cp(), C2H5OH::cp(), C16H34::cp(), C14H30::cp(), C13H28::cp(), C12H26::cp(), C10H22::cp(), bC10H7CH3::cp(), Ar::cp(), aC10H7CH3::cp(), N2::cpg(), MB::cpg(), IDEA::cpg(), IC8H18::cpg(), H2O::cpg(), CH3OH::cpg(), C9H20::cpg(), C8H18::cpg(), C8H10::cpg(), C7H8::cpg(), C7H16::cpg(), C6H6::cpg(), C6H14::cpg(), C4H10O::cpg(), C3H8::cpg(), C3H6O::cpg(), C2H6O::cpg(), C2H6::cpg(), C2H5OH::cpg(), C16H34::cpg(), C14H30::cpg(), C13H28::cpg(), C12H26::cpg(), C10H22::cpg(), bC10H7CH3::cpg(), Ar::cpg(), aC10H7CH3::cpg(), specieThermo::Cv(), specieThermo::cv(), DLList< T * >::DLList(), DLPtrList::DLPtrList(), specieThermo::E(), specieThermo::e(), diagonalEdge::faceIndex0(), FIFOStack< word >::FIFOStack(), specieThermo::G(), specieThermo::g(), specieThermo::gamma(), specieThermo::H(), janafThermo::h(), N2::h(), MB::h(), IDEA::h(), IC8H18::h(), H2O::h(), CH3OH::h(), C9H20::h(), C8H18::h(), C8H10::h(), C7H8::h(), C7H16::h(), C6H6::h(), C6H14::h(), C4H10O::h(), C3H8::h(), C3H6O::h(), C2H6O::h(), C2H6::h(), C2H5OH::h(), C16H34::h(), C14H30::h(), C13H28::h(), C12H26::h(), C10H22::h(), bC10H7CH3::h(), Ar::h(), aC10H7CH3::h(), N2::hl(), MB::hl(), IDEA::hl(), IC8H18::hl(), H2O::hl(), CH3OH::hl(), C9H20::hl(), C8H18::hl(), C8H10::hl(), C7H8::hl(), C7H16::hl(), C6H6::hl(), C6H14::hl(), C4H10O::hl(), C3H8::hl(), C3H6O::hl(), C2H6O::hl(), C2H6::hl(), C2H5OH::hl(), C16H34::hl(), C14H30::hl(), C13H28::hl(), C12H26::hl(), C10H22::hl(), bC10H7CH3::hl(), Ar::hl(), aC10H7CH3::hl(), PtrList::hook(), IDLList< particleType >::IDLList(), ILList< DLListBase, entry >::ILList(), ISLList::ISLList(), N2::K(), MB::K(), IDEA::K(), IC8H18::K(), H2O::K(), CH3OH::K(), C9H20::K(), C8H18::K(), C8H10::K(), C7H8::K(), C7H16::K(), C6H6::K(), C6H14::K(), C4H10O::K(), C3H8::K(), C3H6O::K(), C2H6O::K(), C2H6::K(), C2H5OH::K(), C16H34::K(), C14H30::K(), C13H28::K(), C12H26::K(), C10H22::K(), bC10H7CH3::K(), Ar::K(), aC10H7CH3::K(), sutherlandTransport::kappa(), constTransport::kappa(), specieThermo::Kc(), N2::Kg(), MB::Kg(), IDEA::Kg(), IC8H18::Kg(), H2O::Kg(), CH3OH::Kg(), C9H20::Kg(), C8H18::Kg(), C8H10::Kg(), C7H8::Kg(), C7H16::Kg(), C6H6::Kg(), C6H14::Kg(), C4H10O::Kg(), C3H8::Kg(), C3H6O::Kg(), C2H6O::Kg(), C2H6::Kg(), C2H5OH::Kg(), C16H34::Kg(), C14H30::Kg(), C13H28::Kg(), C12H26::Kg(), C10H22::Kg(), bC10H7CH3::Kg(), Ar::Kg(), aC10H7CH3::Kg(), specieThermo::Kn(), specieThermo::Kp(), specieThermo::Kx(), UILList< DLListBase, entry >::last(), LPtrList< SLListBase, reaction >::last(), LIFOStack::LIFOStack(), LList< SLListBase, word >::LList(), LPtrList< SLListBase, reaction >::LPtrList(), Map< labelList >::Map(), Pstream::msgType(), sutherlandTransport::mu(), constTransport::mu(), N2::mu(), MB::mu(), IDEA::mu(), IC8H18::mu(), H2O::mu(), CH3OH::mu(), C9H20::mu(), C8H18::mu(), C8H10::mu(), C7H8::mu(), C7H16::mu(), C6H6::mu(), C6H14::mu(), C4H10O::mu(), C3H8::mu(), C3H6O::mu(), C2H6O::mu(), C2H6::mu(), C2H5OH::mu(), C16H34::mu(), C14H30::mu(), C13H28::mu(), C12H26::mu(), C10H22::mu(), bC10H7CH3::mu(), Ar::mu(), aC10H7CH3::mu(), N2::mug(), MB::mug(), IDEA::mug(), IC8H18::mug(), H2O::mug(), CH3OH::mug(), C9H20::mug(), C8H18::mug(), C8H10::mug(), C7H8::mug(), C7H16::mug(), C6H6::mug(), C6H14::mug(), C4H10O::mug(), C3H8::mug(), C3H6O::mug(), C2H6O::mug(), C2H6::mug(), C2H5OH::mug(), C16H34::mug(), C14H30::mug(), C13H28::mug(), C12H26::mug(), C10H22::mug(), bC10H7CH3::mug(), Ar::mug(), aC10H7CH3::mug(), PtrList< faPatch >::nextFree(), LPtrList::const_iterator::operator *(), tmp::operator const T &(), autoPtr::operator const T &(), powerSeriesReactionRate::operator()(), LangmuirHinshelwoodReactionRate::operator()(), LandauTellerReactionRate::operator()(), JanevReactionRate::operator()(), ArrheniusReactionRate::operator()(), accessOp::operator()(), LList::const_iterator::operator()(), Foam::operator-(), Foam::operator<<(), Foam::operator>>(), PtrMap::PtrMap(), N2::pv(), MB::pv(), IDEA::pv(), IC8H18::pv(), H2O::pv(), CH3OH::pv(), C9H20::pv(), C8H18::pv(), C8H10::pv(), C7H8::pv(), C7H16::pv(), C6H6::pv(), C6H14::pv(), C4H10O::pv(), C3H8::pv(), C3H6O::pv(), C2H6O::pv(), C2H6::pv(), C2H5OH::pv(), C16H34::pv(), C14H30::pv(), C13H28::pv(), C12H26::pv(), C10H22::pv(), bC10H7CH3::pv(), Ar::pv(), aC10H7CH3::pv(), UILList< DLListBase, entry >::remove(), LList< SLListBase, word >::removeHead(), N2::rho(), MB::rho(), IDEA::rho(), IC8H18::rho(), H2O::rho(), CH3OH::rho(), C9H20::rho(), C8H18::rho(), C8H10::rho(), C7H8::rho(), C7H16::rho(), C6H6::rho(), C6H14::rho(), C4H10O::rho(), C3H8::rho(), C3H6O::rho(), C2H6O::rho(), C2H6::rho(), C2H5OH::rho(), C16H34::rho(), C14H30::rho(), C13H28::rho(), C12H26::rho(), C10H22::rho(), bC10H7CH3::rho(), Ar::rho(), aC10H7CH3::rho(), specieThermo::S(), janafThermo::s(), DynamicList::shrink(), N2::sigma(), MB::sigma(), IDEA::sigma(), IC8H18::sigma(), H2O::sigma(), CH3OH::sigma(), C9H20::sigma(), C8H18::sigma(), C8H10::sigma(), C7H8::sigma(), C7H16::sigma(), C6H6::sigma(), C6H14::sigma(), C4H10O::sigma(), C3H8::sigma(), C3H6O::sigma(), C2H6O::sigma(), C2H6::sigma(), C2H5OH::sigma(), C16H34::sigma(), C14H30::sigma(), C13H28::sigma(), C12H26::sigma(), C10H22::sigma(), bC10H7CH3::sigma(), Ar::sigma(), aC10H7CH3::sigma(), StaticHashTable::size(), HashTable::size(), SLList< word >::SLList(), SLPtrList< reaction >::SLPtrList(), simpleMatrix::source(), specieThermo::specieThermo(), Pstream::treeCommunication(), UIDLList::UIDLList(), UILList< DLListBase, entry >::UILList(), tmp::valid(), and autoPtr::valid().

For further information go to www.openfoam.org