FieldM.H
Go to the documentation of this file.
1/*---------------------------------------------------------------------------*\
2 ========= |
3 \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4 \\ / O peration |
5 \\ / A nd | www.openfoam.com
6 \\/ M anipulation |
7-------------------------------------------------------------------------------
8 Copyright (C) 2011-2016 OpenFOAM Foundation
9-------------------------------------------------------------------------------
10License
11 This file is part of OpenFOAM.
12
13 OpenFOAM is free software: you can redistribute it and/or modify it
14 under the terms of the GNU General Public License as published by
15 the Free Software Foundation, either version 3 of the License, or
16 (at your option) any later version.
17
18 OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
19 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
20 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
25
26Description
27 High performance macro functions for Field<Type> algebra. These expand
28 using either array element access (for vector machines) or pointer
29 dereferencing for scalar machines as appropriate.
30
31\*---------------------------------------------------------------------------*/
32
33#ifndef FieldM_H
34#define FieldM_H
35
36#include "error.H"
37#include "ListLoopM.H"
38
39// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
40
41namespace Foam
42{
43
44// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
45
46#ifdef FULLDEBUG
47
48template<class Type1, class Type2>
49void checkFields
50(
51 const UList<Type1>& f1,
52 const UList<Type2>& f2,
53 const char* op
54)
55{
56 if (f1.size() != f2.size())
57 {
58 FatalErrorInFunction
59 << " Field<"<<pTraits<Type1>::typeName<<"> f1("<<f1.size()<<')'
60 << " and Field<"<<pTraits<Type2>::typeName<<"> f2("<<f2.size()<<')'
61 << endl
62 << " for operation " << op
63 << abort(FatalError);
64 }
65}
66
67template<class Type1, class Type2, class Type3>
68void checkFields
69(
70 const UList<Type1>& f1,
71 const UList<Type2>& f2,
72 const UList<Type3>& f3,
73 const char* op
74)
75{
76 if (f1.size() != f2.size() || f1.size() != f3.size())
77 {
78 FatalErrorInFunction
79 << " Field<"<<pTraits<Type1>::typeName<<"> f1("<<f1.size()<<')'
80 << ", Field<"<<pTraits<Type2>::typeName<<"> f2("<<f2.size()<<')'
81 << " and Field<"<<pTraits<Type3>::typeName<<"> f3("<<f3.size()<<')'
82 << endl
83 << " for operation " << op
84 << abort(FatalError);
85 }
86}
87
88#else
89
90template<class Type1, class Type2>
91void checkFields
92(
93 const UList<Type1>&,
94 const UList<Type2>&,
95 const char*
96)
97{}
98
99template<class Type1, class Type2, class Type3>
100void checkFields
101(
102 const UList<Type1>&,
103 const UList<Type2>&,
104 const UList<Type3>&,
105 const char*
106)
107{}
108
109#endif
110
111
112// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
113
114// Member function : f1 OP Func f2
115
116#define TFOR_ALL_F_OP_FUNC_F(typeF1, f1, OP, FUNC, typeF2, f2) \
117 \
118 /* Check fields have same size */ \
119 checkFields(f1, f2, "f1 " #OP " " #FUNC "(f2)"); \
120 \
121 /* Field access */ \
122 List_ACCESS(typeF1, f1, f1P); \
123 List_CONST_ACCESS(typeF2, f2, f2P); \
124 \
125 /* Loop: f1 OP FUNC(f2) */ \
126 List_FOR_ALL(f1, i) \
127 { \
128 (f1P[i]) OP FUNC(f2P[i]); \
129 }
130
131
132#define TFOR_ALL_F_OP_F_FUNC(typeF1, f1, OP, typeF2, f2, FUNC) \
133 \
134 /* Check fields have same size */ \
135 checkFields(f1, f2, "f1 " #OP " f2" #FUNC); \
136 \
137 /* Field access */ \
138 List_ACCESS(typeF1, f1, f1P); \
139 List_CONST_ACCESS(typeF2, f2, f2P); \
140 \
141 /* Loop: f1 OP f2.FUNC() */ \
142 List_FOR_ALL(f1, i) \
143 { \
144 (f1P[i]) OP (f2P[i]).FUNC(); \
145 }
146
147
148// Member function : this field f1 OP FUNC(f2, f3)
149
150#define TFOR_ALL_F_OP_FUNC_F_F(typeF1, f1, OP, FUNC, typeF2, f2, typeF3, f3) \
151 \
152 /* Check fields have same size */ \
153 checkFields(f1, f2, f3, "f1 " #OP " " #FUNC "(f2, f3)"); \
154 \
155 /* Field access */ \
156 List_ACCESS(typeF1, f1, f1P); \
157 List_CONST_ACCESS(typeF2, f2, f2P); \
158 List_CONST_ACCESS(typeF3, f3, f3P); \
159 \
160 /* Loop: f1 OP FUNC(f2, f3) */ \
161 List_FOR_ALL(f1, i) \
162 { \
163 (f1P[i]) OP FUNC((f2P[i]), (f3P[i])); \
164 }
165
166
167// Member function : s OP FUNC(f1, f2)
168
169#define TFOR_ALL_S_OP_FUNC_F_F(typeS, s, OP, FUNC, typeF1, f1, typeF2, f2) \
170 \
171 /* Check fields have same size */ \
172 checkFields(f1, f2, "s " #OP " " #FUNC "(f1, f2)"); \
173 \
174 /* Field access */ \
175 List_CONST_ACCESS(typeF1, f1, f1P); \
176 List_CONST_ACCESS(typeF2, f2, f2P); \
177 \
178 /* Loop: s OP FUNC(f1, f2) */ \
179 List_FOR_ALL(f1, i) \
180 { \
181 (s) OP FUNC((f1P[i]), (f2P[i])); \
182 }
183
184
185// Member function : this f1 OP FUNC(f2, s)
186
187#define TFOR_ALL_F_OP_FUNC_F_S(typeF1, f1, OP, FUNC, typeF2, f2, typeS, s) \
188 \
189 /* Check fields have same size */ \
190 checkFields(f1, f2, "f1 " #OP " " #FUNC "(f2, s)"); \
191 \
192 /* Field access */ \
193 List_ACCESS(typeF1, f1, f1P); \
194 List_CONST_ACCESS(typeF2, f2, f2P); \
195 \
196 /* Loop: f1 OP FUNC(f2, s) */ \
197 List_FOR_ALL(f1, i) \
198 { \
199 (f1P[i]) OP FUNC((f2P[i]), (s)); \
200 }
201
202
203// Member function : s1 OP FUNC(f, s2)
204
205#define TFOR_ALL_S_OP_FUNC_F_S(typeS1, s1, OP, FUNC, typeF, f, typeS2, s2) \
206 \
207 /* Field access */ \
208 List_CONST_ACCESS(typeF, f, fP); \
209 \
210 /* Loop: s1 OP FUNC(f, s2) */ \
211 List_FOR_ALL(f, i) \
212 { \
213 (s1) OP FUNC((fP[i]), (s2)); \
214 }
215
216
217// Member function : this f1 OP FUNC(s, f2)
218
219#define TFOR_ALL_F_OP_FUNC_S_F(typeF1, f1, OP, FUNC, typeS, s, typeF2, f2) \
220 \
221 /* Check fields have same size */ \
222 checkFields(f1, f2, "f1 " #OP " " #FUNC "(s, f2)"); \
223 \
224 /* Field access */ \
225 List_ACCESS(typeF1, f1, f1P); \
226 List_CONST_ACCESS(typeF2, f2, f2P); \
227 \
228 /* Loop: f1 OP1 f2 OP2 f3 */ \
229 List_FOR_ALL(f1, i) \
230 { \
231 (f1P[i]) OP FUNC((s), (f2P[i])); \
232 }
233
234
235// Member function : this f1 OP FUNC(s1, s2)
236
237#define TFOR_ALL_F_OP_FUNC_S_S(typeF1, f1, OP, FUNC, typeS1, s1, typeS2, s2) \
238 \
239 /* Field access */ \
240 List_ACCESS(typeF1, f1, f1P); \
241 \
242 /* Loop: f1 OP FUNC(s1, s2) */ \
243 List_FOR_ALL(f1, i) \
244 { \
245 (f1P[i]) OP FUNC((s1), (s2)); \
246 }
247
248
249// Member function : this f1 OP f2 FUNC(s)
250
251#define TFOR_ALL_F_OP_F_FUNC_S(typeF1, f1, OP, typeF2, f2, FUNC, typeS, s) \
252 \
253 /* Check fields have same size */ \
254 checkFields(f1, f2, "f1 " #OP " f2 " #FUNC "(s)"); \
255 \
256 /* Field access */ \
257 List_ACCESS(typeF1, f1, f1P); \
258 List_CONST_ACCESS(typeF2, f2, f2P); \
259 \
260 /* Loop: f1 OP f2 FUNC(s) */ \
261 List_FOR_ALL(f1, i) \
262 { \
263 (f1P[i]) OP (f2P[i]) FUNC((s)); \
264 }
265
266
267// Member operator : this field f1 OP1 f2 OP2 f3
268
269#define TFOR_ALL_F_OP_F_OP_F(typeF1, f1, OP1, typeF2, f2, OP2, typeF3, f3) \
270 \
271 /* Check fields have same size */ \
272 checkFields(f1, f2, f3, "f1 " #OP1 " f2 " #OP2 " f3"); \
273 \
274 /* Field access */ \
275 List_ACCESS(typeF1, f1, f1P); \
276 List_CONST_ACCESS(typeF2, f2, f2P); \
277 List_CONST_ACCESS(typeF3, f3, f3P); \
278 \
279 /* Loop: f1 OP1 f2 OP2 f3 */ \
280 List_FOR_ALL(f1, i) \
281 { \
282 (f1P[i]) OP1 (f2P[i]) OP2 (f3P[i]); \
283 }
284
285
286// Member operator : this field f1 OP1 s OP2 f2
287
288#define TFOR_ALL_F_OP_S_OP_F(typeF1, f1, OP1, typeS, s, OP2, typeF2, f2) \
289 \
290 /* Check fields have same size */ \
291 checkFields(f1, f2, "f1 " #OP1 " s " #OP2 " f2"); \
292 \
293 /* Field access */ \
294 List_ACCESS(typeF1, f1, f1P); \
295 List_CONST_ACCESS(typeF2, f2, f2P); \
296 \
297 /* Loop: f1 OP1 s OP2 f2 */ \
298 List_FOR_ALL(f1, i) \
299 { \
300 (f1P[i]) OP1 (s) OP2 (f2P[i]); \
301 }
302
303
304// Member operator : this field f1 OP1 f2 OP2 s
305
306#define TFOR_ALL_F_OP_F_OP_S(typeF1, f1, OP1, typeF2, f2, OP2, typeS, s) \
307 \
308 /* Check fields have same size */ \
309 checkFields(f1, f2, "f1 " #OP1 " f2 " #OP2 " s"); \
310 \
311 /* Field access */ \
312 List_ACCESS(typeF1, f1, f1P); \
313 List_CONST_ACCESS(typeF2, f2, f2P); \
314 \
315 /* Loop f1 OP1 s OP2 f2 */ \
316 List_FOR_ALL(f1, i) \
317 { \
318 (f1P[i]) OP1 (f2P[i]) OP2 (s); \
319 }
320
321
322// Member operator : this field f1 OP f2
323
324#define TFOR_ALL_F_OP_F(typeF1, f1, OP, typeF2, f2) \
325 \
326 /* Check fields have same size */ \
327 checkFields(f1, f2, "f1 " #OP " f2"); \
328 \
329 /* Field access */ \
330 List_ACCESS(typeF1, f1, f1P); \
331 List_CONST_ACCESS(typeF2, f2, f2P); \
332 \
333 /* Loop: f1 OP f2 */ \
334 List_FOR_ALL(f1, i) \
335 { \
336 (f1P[i]) OP (f2P[i]); \
337 }
338
339// Member operator : this field f1 OP1 OP2 f2
340
341#define TFOR_ALL_F_OP_OP_F(typeF1, f1, OP1, OP2, typeF2, f2) \
342 \
343 /* Check fields have same size */ \
344 checkFields(f1, f2, #OP1 " " #OP2 " f2"); \
345 \
346 /* Field access */ \
347 List_ACCESS(typeF1, f1, f1P); \
348 List_CONST_ACCESS(typeF2, f2, f2P); \
349 \
350 /* Loop: f1 OP1 OP2 f2 */ \
351 List_FOR_ALL(f1, i) \
352 { \
353 (f1P[i]) OP1 OP2 (f2P[i]); \
354 }
355
356
357// Member operator : this field f OP s
358
359#define TFOR_ALL_F_OP_S(typeF, f, OP, typeS, s) \
360 \
361 /* Field access */ \
362 List_ACCESS(typeF, f, fP); \
363 \
364 /* Loop: f OP s */ \
365 List_FOR_ALL(f, i) \
366 { \
367 (fP[i]) OP (s); \
368 }
369
370
371// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
372
373// Friend operator function : s OP f, allocates storage for s
374
375#define TFOR_ALL_S_OP_F(typeS, s, OP, typeF, f) \
376 \
377 /* Field access */ \
378 List_CONST_ACCESS(typeF, f, fP); \
379 \
380 /* Loop: s OP f */ \
381 List_FOR_ALL(f, i) \
382 { \
383 (s) OP (fP[i]); \
384 }
385
386
387// Friend operator function : s OP1 f1 OP2 f2, allocates storage for s
388
389#define TFOR_ALL_S_OP_F_OP_F(typeS, s, OP1, typeF1, f1, OP2, typeF2, f2) \
390 \
391 /* Field access */ \
392 List_CONST_ACCESS(typeF1, f1, f1P); \
393 List_CONST_ACCESS(typeF2, f2, f2P); \
394 \
395 /* Loop: s OP f */ \
396 List_FOR_ALL(f1, i) \
397 { \
398 (s) OP1 (f1P[i]) OP2 (f2P[i]); \
399 }
400
401
402// Friend operator function : s OP FUNC(f), allocates storage for s
403
404#define TFOR_ALL_S_OP_FUNC_F(typeS, s, OP, FUNC, typeF, f) \
405 \
406 /* Field access */ \
407 List_CONST_ACCESS(typeF, f, fP); \
408 \
409 /* Loop: s OP FUNC(f) */ \
410 List_FOR_ALL(f, i) \
411 { \
412 (s) OP FUNC(fP[i]); \
413 }
414
415
416// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
417
418} // End namespace Foam
419
420// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
421
422#endif
423
424// ************************************************************************* //
ListLoopM.H
Macros for accessing List elements.
Foam::UList
A 1D vector of objects of type <T>, where the size of the vector is known and can be used for subscri...
Definition: UList.H:94
FatalErrorInFunction
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:453
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.C:34
Foam::checkFields
void checkFields(const FieldField< Field, Type1 > &, const FieldField< Field, Type2 > &, const char *op)
Definition: FieldField.C:85
Foam::endl
Ostream & endl(Ostream &os)
Add newline and flush stream.
Definition: Ostream.H:372
Foam::abort
errorManip< error > abort(error &err)
Definition: errorManip.H:144
Foam::FatalError
error FatalError
Foam::ensightPTraits::typeName
static const char *const typeName
The type name used in ensight case files.
Definition: ensightPTraits.H:56