Namespaces | Macros | Functions
FieldM.H File Reference

High performance macro functions for Field<Type> algebra. These expand using either array element access (for vector machines) or pointer dereferencing for scalar machines as appropriate. More...

Include dependency graph for FieldM.H:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces

 Foam
 Namespace for OpenFOAM.
 

Macros

#define TFOR_ALL_F_OP_FUNC_F(typeF1, f1, OP, FUNC, typeF2, f2)
 
#define TFOR_ALL_F_OP_F_FUNC(typeF1, f1, OP, typeF2, f2, FUNC)
 
#define TFOR_ALL_F_OP_FUNC_F_F(typeF1, f1, OP, FUNC, typeF2, f2, typeF3, f3)
 
#define TFOR_ALL_S_OP_FUNC_F_F(typeS, s, OP, FUNC, typeF1, f1, typeF2, f2)
 
#define TFOR_ALL_F_OP_FUNC_F_S(typeF1, f1, OP, FUNC, typeF2, f2, typeS, s)
 
#define TFOR_ALL_S_OP_FUNC_F_S(typeS1, s1, OP, FUNC, typeF, f, typeS2, s2)
 
#define TFOR_ALL_F_OP_FUNC_S_F(typeF1, f1, OP, FUNC, typeS, s, typeF2, f2)
 
#define TFOR_ALL_F_OP_FUNC_S_S(typeF1, f1, OP, FUNC, typeS1, s1, typeS2, s2)
 
#define TFOR_ALL_F_OP_F_FUNC_S(typeF1, f1, OP, typeF2, f2, FUNC, typeS, s)
 
#define TFOR_ALL_F_OP_F_OP_F(typeF1, f1, OP1, typeF2, f2, OP2, typeF3, f3)
 
#define TFOR_ALL_F_OP_S_OP_F(typeF1, f1, OP1, typeS, s, OP2, typeF2, f2)
 
#define TFOR_ALL_F_OP_F_OP_S(typeF1, f1, OP1, typeF2, f2, OP2, typeS, s)
 
#define TFOR_ALL_F_OP_F(typeF1, f1, OP, typeF2, f2)
 
#define TFOR_ALL_F_OP_OP_F(typeF1, f1, OP1, OP2, typeF2, f2)
 
#define TFOR_ALL_F_OP_S(typeF, f, OP, typeS, s)
 
#define TFOR_ALL_S_OP_F(typeS, s, OP, typeF, f)
 
#define TFOR_ALL_S_OP_F_OP_F(typeS, s, OP1, typeF1, f1, OP2, typeF2, f2)
 
#define TFOR_ALL_S_OP_FUNC_F(typeS, s, OP, FUNC, typeF, f)
 

Functions

template<class Type1 , class Type2 >
void checkFields (const UList< Type1 > &, const UList< Type2 > &, const char *)
 
template<class Type1 , class Type2 , class Type3 >
void checkFields (const UList< Type1 > &, const UList< Type2 > &, const UList< Type3 > &, const char *)
 

Detailed Description

High performance macro functions for Field<Type> algebra. These expand using either array element access (for vector machines) or pointer dereferencing for scalar machines as appropriate.

Original source file FieldM.H

Definition in file FieldM.H.

Macro Definition Documentation

◆ TFOR_ALL_F_OP_FUNC_F

#define TFOR_ALL_F_OP_FUNC_F (   typeF1,
  f1,
  OP,
  FUNC,
  typeF2,
  f2 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, "f1 " #OP " " #FUNC "(f2)"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
\
/* Loop: f1 OP FUNC(f2) */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP FUNC(f2P[i]); \
}

Definition at line 116 of file FieldM.H.

◆ TFOR_ALL_F_OP_F_FUNC

#define TFOR_ALL_F_OP_F_FUNC (   typeF1,
  f1,
  OP,
  typeF2,
  f2,
  FUNC 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, "f1 " #OP " f2" #FUNC); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
\
/* Loop: f1 OP f2.FUNC() */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP (f2P[i]).FUNC(); \
}

Definition at line 132 of file FieldM.H.

◆ TFOR_ALL_F_OP_FUNC_F_F

#define TFOR_ALL_F_OP_FUNC_F_F (   typeF1,
  f1,
  OP,
  FUNC,
  typeF2,
  f2,
  typeF3,
  f3 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, f3, "f1 " #OP " " #FUNC "(f2, f3)"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
List_CONST_ACCESS(typeF3, f3, f3P); \
\
/* Loop: f1 OP FUNC(f2, f3) */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP FUNC((f2P[i]), (f3P[i])); \
}

Definition at line 150 of file FieldM.H.

◆ TFOR_ALL_S_OP_FUNC_F_F

#define TFOR_ALL_S_OP_FUNC_F_F (   typeS,
  s,
  OP,
  FUNC,
  typeF1,
  f1,
  typeF2,
  f2 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, "s " #OP " " #FUNC "(f1, f2)"); \
\
/* Field access */ \
List_CONST_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
\
/* Loop: s OP FUNC(f1, f2) */ \
List_FOR_ALL(f1, i) \
{ \
(s) OP FUNC((f1P[i]), (f2P[i])); \
}

Definition at line 169 of file FieldM.H.

◆ TFOR_ALL_F_OP_FUNC_F_S

#define TFOR_ALL_F_OP_FUNC_F_S (   typeF1,
  f1,
  OP,
  FUNC,
  typeF2,
  f2,
  typeS,
  s 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, "f1 " #OP " " #FUNC "(f2, s)"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
\
/* Loop: f1 OP FUNC(f2, s) */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP FUNC((f2P[i]), (s)); \
}

Definition at line 187 of file FieldM.H.

◆ TFOR_ALL_S_OP_FUNC_F_S

#define TFOR_ALL_S_OP_FUNC_F_S (   typeS1,
  s1,
  OP,
  FUNC,
  typeF,
  f,
  typeS2,
  s2 
)
Value:
\
/* Field access */ \
List_CONST_ACCESS(typeF, f, fP); \
\
/* Loop: s1 OP FUNC(f, s2) */ \
List_FOR_ALL(f, i) \
{ \
(s1) OP FUNC((fP[i]), (s2)); \
}

Definition at line 205 of file FieldM.H.

◆ TFOR_ALL_F_OP_FUNC_S_F

#define TFOR_ALL_F_OP_FUNC_S_F (   typeF1,
  f1,
  OP,
  FUNC,
  typeS,
  s,
  typeF2,
  f2 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, "f1 " #OP " " #FUNC "(s, f2)"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
\
/* Loop: f1 OP1 f2 OP2 f3 */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP FUNC((s), (f2P[i])); \
}

Definition at line 219 of file FieldM.H.

◆ TFOR_ALL_F_OP_FUNC_S_S

#define TFOR_ALL_F_OP_FUNC_S_S (   typeF1,
  f1,
  OP,
  FUNC,
  typeS1,
  s1,
  typeS2,
  s2 
)
Value:
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
\
/* Loop: f1 OP FUNC(s1, s2) */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP FUNC((s1), (s2)); \
}

Definition at line 237 of file FieldM.H.

◆ TFOR_ALL_F_OP_F_FUNC_S

#define TFOR_ALL_F_OP_F_FUNC_S (   typeF1,
  f1,
  OP,
  typeF2,
  f2,
  FUNC,
  typeS,
  s 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, "f1 " #OP " f2 " #FUNC "(s)"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
\
/* Loop: f1 OP f2 FUNC(s) */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP (f2P[i]) FUNC((s)); \
}

Definition at line 251 of file FieldM.H.

◆ TFOR_ALL_F_OP_F_OP_F

#define TFOR_ALL_F_OP_F_OP_F (   typeF1,
  f1,
  OP1,
  typeF2,
  f2,
  OP2,
  typeF3,
  f3 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, f3, "f1 " #OP1 " f2 " #OP2 " f3"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
List_CONST_ACCESS(typeF3, f3, f3P); \
\
/* Loop: f1 OP1 f2 OP2 f3 */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP1 (f2P[i]) OP2 (f3P[i]); \
}

Definition at line 269 of file FieldM.H.

◆ TFOR_ALL_F_OP_S_OP_F

#define TFOR_ALL_F_OP_S_OP_F (   typeF1,
  f1,
  OP1,
  typeS,
  s,
  OP2,
  typeF2,
  f2 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, "f1 " #OP1 " s " #OP2 " f2"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
\
/* Loop: f1 OP1 s OP2 f2 */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP1 (s) OP2 (f2P[i]); \
}

Definition at line 288 of file FieldM.H.

◆ TFOR_ALL_F_OP_F_OP_S

#define TFOR_ALL_F_OP_F_OP_S (   typeF1,
  f1,
  OP1,
  typeF2,
  f2,
  OP2,
  typeS,
  s 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, "f1 " #OP1 " f2 " #OP2 " s"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
\
/* Loop f1 OP1 s OP2 f2 */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP1 (f2P[i]) OP2 (s); \
}

Definition at line 306 of file FieldM.H.

◆ TFOR_ALL_F_OP_F

#define TFOR_ALL_F_OP_F (   typeF1,
  f1,
  OP,
  typeF2,
  f2 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, "f1 " #OP " f2"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
\
/* Loop: f1 OP f2 */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP (f2P[i]); \
}

Definition at line 324 of file FieldM.H.

◆ TFOR_ALL_F_OP_OP_F

#define TFOR_ALL_F_OP_OP_F (   typeF1,
  f1,
  OP1,
  OP2,
  typeF2,
  f2 
)
Value:
\
/* Check fields have same size */ \
checkFields(f1, f2, #OP1 " " #OP2 " f2"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
\
/* Loop: f1 OP1 OP2 f2 */ \
List_FOR_ALL(f1, i) \
{ \
(f1P[i]) OP1 OP2 (f2P[i]); \
}

Definition at line 341 of file FieldM.H.

◆ TFOR_ALL_F_OP_S

#define TFOR_ALL_F_OP_S (   typeF,
  f,
  OP,
  typeS,
  s 
)
Value:
\
/* Field access */ \
List_ACCESS(typeF, f, fP); \
\
/* Loop: f OP s */ \
List_FOR_ALL(f, i) \
{ \
(fP[i]) OP (s); \
}

Definition at line 359 of file FieldM.H.

◆ TFOR_ALL_S_OP_F

#define TFOR_ALL_S_OP_F (   typeS,
  s,
  OP,
  typeF,
  f 
)
Value:
\
/* Field access */ \
List_CONST_ACCESS(typeF, f, fP); \
\
/* Loop: s OP f */ \
List_FOR_ALL(f, i) \
{ \
(s) OP (fP[i]); \
}

Definition at line 375 of file FieldM.H.

◆ TFOR_ALL_S_OP_F_OP_F

#define TFOR_ALL_S_OP_F_OP_F (   typeS,
  s,
  OP1,
  typeF1,
  f1,
  OP2,
  typeF2,
  f2 
)
Value:
\
/* Field access */ \
List_CONST_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
\
/* Loop: s OP f */ \
List_FOR_ALL(f1, i) \
{ \
(s) OP1 (f1P[i]) OP2 (f2P[i]); \
}

Definition at line 389 of file FieldM.H.

◆ TFOR_ALL_S_OP_FUNC_F

#define TFOR_ALL_S_OP_FUNC_F (   typeS,
  s,
  OP,
  FUNC,
  typeF,
  f 
)
Value:
\
/* Field access */ \
List_CONST_ACCESS(typeF, f, fP); \
\
/* Loop: s OP FUNC(f) */ \
List_FOR_ALL(f, i) \
{ \
(s) OP FUNC(fP[i]); \
}

Definition at line 404 of file FieldM.H.

s
gmvFile<< "tracers "<< particles.size()<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().x()<< " ";}gmvFile<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().y()<< " ";}gmvFile<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().z()<< " ";}gmvFile<< nl;forAll(lagrangianScalarNames, i){ word name=lagrangianScalarNames[i];IOField< scalar > s(IOobject(name, runTime.timeName(), cloud::prefix, mesh, IOobject::MUST_READ, IOobject::NO_WRITE))
Definition: gmvOutputSpray.H:25
f
labelList f(nPoints)