| blob | 4227d67df3ae4b66cfc5061dbdeff140711d0892 |
1 /*---------------------------------------------------------------------------*\
2 ========= |
3 \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4 \\ / O peration |
5 \\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
6 \\/ M anipulation |
7 -------------------------------------------------------------------------------
8 License
9 This file is part of OpenFOAM.
11 OpenFOAM is free software: you can redistribute it and/or modify it
12 under the terms of the GNU General Public License as published by
13 the Free Software Foundation, either version 3 of the License, or
14 (at your option) any later version.
16 OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 for more details.
21 You should have received a copy of the GNU General Public License
22 along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
24 \*---------------------------------------------------------------------------*/
26 #include "FieldM.H"
27 #include "FieldReuseFunctions.H"
29 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
31 #define UNARY_FUNCTION(ReturnType, Type, Func) \
32 \
33 TEMPLATE \
34 void Func(Field<ReturnType>& res, const UList<Type>& f) \
35 { \
36 TFOR_ALL_F_OP_FUNC_F(ReturnType, res, =, ::Foam::Func, Type, f) \
37 } \
38 \
39 TEMPLATE \
40 tmp<Field<ReturnType> > Func(const UList<Type>& f) \
41 { \
42 tmp<Field<ReturnType> > tRes(new Field<ReturnType>(f.size())); \
43 Func(tRes(), f); \
44 return tRes; \
45 } \
46 \
47 TEMPLATE \
48 tmp<Field<ReturnType> > Func(const tmp<Field<Type> >& tf) \
49 { \
50 tmp<Field<ReturnType> > tRes = reuseTmp<ReturnType, Type>::New(tf); \
51 Func(tRes(), tf()); \
52 reuseTmp<ReturnType, Type>::clear(tf); \
53 return tRes; \
54 }
57 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
59 #define UNARY_OPERATOR(ReturnType, Type, Op, OpFunc) \
60 \
61 TEMPLATE \
62 void OpFunc(Field<ReturnType>& res, const UList<Type>& f) \
63 { \
64 TFOR_ALL_F_OP_OP_F(ReturnType, res, =, Op, Type, f) \
65 } \
66 \
67 TEMPLATE \
68 tmp<Field<ReturnType> > operator Op(const UList<Type>& f) \
69 { \
70 tmp<Field<ReturnType> > tRes(new Field<ReturnType>(f.size())); \
71 OpFunc(tRes(), f); \
72 return tRes; \
73 } \
74 \
75 TEMPLATE \
76 tmp<Field<ReturnType> > operator Op(const tmp<Field<Type> >& tf) \
77 { \
78 tmp<Field<ReturnType> > tRes = reuseTmp<ReturnType, Type>::New(tf); \
79 OpFunc(tRes(), tf()); \
80 reuseTmp<ReturnType, Type>::clear(tf); \
81 return tRes; \
82 }
85 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
87 #define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
88 \
89 TEMPLATE \
90 void Func \
91 ( \
92 Field<ReturnType>& res, \
93 const UList<Type1>& f1, \
94 const UList<Type2>& f2 \
95 ) \
96 { \
97 TFOR_ALL_F_OP_FUNC_F_F \
98 ( \
99 ReturnType, res, =, ::Foam::Func, Type1, f1, Type2, f2 \
100 ) \
101 } \
102 \
103 TEMPLATE \
104 tmp<Field<ReturnType> > Func \
105 ( \
106 const UList<Type1>& f1, \
107 const UList<Type2>& f2 \
108 ) \
109 { \
110 tmp<Field<ReturnType> > tRes(new Field<ReturnType>(f1.size())); \
111 Func(tRes(), f1, f2); \
112 return tRes; \
113 } \
114 \
115 TEMPLATE \
116 tmp<Field<ReturnType> > Func \
117 ( \
118 const UList<Type1>& f1, \
119 const tmp<Field<Type2> >& tf2 \
120 ) \
121 { \
122 tmp<Field<ReturnType> > tRes = reuseTmp<ReturnType, Type2>::New(tf2); \
123 Func(tRes(), f1, tf2()); \
124 reuseTmp<ReturnType, Type2>::clear(tf2); \
125 return tRes; \
126 } \
127 \
128 TEMPLATE \
129 tmp<Field<ReturnType> > Func \
130 ( \
131 const tmp<Field<Type1> >& tf1, \
132 const UList<Type2>& f2 \
133 ) \
134 { \
135 tmp<Field<ReturnType> > tRes = reuseTmp<ReturnType, Type1>::New(tf1); \
136 Func(tRes(), tf1(), f2); \
137 reuseTmp<ReturnType, Type1>::clear(tf1); \
138 return tRes; \
139 } \
140 \
141 TEMPLATE \
142 tmp<Field<ReturnType> > Func \
143 ( \
144 const tmp<Field<Type1> >& tf1, \
145 const tmp<Field<Type2> >& tf2 \
146 ) \
147 { \
148 tmp<Field<ReturnType> > tRes = \
149 reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2); \
150 Func(tRes(), tf1(), tf2()); \
151 reuseTmpTmp<ReturnType, Type1, Type1, Type2>::clear(tf1, tf2); \
152 return tRes; \
153 }
156 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
158 #define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
159 \
160 TEMPLATE \
161 void Func \
162 ( \
163 Field<ReturnType>& res, \
164 const Type1& s1, \
165 const UList<Type2>& f2 \
166 ) \
167 { \
168 TFOR_ALL_F_OP_FUNC_S_F \
169 ( \
170 ReturnType, res, =, ::Foam::Func, Type1, s1, Type2, f2 \
171 ) \
172 } \
173 \
174 TEMPLATE \
175 tmp<Field<ReturnType> > Func \
176 ( \
177 const Type1& s1, \
178 const UList<Type2>& f2 \
179 ) \
180 { \
181 tmp<Field<ReturnType> > tRes(new Field<ReturnType>(f2.size())); \
182 Func(tRes(), s1, f2); \
183 return tRes; \
184 } \
185 \
186 TEMPLATE \
187 tmp<Field<ReturnType> > Func \
188 ( \
189 const Type1& s1, \
190 const tmp<Field<Type2> >& tf2 \
191 ) \
192 { \
193 tmp<Field<ReturnType> > tRes = reuseTmp<ReturnType, Type2>::New(tf2); \
194 Func(tRes(), s1, tf2()); \
195 reuseTmp<ReturnType, Type2>::clear(tf2); \
196 return tRes; \
197 }
200 #define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
201 \
202 TEMPLATE \
203 void Func \
204 ( \
205 Field<ReturnType>& res, \
206 const UList<Type1>& f1, \
207 const Type2& s2 \
208 ) \
209 { \
210 TFOR_ALL_F_OP_FUNC_F_S \
211 ( \
212 ReturnType, res, =, ::Foam::Func, Type1, f1, Type2, s2 \
213 ) \
214 } \
215 \
216 TEMPLATE \
217 tmp<Field<ReturnType> > Func \
218 ( \
219 const UList<Type1>& f1, \
220 const Type2& s2 \
221 ) \
222 { \
223 tmp<Field<ReturnType> > tRes(new Field<ReturnType>(f1.size())); \
224 Func(tRes(), f1, s2); \
225 return tRes; \
226 } \
227 \
228 TEMPLATE \
229 tmp<Field<ReturnType> > Func \
230 ( \
231 const tmp<Field<Type1> >& tf1, \
232 const Type2& s2 \
233 ) \
234 { \
235 tmp<Field<ReturnType> > tRes = reuseTmp<ReturnType, Type1>::New(tf1); \
236 Func(tRes(), tf1(), s2); \
237 reuseTmp<ReturnType, Type1>::clear(tf1); \
238 return tRes; \
239 }
242 #define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func) \
243 BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
244 BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)
247 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
249 #define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpFunc) \
250 \
251 TEMPLATE \
252 void OpFunc \
253 ( \
254 Field<ReturnType>& res, \
255 const UList<Type1>& f1, \
256 const UList<Type2>& f2 \
257 ) \
258 { \
259 TFOR_ALL_F_OP_F_OP_F(ReturnType, res, =, Type1, f1, Op, Type2, f2) \
260 } \
261 \
262 TEMPLATE \
263 tmp<Field<ReturnType> > operator Op \
264 ( \
265 const UList<Type1>& f1, \
266 const UList<Type2>& f2 \
267 ) \
268 { \
269 tmp<Field<ReturnType> > tRes(new Field<ReturnType>(f1.size())); \
270 OpFunc(tRes(), f1, f2); \
271 return tRes; \
272 } \
273 \
274 TEMPLATE \
275 tmp<Field<ReturnType> > operator Op \
276 ( \
277 const UList<Type1>& f1, \
278 const tmp<Field<Type2> >& tf2 \
279 ) \
280 { \
281 tmp<Field<ReturnType> > tRes = reuseTmp<ReturnType, Type2>::New(tf2); \
282 OpFunc(tRes(), f1, tf2()); \
283 reuseTmp<ReturnType, Type2>::clear(tf2); \
284 return tRes; \
285 } \
286 \
287 TEMPLATE \
288 tmp<Field<ReturnType> > operator Op \
289 ( \
290 const tmp<Field<Type1> >& tf1, \
291 const UList<Type2>& f2 \
292 ) \
293 { \
294 tmp<Field<ReturnType> > tRes = reuseTmp<ReturnType, Type1>::New(tf1); \
295 OpFunc(tRes(), tf1(), f2); \
296 reuseTmp<ReturnType, Type1>::clear(tf1); \
297 return tRes; \
298 } \
299 \
300 TEMPLATE \
301 tmp<Field<ReturnType> > operator Op \
302 ( \
303 const tmp<Field<Type1> >& tf1, \
304 const tmp<Field<Type2> >& tf2 \
305 ) \
306 { \
307 tmp<Field<ReturnType> > tRes = \
308 reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2); \
309 OpFunc(tRes(), tf1(), tf2()); \
310 reuseTmpTmp<ReturnType, Type1, Type1, Type2>::clear(tf1, tf2); \
311 return tRes; \
312 }
315 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
317 #define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc) \
318 \
319 TEMPLATE \
320 void OpFunc \
321 ( \
322 Field<ReturnType>& res, \
323 const Type1& s1, \
324 const UList<Type2>& f2 \
325 ) \
326 { \
327 TFOR_ALL_F_OP_S_OP_F(ReturnType, res, =, Type1, s1, Op, Type2, f2) \
328 } \
329 \
330 TEMPLATE \
331 tmp<Field<ReturnType> > operator Op \
332 ( \
333 const Type1& s1, \
334 const UList<Type2>& f2 \
335 ) \
336 { \
337 tmp<Field<ReturnType> > tRes(new Field<ReturnType>(f2.size())); \
338 OpFunc(tRes(), s1, f2); \
339 return tRes; \
340 } \
341 \
342 TEMPLATE \
343 tmp<Field<ReturnType> > operator Op \
344 ( \
345 const Type1& s1, \
346 const tmp<Field<Type2> >& tf2 \
347 ) \
348 { \
349 tmp<Field<ReturnType> > tRes = reuseTmp<ReturnType, Type2>::New(tf2); \
350 OpFunc(tRes(), s1, tf2()); \
351 reuseTmp<ReturnType, Type2>::clear(tf2); \
352 return tRes; \
353 }
356 #define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc) \
357 \
358 TEMPLATE \
359 void OpFunc \
360 ( \
361 Field<ReturnType>& res, \
362 const UList<Type1>& f1, \
363 const Type2& s2 \
364 ) \
365 { \
366 TFOR_ALL_F_OP_F_OP_S(ReturnType, res, =, Type1, f1, Op, Type2, s2) \
367 } \
368 \
369 TEMPLATE \
370 tmp<Field<ReturnType> > operator Op \
371 ( \
372 const UList<Type1>& f1, \
373 const Type2& s2 \
374 ) \
375 { \
376 tmp<Field<ReturnType> > tRes(new Field<ReturnType>(f1.size())); \
377 OpFunc(tRes(), f1, s2); \
378 return tRes; \
379 } \
380 \
381 TEMPLATE \
382 tmp<Field<ReturnType> > operator Op \
383 ( \
384 const tmp<Field<Type1> >& tf1, \
385 const Type2& s2 \
386 ) \
387 { \
388 tmp<Field<ReturnType> > tRes = reuseTmp<ReturnType, Type1>::New(tf1); \
389 OpFunc(tRes(), tf1(), s2); \
390 reuseTmp<ReturnType, Type1>::clear(tf1); \
391 return tRes; \
392 }
395 #define BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpFunc) \
396 BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc) \
397 BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
400 // ************************************************************************* //