FreeFOAM The Cross-Platform CFD Toolkit
genericPointPatchField.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 "genericPointPatchField.H"
28 
29 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
30 
31 namespace Foam
32 {
33 
34 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
35 
36 template<class Type>
38 (
39  const pointPatch& p,
41 )
42 :
44 {
46  (
47  "genericPointPatchField<Type>::genericPointPatchField"
48  "(const pointPatch& p, const DimensionedField<Type, volMesh>& iF)"
49  );
50 }
51 
52 
53 template<class Type>
55 (
56  const pointPatch& p,
58  const dictionary& dict
59 )
60 :
62  actualTypeName_(dict.lookup("type")),
63  dict_(dict)
64 {
65  for
66  (
67  dictionary::const_iterator iter = dict_.begin();
68  iter != dict_.end();
69  ++iter
70  )
71  {
72  if (iter().keyword() != "type")
73  {
74  if
75  (
76  iter().isStream()
77  && iter().stream().size()
78  )
79  {
80  ITstream& is = iter().stream();
81 
82  // Read first token
83  token firstToken(is);
84 
85  if
86  (
87  firstToken.isWord()
88  && firstToken.wordToken() == "nonuniform"
89  )
90  {
91  token fieldToken(is);
92 
93  if (!fieldToken.isCompound())
94  {
95  if
96  (
97  fieldToken.isLabel()
98  && fieldToken.labelToken() == 0
99  )
100  {
101  scalarFields_.insert
102  (
103  iter().keyword(),
104  new scalarField(0)
105  );
106  }
107  else
108  {
110  (
111  "genericPointPatchField<Type>::"
112  "genericPointPatchField"
113  "(const pointPatch&, const Field<Type>&, "
114  "const dictionary&)",
115  dict
116  ) << "\n token following 'nonuniform' "
117  "is not a compound"
118  << "\n on patch " << this->patch().name()
119  << " of field "
120  << this->dimensionedInternalField().name()
121  << " in file "
122  << this->dimensionedInternalField().objectPath()
123  << exit(FatalIOError);
124  }
125  }
126  else if
127  (
128  fieldToken.compoundToken().type()
129  == token::Compound<List<scalar> >::typeName
130  )
131  {
132  scalarField* fPtr = new scalarField;
133  fPtr->transfer
134  (
136  (
137  fieldToken.transferCompoundToken()
138  )
139  );
140 
141  if (fPtr->size() != this->size())
142  {
144  (
145  "genericPointPatchField<Type>::"
146  "genericPointPatchField"
147  "(const pointPatch&, const Field<Type>&, "
148  "const dictionary&)",
149  dict
150  ) << "\n size of field " << iter().keyword()
151  << " (" << fPtr->size() << ')'
152  << " is not the same size as the patch ("
153  << this->size() << ')'
154  << "\n on patch " << this->patch().name()
155  << " of field "
156  << this->dimensionedInternalField().name()
157  << " in file "
158  << this->dimensionedInternalField().objectPath()
159  << exit(FatalIOError);
160  }
161 
162  scalarFields_.insert(iter().keyword(), fPtr);
163  }
164  else if
165  (
166  fieldToken.compoundToken().type()
167  == token::Compound<List<vector> >::typeName
168  )
169  {
170  vectorField* fPtr = new vectorField;
171  fPtr->transfer
172  (
174  (
175  fieldToken.transferCompoundToken()
176  )
177  );
178 
179  if (fPtr->size() != this->size())
180  {
182  (
183  "genericPointPatchField<Type>::"
184  "genericPointPatchField"
185  "(const pointPatch&, const Field<Type>&, "
186  "const dictionary&)",
187  dict
188  ) << "\n size of field " << iter().keyword()
189  << " (" << fPtr->size() << ')'
190  << " is not the same size as the patch ("
191  << this->size() << ')'
192  << "\n on patch " << this->patch().name()
193  << " of field "
194  << this->dimensionedInternalField().name()
195  << " in file "
196  << this->dimensionedInternalField().objectPath()
197  << exit(FatalIOError);
198  }
199 
200  vectorFields_.insert(iter().keyword(), fPtr);
201  }
202  else if
203  (
204  fieldToken.compoundToken().type()
206  )
207  {
209  fPtr->transfer
210  (
212  <
214  >
215  (
216  fieldToken.transferCompoundToken()
217  )
218  );
219 
220  if (fPtr->size() != this->size())
221  {
223  (
224  "genericPointPatchField<Type>::"
225  "genericPointPatchField"
226  "(const pointPatch&, const Field<Type>&, "
227  "const dictionary&)",
228  dict
229  ) << "\n size of field " << iter().keyword()
230  << " (" << fPtr->size() << ')'
231  << " is not the same size as the patch ("
232  << this->size() << ')'
233  << "\n on patch " << this->patch().name()
234  << " of field "
235  << this->dimensionedInternalField().name()
236  << " in file "
237  << this->dimensionedInternalField().objectPath()
238  << exit(FatalIOError);
239  }
240 
241  sphericalTensorFields_.insert(iter().keyword(), fPtr);
242  }
243  else if
244  (
245  fieldToken.compoundToken().type()
246  == token::Compound<List<symmTensor> >::typeName
247  )
248  {
249  symmTensorField* fPtr = new symmTensorField;
250  fPtr->transfer
251  (
253  <
255  >
256  (
257  fieldToken.transferCompoundToken()
258  )
259  );
260 
261  if (fPtr->size() != this->size())
262  {
264  (
265  "genericPointPatchField<Type>::"
266  "genericPointPatchField"
267  "(const pointPatch&, const Field<Type>&, "
268  "const dictionary&)",
269  dict
270  ) << "\n size of field " << iter().keyword()
271  << " (" << fPtr->size() << ')'
272  << " is not the same size as the patch ("
273  << this->size() << ')'
274  << "\n on patch " << this->patch().name()
275  << " of field "
276  << this->dimensionedInternalField().name()
277  << " in file "
278  << this->dimensionedInternalField().objectPath()
279  << exit(FatalIOError);
280  }
281 
282  symmTensorFields_.insert(iter().keyword(), fPtr);
283  }
284  else if
285  (
286  fieldToken.compoundToken().type()
287  == token::Compound<List<tensor> >::typeName
288  )
289  {
290  tensorField* fPtr = new tensorField;
291  fPtr->transfer
292  (
294  (
295  fieldToken.transferCompoundToken()
296  )
297  );
298 
299  if (fPtr->size() != this->size())
300  {
302  (
303  "genericPointPatchField<Type>::"
304  "genericPointPatchField"
305  "(const pointPatch&, const Field<Type>&, "
306  "const dictionary&)",
307  dict
308  ) << "\n size of field " << iter().keyword()
309  << " (" << fPtr->size() << ')'
310  << " is not the same size as the patch ("
311  << this->size() << ')'
312  << "\n on patch " << this->patch().name()
313  << " of field "
314  << this->dimensionedInternalField().name()
315  << " in file "
316  << this->dimensionedInternalField().objectPath()
317  << exit(FatalIOError);
318  }
319 
320  tensorFields_.insert(iter().keyword(), fPtr);
321  }
322  else
323  {
325  (
326  "genericPointPatchField<Type>::"
327  "genericPointPatchField"
328  "(const pointPatch&, const Field<Type>&, "
329  "const dictionary&)",
330  dict
331  ) << "\n compound " << fieldToken.compoundToken()
332  << " not supported"
333  << "\n on patch " << this->patch().name()
334  << " of field "
335  << this->dimensionedInternalField().name()
336  << " in file "
337  << this->dimensionedInternalField().objectPath()
338  << exit(FatalIOError);
339  }
340  }
341  }
342  }
343  }
344 }
345 
346 
347 template<class Type>
349 (
350  const genericPointPatchField<Type>& ptf,
351  const pointPatch& p,
353  const pointPatchFieldMapper& mapper
354 )
355 :
356  calculatedPointPatchField<Type>(ptf, p, iF, mapper),
357  actualTypeName_(ptf.actualTypeName_),
358  dict_(ptf.dict_)
359 {
360  for
361  (
363  ptf.scalarFields_.begin();
364  iter != ptf.scalarFields_.end();
365  ++iter
366  )
367  {
368  scalarFields_.insert(iter.key(), new scalarField(*iter(), mapper));
369  }
370 
371  for
372  (
374  ptf.vectorFields_.begin();
375  iter != ptf.vectorFields_.end();
376  ++iter
377  )
378  {
379  vectorFields_.insert(iter.key(), new vectorField(*iter(), mapper));
380  }
381 
382  for
383  (
385  ptf.sphericalTensorFields_.begin();
386  iter != ptf.sphericalTensorFields_.end();
387  ++iter
388  )
389  {
390  sphericalTensorFields_.insert
391  (
392  iter.key(),
393  new sphericalTensorField(*iter(), mapper)
394  );
395  }
396 
397  for
398  (
400  ptf.symmTensorFields_.begin();
401  iter != ptf.symmTensorFields_.end();
402  ++iter
403  )
404  {
405  symmTensorFields_.insert
406  (
407  iter.key(),
408  new symmTensorField(*iter(), mapper)
409  );
410  }
411 
412  for
413  (
415  ptf.tensorFields_.begin();
416  iter != ptf.tensorFields_.end();
417  ++iter
418  )
419  {
420  tensorFields_.insert(iter.key(), new tensorField(*iter(), mapper));
421  }
422 }
423 
424 
425 template<class Type>
427 (
428  const genericPointPatchField<Type>& ptf,
430 )
431 :
433  actualTypeName_(ptf.actualTypeName_),
434  dict_(ptf.dict_),
435  scalarFields_(ptf.scalarFields_),
436  vectorFields_(ptf.vectorFields_),
437  sphericalTensorFields_(ptf.sphericalTensorFields_),
438  symmTensorFields_(ptf.symmTensorFields_),
439  tensorFields_(ptf.tensorFields_)
440 {}
441 
442 
443 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
444 
445 template<class Type>
447 (
448  const pointPatchFieldMapper& m
449 )
450 {
451  for
452  (
453  HashPtrTable<scalarField>::iterator iter = scalarFields_.begin();
454  iter != scalarFields_.end();
455  ++iter
456  )
457  {
458  iter()->autoMap(m);
459  }
460 
461  for
462  (
463  HashPtrTable<vectorField>::iterator iter = vectorFields_.begin();
464  iter != vectorFields_.end();
465  ++iter
466  )
467  {
468  iter()->autoMap(m);
469  }
470 
471  for
472  (
474  sphericalTensorFields_.begin();
475  iter != sphericalTensorFields_.end();
476  ++iter
477  )
478  {
479  iter()->autoMap(m);
480  }
481 
482  for
483  (
485  symmTensorFields_.begin();
486  iter != symmTensorFields_.end();
487  ++iter
488  )
489  {
490  iter()->autoMap(m);
491  }
492 
493  for
494  (
495  HashPtrTable<tensorField>::iterator iter = tensorFields_.begin();
496  iter != tensorFields_.end();
497  ++iter
498  )
499  {
500  iter()->autoMap(m);
501  }
502 }
503 
504 
505 template<class Type>
507 (
508  const pointPatchField<Type>& ptf,
509  const labelList& addr
510 )
511 {
512  const genericPointPatchField<Type>& dptf =
513  refCast<const genericPointPatchField<Type> >(ptf);
514 
515  for
516  (
517  HashPtrTable<scalarField>::iterator iter = scalarFields_.begin();
518  iter != scalarFields_.end();
519  ++iter
520  )
521  {
523  dptf.scalarFields_.find(iter.key());
524 
525  if (dptfIter != scalarFields_.end())
526  {
527  iter()->rmap(*dptfIter(), addr);
528  }
529  }
530 
531  for
532  (
533  HashPtrTable<vectorField>::iterator iter = vectorFields_.begin();
534  iter != vectorFields_.end();
535  ++iter
536  )
537  {
539  dptf.vectorFields_.find(iter.key());
540 
541  if (dptfIter != vectorFields_.end())
542  {
543  iter()->rmap(*dptfIter(), addr);
544  }
545  }
546 
547  for
548  (
550  sphericalTensorFields_.begin();
551  iter != sphericalTensorFields_.end();
552  ++iter
553  )
554  {
556  dptf.sphericalTensorFields_.find(iter.key());
557 
558  if (dptfIter != sphericalTensorFields_.end())
559  {
560  iter()->rmap(*dptfIter(), addr);
561  }
562  }
563 
564  for
565  (
567  symmTensorFields_.begin();
568  iter != symmTensorFields_.end();
569  ++iter
570  )
571  {
573  dptf.symmTensorFields_.find(iter.key());
574 
575  if (dptfIter != symmTensorFields_.end())
576  {
577  iter()->rmap(*dptfIter(), addr);
578  }
579  }
580 
581  for
582  (
583  HashPtrTable<tensorField>::iterator iter = tensorFields_.begin();
584  iter != tensorFields_.end();
585  ++iter
586  )
587  {
589  dptf.tensorFields_.find(iter.key());
590 
591  if (dptfIter != tensorFields_.end())
592  {
593  iter()->rmap(*dptfIter(), addr);
594  }
595  }
596 }
597 
598 
599 template<class Type>
601 {
602  os.writeKeyword("type") << actualTypeName_ << token::END_STATEMENT << nl;
603 
604  for
605  (
606  dictionary::const_iterator iter = dict_.begin();
607  iter != dict_.end();
608  ++iter
609  )
610  {
611  if (iter().keyword() != "type")
612  {
613  if
614  (
615  iter().isStream()
616  && iter().stream().size()
617  && iter().stream()[0].isWord()
618  && iter().stream()[0].wordToken() == "nonuniform"
619  )
620  {
621  if (scalarFields_.found(iter().keyword()))
622  {
623  scalarFields_.find(iter().keyword())()
624  ->writeEntry(iter().keyword(), os);
625  }
626  else if (vectorFields_.found(iter().keyword()))
627  {
628  vectorFields_.find(iter().keyword())()
629  ->writeEntry(iter().keyword(), os);
630  }
631  else if (sphericalTensorFields_.found(iter().keyword()))
632  {
633  sphericalTensorFields_.find(iter().keyword())()
634  ->writeEntry(iter().keyword(), os);
635  }
636  else if (symmTensorFields_.found(iter().keyword()))
637  {
638  symmTensorFields_.find(iter().keyword())()
639  ->writeEntry(iter().keyword(), os);
640  }
641  else if (tensorFields_.found(iter().keyword()))
642  {
643  tensorFields_.find(iter().keyword())()
644  ->writeEntry(iter().keyword(), os);
645  }
646  }
647  else
648  {
649  iter().write(os);
650  }
651  }
652  }
653 }
654 
655 
656 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
657 
658 } // End namespace Foam
659 
660 // ************************ vim: set sw=4 sts=4 et: ************************ //