FreeFOAM The Cross-Platform CFD Toolkit
dimensionedType.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | Copyright (C) 1991-2010 OpenCFD Ltd.
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8 License
9  This file is part of OpenFOAM.
10 
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.
15 
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.
20 
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/>.
23 
24 \*---------------------------------------------------------------------------*/
25 
26 #include "dimensionedType.H"
27 #include <OpenFOAM/pTraits.H>
28 #include <OpenFOAM/dictionary.H>
29 
30 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
31 
32 namespace Foam
33 {
34 
35 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
36 
37 template <class Type>
38 dimensioned<Type> dimensioned<Type>::lookupOrDefault
39 (
40  const word& name,
41  const dictionary& dict,
42  const Type& defaultValue,
43  const dimensionSet& dims
44 )
45 {
46  Type value = dict.lookupOrDefault<Type>(name, defaultValue);
47  return dimensioned<Type>(name, dims, value);
48 }
49 
50 
51 template <class Type>
53 (
54  const word& name,
55  dictionary& dict,
56  const Type& defaultValue,
57  const dimensionSet& dims
58 )
59 {
60  Type value = dict.lookupOrAddDefault<Type>(name, defaultValue);
61  return dimensioned<Type>(name, dims, value);
62 }
63 
64 
65 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
66 
67 template <class Type>
69 (
70  const word& name,
71  const dimensionSet& dimSet,
72  const Type t
73 )
74 :
75  name_(name),
76  dimensions_(dimSet),
77  value_(t)
78 {}
79 
80 
81 template <class Type>
83 (
84  const word& name,
85  const dimensioned<Type>& dt
86 )
87 :
88  name_(name),
89  dimensions_(dt.dimensions_),
90  value_(dt.value_)
91 {}
92 
93 
94 template <class Type>
96 (
97  Istream& is
98 )
99 :
100  name_(is),
101  dimensions_(is),
102  value_(pTraits<Type>(is))
103 {}
104 
105 
106 template <class Type>
108 (
109  const word& name,
110  Istream& is
111 )
112 :
113  name_(name),
114  dimensions_(is),
115  value_(pTraits<Type>(is))
116 {}
117 
118 
119 template <class Type>
121 (
122  const word& name,
123  const dimensionSet& dimSet,
124  Istream& is
125 )
126 :
127  name_(name),
128  dimensions_(dimSet),
129  value_(pTraits<Type>(is))
130 {}
131 
132 
133 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
134 
135 template <class Type>
137 {
138  return name_;
139 }
140 
141 template <class Type>
143 {
144  return name_;
145 }
146 
147 
148 template <class Type>
150 {
151  return dimensions_;
152 }
153 
154 template <class Type>
156 {
157  return dimensions_;
158 }
159 
160 
161 template <class Type>
162 const Type& dimensioned<Type>::value() const
163 {
164  return value_;
165 }
166 
167 template <class Type>
169 {
170  return value_;
171 }
172 
173 
174 template <class Type>
176 (
177  const direction d
178 ) const
179 {
180  return dimensioned<cmptType>
181  (
182  name_ + ".component(" + Foam::name(d) + ')',
183  dimensions_,
184  value_.component(d)
185  );
186 }
187 
188 
189 template <class Type>
191 (
192  const direction d,
193  const dimensioned<typename dimensioned<Type>::cmptType>& dc
194 )
195 {
196  dimensions_ = dc.dimensions();
197  value_.replace(d, dc.value());
198 }
199 
200 
201 template <class Type>
203 {
204  return dict.readIfPresent(name_, value_);
205 }
206 
207 
208 // * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
209 
210 template <class Type>
212 (
213  const direction d
214 ) const
215 {
216  return component(d);
217 }
218 
219 
220 template <class Type>
222 (
223  const dimensioned<Type>& dt
224 )
225 {
226  dimensions_ += dt.dimensions_;
227  value_ += dt.value_;
228 }
229 
230 
231 template <class Type>
233 (
234  const dimensioned<Type>& dt
235 )
236 {
237  dimensions_ -= dt.dimensions_;
238  value_ -= dt.value_;
239 }
240 
241 
242 template <class Type>
244 (
245  const scalar s
246 )
247 {
248  value_ *= s;
249 }
250 
251 
252 template <class Type>
254 (
255  const scalar s
256 )
257 {
258  value_ /= s;
259 }
260 
261 
262 // * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * //
263 
264 template<class Type, int r>
267 {
269  (
270  "pow(" + dt.name() + ',' + name(r) + ')',
271  pow(dt.dimensions(), r),
272  pow(dt.value(), 2)
273  );
274 }
275 
276 template<class Type>
279 {
281  (
282  "sqr(" + dt.name() + ')',
283  sqr(dt.dimensions()),
284  sqr(dt.value())
285  );
286 }
287 
288 template<class Type>
290 {
291  return dimensioned<scalar>
292  (
293  "magSqr(" + dt.name() + ')',
294  magSqr(dt.dimensions()),
295  magSqr(dt.value())
296  );
297 }
298 
299 template<class Type>
301 {
302  return dimensioned<scalar>
303  (
304  "mag(" + dt.name() + ')',
305  dt.dimensions(),
306  mag(dt.value())
307  );
308 }
309 
310 
311 template <class Type>
312 dimensioned<Type> max
313 (
314  const dimensioned<Type>& dt1,
315  const dimensioned<Type>& dt2
316 )
317 {
318  if (dt1.dimensions() != dt2.dimensions())
319  {
320  FatalErrorIn("max(const dimensioned<Type>&, const dimensioned<Type>&)")
321  << "dimensions of arguments are not equal"
322  << abort(FatalError);
323  }
324 
325  return dimensioned<Type>
326  (
327  "max(" + dt1.name() + ',' + dt2.name() + ')',
328  dt1.dimensions(),
329  max(dt1.value(), dt2.value())
330  );
331 }
332 
333 
334 template <class Type>
335 dimensioned<Type> min
336 (
337  const dimensioned<Type>& dt1,
338  const dimensioned<Type>& dt2
339 )
340 {
341  if (dt1.dimensions() != dt2.dimensions())
342  {
343  FatalErrorIn("min(const dimensioned<Type>&, const dimensioned<Type>&)")
344  << "dimensions of arguments are not equal"
345  << abort(FatalError);
346  }
347 
348  return dimensioned<Type>
349  (
350  "min(" + dt1.name() + ',' + dt2.name() + ')',
351  dt1.dimensions(),
352  min(dt1.value(), dt2.value())
353  );
354 }
355 
356 
357 // * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
358 
359 template <class Type>
361 {
362  // do a stream read op for a Type and a dimensions()et
363  is >> dt.name_ >> dt.dimensions_ >> dt.value_;
364 
365  // Check state of Istream
366  is.check("Istream& operator>>(Istream&, dimensioned<Type>&)");
367 
368  return is;
369 }
370 
371 
372 template <class Type>
373 Ostream& operator<<(Ostream& os, const dimensioned<Type>& dt)
374 {
375  // do a stream write op for a dimensions()et
376  os << dt.name() << token::SPACE
377  << dt.dimensions() << token::SPACE
378  << dt.value();
379 
380  // Check state of Ostream
381  os.check("Ostream& operator<<(Ostream&, const dimensioned<Type>&)");
382 
383  return os;
384 }
385 
386 
387 // * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * //
388 
389 template <class Type>
390 bool operator>
391 (
392  const dimensioned<Type>& dt1,
393  const dimensioned<Type>& dt2
394 )
395 {
396  return dt1.value() > dt2.value();
397 }
398 
399 
400 template <class Type>
401 bool operator<
402 (
403  const dimensioned<Type>& dt1,
404  const dimensioned<Type>& dt2
405 )
406 {
407  return dt1.value() < dt2.value();
408 }
409 
410 
411 template <class Type>
412 dimensioned<Type> operator+
413 (
414  const dimensioned<Type>& dt1,
415  const dimensioned<Type>& dt2
416 )
417 {
418  return dimensioned<Type>
419  (
420  '(' + dt1.name() + '+' + dt2.name() + ')',
421  dt1.dimensions() + dt2.dimensions(),
422  dt1.value() + dt2.value()
423  );
424 }
425 
426 
427 template <class Type>
429 {
430  return dimensioned<Type>
431  (
432  '-' + dt.name(),
433  dt.dimensions(),
434  -dt.value()
435  );
436 }
437 
438 
439 template <class Type>
440 dimensioned<Type> operator-
441 (
442  const dimensioned<Type>& dt1,
443  const dimensioned<Type>& dt2
444 )
445 {
446  return dimensioned<Type>
447  (
448  '(' + dt1.name() + '-' + dt2.name() + ')',
449  dt1.dimensions() - dt2.dimensions(),
450  dt1.value() - dt2.value()
451  );
452 }
453 
454 
455 template <class Type>
456 dimensioned<Type> operator*
457 (
458  const dimensioned<scalar>& ds,
459  const dimensioned<Type>& dt
460 )
461 {
462  return dimensioned<Type>
463  (
464  '(' + ds.name() + '*' + dt.name() + ')',
465  ds.dimensions() * dt.dimensions(),
466  ds.value() * dt.value()
467  );
468 }
469 
470 
471 template <class Type>
472 dimensioned<Type> operator/
473 (
474  const dimensioned<Type>& dt,
475  const dimensioned<scalar>& ds
476 )
477 {
478  return dimensioned<Type>
479  (
480  '(' + dt.name() + '|' + ds.name() + ')',
481  dt.dimensions()/ds.dimensions(),
482  dt.value()/ds.value()
483  );
484 }
485 
486 
487 // Products
488 // ~~~~~~~~
489 
490 #define PRODUCT_OPERATOR(product, op, opFunc) \
491  \
492 template<class Type1, class Type2> \
493 dimensioned<typename product<Type1, Type2>::type> \
494 operator op(const dimensioned<Type1>& dt1, const dimensioned<Type2>& dt2) \
495 { \
496  return dimensioned<typename product<Type1, Type2>::type> \
497  ( \
498  '(' + dt1.name() + #op + dt2.name() + ')', \
499  dt1.dimensions() op dt2.dimensions(), \
500  dt1.value() op dt2.value() \
501  ); \
502 } \
503  \
504 template<class Type, class Form, class Cmpt, int nCmpt> \
505 dimensioned<typename product<Type, Form>::type> \
506 operator op \
507 ( \
508  const dimensioned<Type>& dt1, \
509  const VectorSpace<Form,Cmpt,nCmpt>& t2 \
510 ) \
511 { \
512  return dimensioned<typename product<Type, Form>::type> \
513  ( \
514  '(' + dt1.name() + #op + name(t2) + ')', \
515  dt1.dimensions(), \
516  dt1.value() op static_cast<const Form&>(t2) \
517  ); \
518 } \
519  \
520 template<class Type, class Form, class Cmpt, int nCmpt> \
521 dimensioned<typename product<Form, Type>::type> \
522 operator op \
523 ( \
524  const VectorSpace<Form,Cmpt,nCmpt>& t1, \
525  const dimensioned<Type>& dt2 \
526 ) \
527 { \
528  return dimensioned<typename product<Form, Type>::type> \
529  ( \
530  '(' + name(t1) + #op + dt2.name() + ')', \
531  dt2.dimensions(), \
532  static_cast<const Form&>(t1) op dt2.value() \
533  ); \
534 }
535 
536 
541 
542 #undef PRODUCT_OPERATOR
543 
544 
545 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
546 
547 } // End namespace Foam
548 
549 // ************************ vim: set sw=4 sts=4 et: ************************ //