genericPointPatchField.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
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"
27 #include "pointPatchFieldMapper.H"
28 
29 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
30 
31 template<class Type>
32 Foam::genericPointPatchField<Type>::genericPointPatchField
33 (
34  const pointPatch& p,
35  const DimensionedField<Type, pointMesh>& iF
36 )
37 :
38  calculatedPointPatchField<Type>(p, iF)
39 {
40  NotImplemented;
41 }
42 
43 
44 template<class Type>
45 Foam::genericPointPatchField<Type>::genericPointPatchField
46 (
47  const pointPatch& p,
48  const DimensionedField<Type, pointMesh>& iF,
49  const dictionary& dict
50 )
51 :
52  genericPatchField(dict.lookup("type")),
53  calculatedPointPatchField<Type>(p, iF, dict),
54  dict_(dict)
55 {
56  forAllConstIter(dictionary, dict_, iter)
57  {
58  if (iter().keyword() != "type")
59  {
60  if
61  (
62  iter().isStream()
63  && iter().stream().size()
64  )
65  {
66  ITstream& is = iter().stream();
67 
68  // Read first token
69  token firstToken(is);
70 
71  if
72  (
73  firstToken.isWord()
74  && firstToken.wordToken() == "nonuniform"
75  )
76  {
77  token fieldToken(is);
78 
79  if (!fieldToken.isCompound())
80  {
81  if
82  (
83  fieldToken.isLabel()
84  && fieldToken.labelToken() == 0
85  )
86  {
87  scalarFields_.insert
88  (
89  iter().keyword(),
90  new scalarField(0)
91  );
92  }
93  else
94  {
95  FatalIOErrorInFunction
96  (
97  dict
98  ) << "\n token following 'nonuniform' "
99  "is not a compound"
100  << "\n on patch " << this->patch().name()
101  << " of field "
102  << this->internalField().name()
103  << " in file "
104  << this->internalField().objectPath()
105  << exit(FatalIOError);
106  }
107  }
108  else if
109  (
110  fieldToken.compoundToken().type()
111  == token::Compound<List<scalar>>::typeName
112  )
113  {
114  scalarField* fPtr = new scalarField;
115  fPtr->transfer
116  (
117  dynamicCast<token::Compound<List<scalar>>>
118  (
119  fieldToken.transferCompoundToken(is)
120  )
121  );
122 
123  if (fPtr->size() != this->size())
124  {
125  FatalIOErrorInFunction
126  (
127  dict
128  ) << "\n size of field " << iter().keyword()
129  << " (" << fPtr->size() << ')'
130  << " is not the same size as the patch ("
131  << this->size() << ')'
132  << "\n on patch " << this->patch().name()
133  << " of field "
134  << this->internalField().name()
135  << " in file "
136  << this->internalField().objectPath()
137  << exit(FatalIOError);
138  }
139 
140  scalarFields_.insert(iter().keyword(), fPtr);
141  }
142  else if
143  (
144  fieldToken.compoundToken().type()
145  == token::Compound<List<vector>>::typeName
146  )
147  {
148  vectorField* fPtr = new vectorField;
149  fPtr->transfer
150  (
151  dynamicCast<token::Compound<List<vector>>>
152  (
153  fieldToken.transferCompoundToken(is)
154  )
155  );
156 
157  if (fPtr->size() != this->size())
158  {
159  FatalIOErrorInFunction
160  (
161  dict
162  ) << "\n size of field " << iter().keyword()
163  << " (" << fPtr->size() << ')'
164  << " is not the same size as the patch ("
165  << this->size() << ')'
166  << "\n on patch " << this->patch().name()
167  << " of field "
168  << this->internalField().name()
169  << " in file "
170  << this->internalField().objectPath()
171  << exit(FatalIOError);
172  }
173 
174  vectorFields_.insert(iter().keyword(), fPtr);
175  }
176  else if
177  (
178  fieldToken.compoundToken().type()
179  == token::Compound<List<sphericalTensor>>::typeName
180  )
181  {
182  sphericalTensorField* fPtr = new sphericalTensorField;
183  fPtr->transfer
184  (
185  dynamicCast
186  <
187  token::Compound<List<sphericalTensor>>
188  >
189  (
190  fieldToken.transferCompoundToken(is)
191  )
192  );
193 
194  if (fPtr->size() != this->size())
195  {
196  FatalIOErrorInFunction
197  (
198  dict
199  ) << "\n size of field " << iter().keyword()
200  << " (" << fPtr->size() << ')'
201  << " is not the same size as the patch ("
202  << this->size() << ')'
203  << "\n on patch " << this->patch().name()
204  << " of field "
205  << this->internalField().name()
206  << " in file "
207  << this->internalField().objectPath()
208  << exit(FatalIOError);
209  }
210 
211  sphericalTensorFields_.insert(iter().keyword(), fPtr);
212  }
213  else if
214  (
215  fieldToken.compoundToken().type()
216  == token::Compound<List<symmTensor>>::typeName
217  )
218  {
219  symmTensorField* fPtr = new symmTensorField;
220  fPtr->transfer
221  (
222  dynamicCast
223  <
224  token::Compound<List<symmTensor>>
225  >
226  (
227  fieldToken.transferCompoundToken(is)
228  )
229  );
230 
231  if (fPtr->size() != this->size())
232  {
233  FatalIOErrorInFunction
234  (
235  dict
236  ) << "\n size of field " << iter().keyword()
237  << " (" << fPtr->size() << ')'
238  << " is not the same size as the patch ("
239  << this->size() << ')'
240  << "\n on patch " << this->patch().name()
241  << " of field "
242  << this->internalField().name()
243  << " in file "
244  << this->internalField().objectPath()
245  << exit(FatalIOError);
246  }
247 
248  symmTensorFields_.insert(iter().keyword(), fPtr);
249  }
250  else if
251  (
252  fieldToken.compoundToken().type()
253  == token::Compound<List<tensor>>::typeName
254  )
255  {
256  tensorField* fPtr = new tensorField;
257  fPtr->transfer
258  (
259  dynamicCast<token::Compound<List<tensor>>>
260  (
261  fieldToken.transferCompoundToken(is)
262  )
263  );
264 
265  if (fPtr->size() != this->size())
266  {
267  FatalIOErrorInFunction
268  (
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->internalField().name()
277  << " in file "
278  << this->internalField().objectPath()
279  << exit(FatalIOError);
280  }
281 
282  tensorFields_.insert(iter().keyword(), fPtr);
283  }
284  else
285  {
286  FatalIOErrorInFunction
287  (
288  dict
289  ) << "\n compound " << fieldToken.compoundToken()
290  << " not supported"
291  << "\n on patch " << this->patch().name()
292  << " of field "
293  << this->internalField().name()
294  << " in file "
295  << this->internalField().objectPath()
296  << exit(FatalIOError);
297  }
298  }
299  }
300  }
301  }
302 }
303 
304 
305 template<class Type>
306 Foam::genericPointPatchField<Type>::genericPointPatchField
307 (
308  const genericPointPatchField<Type>& ptf,
309  const pointPatch& p,
310  const DimensionedField<Type, pointMesh>& iF,
311  const pointPatchFieldMapper& mapper
312 )
313 :
314  genericPatchField(ptf),
315  calculatedPointPatchField<Type>(ptf, p, iF, mapper),
316  dict_(ptf.dict_)
317 {
318  forAllConstIter
319  (
320  HashPtrTable<scalarField>,
321  ptf.scalarFields_,
322  iter
323  )
324  {
325  scalarFields_.insert
326  (
327  iter.key(),
328  mapper(*iter()).ptr()
329  );
330  }
331 
332  forAllConstIter
333  (
334  HashPtrTable<vectorField>,
335  ptf.vectorFields_,
336  iter
337  )
338  {
339  vectorFields_.insert
340  (
341  iter.key(),
342  mapper(*iter()).ptr()
343  );
344  }
345 
346  forAllConstIter
347  (
348  HashPtrTable<sphericalTensorField>,
349  ptf.sphericalTensorFields_,
350  iter
351  )
352  {
353  sphericalTensorFields_.insert
354  (
355  iter.key(),
356  mapper(*iter()).ptr()
357  );
358  }
359 
360  forAllConstIter
361  (
362  HashPtrTable<symmTensorField>,
363  ptf.symmTensorFields_,
364  iter
365  )
366  {
367  symmTensorFields_.insert
368  (
369  iter.key(),
370  mapper(*iter()).ptr()
371  );
372  }
373 
374  forAllConstIter
375  (
376  HashPtrTable<tensorField>,
377  ptf.tensorFields_,
378  iter
379  )
380  {
381  tensorFields_.insert
382  (
383  iter.key(),
384  mapper(*iter()).ptr()
385  );
386  }
387 }
388 
389 
390 template<class Type>
391 Foam::genericPointPatchField<Type>::genericPointPatchField
392 (
393  const genericPointPatchField<Type>& ptf,
394  const DimensionedField<Type, pointMesh>& iF
395 )
396 :
397  genericPatchField(ptf),
398  calculatedPointPatchField<Type>(ptf, iF),
399  dict_(ptf.dict_),
400  scalarFields_(ptf.scalarFields_),
401  vectorFields_(ptf.vectorFields_),
402  sphericalTensorFields_(ptf.sphericalTensorFields_),
403  symmTensorFields_(ptf.symmTensorFields_),
404  tensorFields_(ptf.tensorFields_)
405 {}
406 
407 
408 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
409 
410 template<class Type>
411 void Foam::genericPointPatchField<Type>::autoMap
412 (
413  const pointPatchFieldMapper& m
414 )
415 {
416  forAllIter
417  (
418  HashPtrTable<scalarField>,
419  scalarFields_,
420  iter
421  )
422  {
423  m(*iter(), *iter());
424  }
425 
426  forAllIter
427  (
428  HashPtrTable<vectorField>,
429  vectorFields_,
430  iter
431  )
432  {
433  m(*iter(), *iter());
434  }
435 
436  forAllIter
437  (
438  HashPtrTable<sphericalTensorField>,
439  sphericalTensorFields_,
440  iter
441  )
442  {
443  m(*iter(), *iter());
444  }
445 
446  forAllIter
447  (
448  HashPtrTable<symmTensorField>,
449  symmTensorFields_,
450  iter
451  )
452  {
453  m(*iter(), *iter());
454  }
455 
456  forAllIter
457  (
458  HashPtrTable<tensorField>,
459  tensorFields_,
460  iter
461  )
462  {
463  m(*iter(), *iter());
464  }
465 }
466 
467 
468 template<class Type>
469 void Foam::genericPointPatchField<Type>::rmap
470 (
471  const pointPatchField<Type>& ptf,
472  const labelList& addr
473 )
474 {
475  const genericPointPatchField<Type>& dptf =
476  refCast<const genericPointPatchField<Type>>(ptf);
477 
478  forAllIter
479  (
480  HashPtrTable<scalarField>,
481  scalarFields_,
482  iter
483  )
484  {
485  HashPtrTable<scalarField>::const_iterator dptfIter =
486  dptf.scalarFields_.find(iter.key());
487 
488  if (dptfIter != scalarFields_.end())
489  {
490  iter()->rmap(*dptfIter(), addr);
491  }
492  }
493 
494  forAllIter
495  (
496  HashPtrTable<vectorField>,
497  vectorFields_,
498  iter
499  )
500  {
501  HashPtrTable<vectorField>::const_iterator dptfIter =
502  dptf.vectorFields_.find(iter.key());
503 
504  if (dptfIter != vectorFields_.end())
505  {
506  iter()->rmap(*dptfIter(), addr);
507  }
508  }
509 
510  forAllIter
511  (
512  HashPtrTable<sphericalTensorField>,
513  sphericalTensorFields_,
514  iter
515  )
516  {
517  HashPtrTable<sphericalTensorField>::const_iterator dptfIter =
518  dptf.sphericalTensorFields_.find(iter.key());
519 
520  if (dptfIter != sphericalTensorFields_.end())
521  {
522  iter()->rmap(*dptfIter(), addr);
523  }
524  }
525 
526  forAllIter
527  (
528  HashPtrTable<symmTensorField>,
529  symmTensorFields_,
530  iter
531  )
532  {
533  HashPtrTable<symmTensorField>::const_iterator dptfIter =
534  dptf.symmTensorFields_.find(iter.key());
535 
536  if (dptfIter != symmTensorFields_.end())
537  {
538  iter()->rmap(*dptfIter(), addr);
539  }
540  }
541 
542  forAllIter
543  (
544  HashPtrTable<tensorField>,
545  tensorFields_,
546  iter
547  )
548  {
549  HashPtrTable<tensorField>::const_iterator dptfIter =
550  dptf.tensorFields_.find(iter.key());
551 
552  if (dptfIter != tensorFields_.end())
553  {
554  iter()->rmap(*dptfIter(), addr);
555  }
556  }
557 }
558 
559 
560 template<class Type>
561 void Foam::genericPointPatchField<Type>::reset
562 (
563  const pointPatchField<Type>& ptf
564 )
565 {
566  const genericPointPatchField<Type>& dptf =
567  refCast<const genericPointPatchField<Type>>(ptf);
568 
569  forAllIter
570  (
571  HashPtrTable<scalarField>,
572  scalarFields_,
573  iter
574  )
575  {
576  HashPtrTable<scalarField>::const_iterator dptfIter =
577  dptf.scalarFields_.find(iter.key());
578 
579  if (dptfIter != scalarFields_.end())
580  {
581  iter()->reset(*dptfIter());
582  }
583  }
584 
585  forAllIter
586  (
587  HashPtrTable<vectorField>,
588  vectorFields_,
589  iter
590  )
591  {
592  HashPtrTable<vectorField>::const_iterator dptfIter =
593  dptf.vectorFields_.find(iter.key());
594 
595  if (dptfIter != vectorFields_.end())
596  {
597  iter()->reset(*dptfIter());
598  }
599  }
600 
601  forAllIter
602  (
603  HashPtrTable<sphericalTensorField>,
604  sphericalTensorFields_,
605  iter
606  )
607  {
608  HashPtrTable<sphericalTensorField>::const_iterator dptfIter =
609  dptf.sphericalTensorFields_.find(iter.key());
610 
611  if (dptfIter != sphericalTensorFields_.end())
612  {
613  iter()->reset(*dptfIter());
614  }
615  }
616 
617  forAllIter
618  (
619  HashPtrTable<symmTensorField>,
620  symmTensorFields_,
621  iter
622  )
623  {
624  HashPtrTable<symmTensorField>::const_iterator dptfIter =
625  dptf.symmTensorFields_.find(iter.key());
626 
627  if (dptfIter != symmTensorFields_.end())
628  {
629  iter()->reset(*dptfIter());
630  }
631  }
632 
633  forAllIter
634  (
635  HashPtrTable<tensorField>,
636  tensorFields_,
637  iter
638  )
639  {
640  HashPtrTable<tensorField>::const_iterator dptfIter =
641  dptf.tensorFields_.find(iter.key());
642 
643  if (dptfIter != tensorFields_.end())
644  {
645  iter()->reset(*dptfIter());
646  }
647  }
648 }
649 
650 
651 template<class Type>
652 void Foam::genericPointPatchField<Type>::write(Ostream& os) const
653 {
654  writeEntry(os, "type", actualTypeName());
655 
656  forAllConstIter(dictionary, dict_, iter)
657  {
658  if (iter().keyword() != "type")
659  {
660  if
661  (
662  iter().isStream()
663  && iter().stream().size()
664  && iter().stream()[0].isWord()
665  && iter().stream()[0].wordToken() == "nonuniform"
666  )
667  {
668  if (scalarFields_.found(iter().keyword()))
669  {
670  writeEntry
671  (
672  os,
673  iter().keyword(),
674  *scalarFields_.find(iter().keyword())()
675  );
676  }
677  else if (vectorFields_.found(iter().keyword()))
678  {
679  writeEntry
680  (
681  os,
682  iter().keyword(),
683  *vectorFields_.find(iter().keyword())()
684  );
685  }
686  else if (sphericalTensorFields_.found(iter().keyword()))
687  {
688  writeEntry
689  (
690  os,
691  iter().keyword(),
692  *sphericalTensorFields_.find(iter().keyword())()
693  );
694  }
695  else if (symmTensorFields_.found(iter().keyword()))
696  {
697  writeEntry
698  (
699  os,
700  iter().keyword(),
701  *symmTensorFields_.find(iter().keyword())()
702  );
703  }
704  else if (tensorFields_.found(iter().keyword()))
705  {
706  writeEntry
707  (
708  os,
709  iter().keyword(),
710  *tensorFields_.find(iter().keyword())()
711  );
712  }
713  }
714  else
715  {
716  iter().write(os);
717  }
718  }
719  }
720 }
721 
722 
723 // ************************************************************************* //
Foam::token::isLabel
bool isLabel() const
Definition: tokenI.H:392
Foam::genericPointPatchField::write
virtual void write(Ostream &) const
Write.
Definition: genericPointPatchField.C:652
Foam::token::isWord
bool isWord() const
Definition: tokenI.H:261
Foam::sphericalTensorField
Field< sphericalTensor > sphericalTensorField
Specialisation of Field<T> for sphericalTensor.
Definition: primitiveFieldsFwd.H:50
Foam::token::transferCompoundToken
compound & transferCompoundToken(const Istream &is)
Definition: token.C:93
Foam::symmTensorField
Field< symmTensor > symmTensorField
Specialisation of Field<T> for symmTensor.
Definition: primitiveFieldsFwd.H:51
Foam::dynamicCast
To & dynamicCast(From &r)
Reference type cast template function,.
Definition: typeInfo.H:85
Foam::HashTable::const_iterator
An STL-conforming const_iterator.
Definition: HashTable.H:481
Foam::exit
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:124
Foam::dictionary
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:156
forAllConstIter
#define forAllConstIter(Container, container, iter)
Iterate across all elements in the container object of type.
Definition: UList.H:477
forAllIter
#define forAllIter(Container, container, iter)
Iterate across all elements in the container object of type.
Definition: UList.H:459
Foam::token::wordToken
const word & wordToken() const
Definition: tokenI.H:266
Foam::List::size
void size(const label)
Override size to be inconsistent with allocated storage.
Definition: ListI.H:164
Foam::token
A token holds items read from Istream.
Definition: token.H:72
Foam::pointPatchFieldMapper
Foam::pointPatchFieldMapper.
Definition: pointPatchFieldMapper.H:46
vectorField
volVectorField vectorField(fieldObject, mesh)
Foam::HashPtrTable
A HashTable specialisation for hashing pointers.
Definition: HashPtrTable.H:50
Foam::calculatedPointPatchField
A calculated boundary condition for pointField.
Definition: calculatedPointPatchField.H:49
Foam::token::isCompound
bool isCompound() const
Definition: tokenI.H:520
Foam::pointPatchField
Abstract base class for point-mesh patch fields.
Definition: pointMVCWeight.H:58
Foam::token::Compound
A templated class for holding compound tokens.
Definition: token.H:209
Foam::genericPointPatchField
A generic version of calculatedPointPatchField, useful as a fallback for handling unknown patch types...
Definition: genericPointPatchField.H:52
Foam::genericPointPatchField::rmap
virtual void rmap(const pointPatchField< Type > &, const labelList &)
Reverse map the given pointPatchField onto this pointPatchField.
Definition: genericPointPatchField.C:470
Foam::token::compoundToken
const compound & compoundToken() const
Definition: tokenI.H:525
Foam::Ostream
An Ostream is an abstract base class for all output systems (streams, files, token lists...
Definition: Ostream.H:54
scalarField
volScalarField scalarField(fieldObject, mesh)
Foam::writeEntry
void writeEntry(Ostream &os, const HashTable< T, Key, Hash > &ht)
Definition: HashTableIO.C:96
Foam::tensorField
Field< tensor > tensorField
Specialisation of Field<T> for tensor.
Definition: primitiveFieldsFwd.H:52
FatalIOErrorInFunction
#define FatalIOErrorInFunction(ios)
Report an error message using Foam::FatalIOError.
Definition: error.H:318
Foam::pointPatch
Basic pointPatch represents a set of points from the mesh.
Definition: pointPatch.H:56
Foam::genericPointPatchField::autoMap
virtual void autoMap(const pointPatchFieldMapper &)
Map (and resize as needed) from self given a mapping object.
Definition: genericPointPatchField.C:412
Foam::genericPointPatchField::reset
virtual void reset(const pointPatchField< Type > &)
Reset the pointPatchField to the given pointPatchField.
Definition: genericPointPatchField.C:562
Foam::token::labelToken
label labelToken() const
Definition: tokenI.H:397
Foam::DimensionedField
Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a...
Definition: DimensionedField.H:51
p
volScalarField & p
Definition: createFieldRefs.H:5
NotImplemented
#define NotImplemented
Issue a FatalErrorIn for a function not currently implemented.
Definition: error.H:353
Foam::List::transfer
void transfer(List< T > &)
Transfer the contents of the argument List into this list.
Definition: List.C:342
Foam::genericPointPatchField::genericPointPatchField
genericPointPatchField(const pointPatch &, const DimensionedField< Type, pointMesh > &)
Construct from patch and internal field.
Definition: genericPointPatchField.C:33
Foam::ITstream
Input token stream.
Definition: ITstream.H:49
Foam::dictionary::lookup
ITstream & lookup(const word &, bool recursive=false, bool patternMatch=true) const
Find and return an entry data stream.
Definition: dictionary.C:864
Foam::FatalIOError
IOerror FatalIOError