cyclicPolyPatch.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-2020 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 "cyclicPolyPatch.H"
28 #include "polyBoundaryMesh.H"
29 #include "polyMesh.H"
30 #include "demandDrivenData.H"
31 #include "OFstream.H"
32 #include "matchPoints.H"
33 #include "EdgeMap.H"
34 #include "Time.H"
35 #include "transformField.H"
36 #include "SubField.H"
37 #include "unitConversion.H"
38 
39 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
40 
41 namespace Foam
42 {
43  defineTypeNameAndDebug(cyclicPolyPatch, 0);
44 
45  addToRunTimeSelectionTable(polyPatch, cyclicPolyPatch, word);
46  addToRunTimeSelectionTable(polyPatch, cyclicPolyPatch, dictionary);
47 }
48 
49 
50 // * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
51 
53 {
55 }
56 
57 
59 (
60  const primitivePatch& referPatch,
61  pointField& nbrCtrs,
62  vectorField& nbrAreas,
63  pointField& nbrCc
64 )
65 {}
66 
67 
69 {
70  static_cast<cyclicTransform&>(*this) =
72  (
73  name(),
74  faceCentres(),
75  faceAreas(),
76  *this,
77  nbrPatchName(),
78  nbrPatch().faceCentres(),
79  nbrPatch().faceAreas(),
80  nbrPatch(),
81  matchTolerance()
82  );
83 }
84 
85 
87 (
88  PstreamBuffers& pBufs,
89  const pointField& p
90 )
91 {
92  polyPatch::initMovePoints(pBufs, p);
93 }
94 
95 
97 (
98  PstreamBuffers& pBufs,
99  const pointField& p
100 )
101 {
102  polyPatch::movePoints(pBufs, p);
103 }
104 
105 
107 {
109 }
110 
111 
113 {
114  polyPatch::updateMesh(pBufs);
115  deleteDemandDrivenData(coupledPointsPtr_);
116  deleteDemandDrivenData(coupledEdgesPtr_);
117 }
118 
119 
120 // * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * * //
121 
123 (
124  const word& name,
125  const label size,
126  const label start,
127  const label index,
128  const polyBoundaryMesh& bm,
129  const word& patchType
130 )
131 :
132  coupledPolyPatch(name, size, start, index, bm, patchType),
133  cyclicTransform(false),
134  nbrPatchName_(word::null),
135  nbrPatchID_(-1),
136  coupledPointsPtr_(nullptr),
137  coupledEdgesPtr_(nullptr),
138  ownToNbrOrderDataPtr_(nullptr),
139  ownToNbrCyclicOrderDataPtr_(nullptr),
140  ownToNbrDebugOrderDataPtr_(nullptr)
141 {
142  // Neighbour patch might not be valid yet so no transformation
143  // calculation possible.
144 }
145 
146 
148 (
149  const word& name,
150  const label size,
151  const label start,
152  const label index,
153  const polyBoundaryMesh& bm,
154  const word& patchType,
155  const word& nbrPatchName
156 )
157 :
158  coupledPolyPatch(name, size, start, index, bm, patchType),
159  cyclicTransform(false),
160  nbrPatchName_(nbrPatchName),
161  nbrPatchID_(-1),
162  coupledPointsPtr_(nullptr),
163  coupledEdgesPtr_(nullptr),
164  ownToNbrOrderDataPtr_(nullptr),
165  ownToNbrCyclicOrderDataPtr_(nullptr),
166  ownToNbrDebugOrderDataPtr_(nullptr)
167 {
168  // Neighbour patch might not be valid yet so no transformation
169  // calculation possible.
170 }
171 
172 
174 (
175  const word& name,
176  const dictionary& dict,
177  const label index,
178  const polyBoundaryMesh& bm,
179  const word& patchType
180 )
181 :
182  coupledPolyPatch(name, dict, index, bm, patchType),
183  cyclicTransform(dict, false),
184  nbrPatchName_(dict.lookupOrDefault("neighbourPatch", word::null)),
185  coupleGroup_(dict),
186  nbrPatchID_(-1),
187  coupledPointsPtr_(nullptr),
188  coupledEdgesPtr_(nullptr),
189  ownToNbrOrderDataPtr_(nullptr),
190  ownToNbrCyclicOrderDataPtr_(nullptr),
191  ownToNbrDebugOrderDataPtr_(nullptr)
192 {
193  if (nbrPatchName_ == word::null && !coupleGroup_.valid())
194  {
196  (
197  dict
198  ) << "No \"neighbourPatch\" provided." << endl
199  << exit(FatalIOError);
200  }
201 
202  if (nbrPatchName_ == name)
203  {
205  << "Neighbour patch name " << nbrPatchName_
206  << " cannot be the same as this patch " << name
207  << exit(FatalIOError);
208  }
209 
210  // Neighbour patch might not be valid yet so no transformation
211  // calculation possible.
212 }
213 
214 
216 (
217  const cyclicPolyPatch& pp,
218  const polyBoundaryMesh& bm
219 )
220 :
221  coupledPolyPatch(pp, bm),
222  cyclicTransform(pp),
223  nbrPatchName_(pp.nbrPatchName_),
224  coupleGroup_(pp.coupleGroup_),
225  nbrPatchID_(-1),
226  coupledPointsPtr_(nullptr),
227  coupledEdgesPtr_(nullptr),
228  ownToNbrOrderDataPtr_(nullptr),
229  ownToNbrCyclicOrderDataPtr_(nullptr),
230  ownToNbrDebugOrderDataPtr_(nullptr)
231 {
232  // Neighbour patch might not be valid yet so no transformation
233  // calculation possible.
234 }
235 
236 
238 (
239  const cyclicPolyPatch& pp,
240  const polyBoundaryMesh& bm,
241  const label index,
242  const label newSize,
243  const label newStart,
244  const word& neiName
245 )
246 :
247  coupledPolyPatch(pp, bm, index, newSize, newStart),
248  cyclicTransform(pp),
249  nbrPatchName_(neiName),
250  coupleGroup_(pp.coupleGroup_),
251  nbrPatchID_(-1),
252  coupledPointsPtr_(nullptr),
253  coupledEdgesPtr_(nullptr),
254  ownToNbrOrderDataPtr_(nullptr),
255  ownToNbrCyclicOrderDataPtr_(nullptr),
256  ownToNbrDebugOrderDataPtr_(nullptr)
257 {
258  if (neiName == name())
259  {
261  << "Neighbour patch name " << neiName
262  << " cannot be the same as this patch " << name()
263  << exit(FatalError);
264  }
265 
266  // Neighbour patch might not be valid yet so no transformation
267  // calculation possible.
268 }
269 
270 
272 (
273  const cyclicPolyPatch& pp,
274  const polyBoundaryMesh& bm,
275  const label index,
276  const labelUList& mapAddressing,
277  const label newStart
278 )
279 :
280  coupledPolyPatch(pp, bm, index, mapAddressing, newStart),
281  cyclicTransform(pp),
282  nbrPatchName_(pp.nbrPatchName_),
283  coupleGroup_(pp.coupleGroup_),
284  nbrPatchID_(-1),
285  coupledPointsPtr_(nullptr),
286  coupledEdgesPtr_(nullptr),
287  ownToNbrOrderDataPtr_(nullptr),
288  ownToNbrCyclicOrderDataPtr_(nullptr),
289  ownToNbrDebugOrderDataPtr_(nullptr)
290 {}
291 
292 
293 // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
294 
296 {
297  deleteDemandDrivenData(coupledPointsPtr_);
298  deleteDemandDrivenData(coupledEdgesPtr_);
299 }
300 
301 
302 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
303 
305 {
306  if (nbrPatchName_.empty())
307  {
308  // Try and use patchGroup to find samplePatch and sampleRegion
309  label patchID = coupleGroup_.findOtherPatchID(*this);
310 
311  nbrPatchName_ = boundaryMesh()[patchID].name();
312  }
313  return nbrPatchName_;
314 }
315 
316 
318 {
319  if (nbrPatchID_ == -1)
320  {
321  nbrPatchID_ = this->boundaryMesh().findPatchID(nbrPatchName());
322 
323  if (nbrPatchID_ == -1)
324  {
326  << "Illegal neighbourPatch name " << nbrPatchName()
327  << endl << "Valid patch names are "
328  << this->boundaryMesh().names()
329  << exit(FatalError);
330  }
331 
332  // Check that it is a cyclic
333  const cyclicPolyPatch& nbrPatch = refCast<const cyclicPolyPatch>
334  (
335  this->boundaryMesh()[nbrPatchID_]
336  );
337 
338  if (nbrPatch.nbrPatchName() != name())
339  {
341  << "Patch " << name()
342  << " specifies neighbour patch " << nbrPatchName()
343  << endl << " but that in return specifies "
344  << nbrPatch.nbrPatchName()
345  << endl;
346  }
347  }
348  return nbrPatchID_;
349 }
350 
351 
353 {
354  if (!coupledPointsPtr_)
355  {
356  const faceList& nbrLocalFaces = nbrPatch().localFaces();
357  const labelList& nbrMeshPoints = nbrPatch().meshPoints();
358 
359  // Now all we know is that relative face index in *this is same
360  // as coupled face in nbrPatch and also that the 0th vertex
361  // corresponds.
362 
363  // From local point to nbrPatch or -1.
364  labelList coupledPoint(nPoints(), -1);
365 
366  forAll(*this, patchFacei)
367  {
368  const face& fA = localFaces()[patchFacei];
369  const face& fB = nbrLocalFaces[patchFacei];
370 
371  forAll(fA, indexA)
372  {
373  label patchPointA = fA[indexA];
374 
375  if (coupledPoint[patchPointA] == -1)
376  {
377  label indexB = (fB.size() - indexA) % fB.size();
378 
379  // Filter out points on wedge axis
380  if (meshPoints()[patchPointA] != nbrMeshPoints[fB[indexB]])
381  {
382  coupledPoint[patchPointA] = fB[indexB];
383  }
384  }
385  }
386  }
387 
388  coupledPointsPtr_ = new edgeList(nPoints());
389  edgeList& connected = *coupledPointsPtr_;
390 
391  // Extract coupled points.
392  label connectedI = 0;
393 
394  forAll(coupledPoint, i)
395  {
396  if (coupledPoint[i] != -1)
397  {
398  connected[connectedI++] = edge(i, coupledPoint[i]);
399  }
400  }
401 
402  connected.setSize(connectedI);
403 
404  if (debug)
405  {
406  OFstream str
407  (
408  boundaryMesh().mesh().time().path()
409  /name() + "_coupledPoints.obj"
410  );
411  label vertI = 0;
412 
413  Pout<< "Writing file " << str.name() << " with coordinates of "
414  << "coupled points" << endl;
415 
416  forAll(connected, i)
417  {
418  const point& a = points()[meshPoints()[connected[i][0]]];
419  const point& b = points()[nbrMeshPoints[connected[i][1]]];
420 
421  str<< "v " << a.x() << ' ' << a.y() << ' ' << a.z() << nl;
422  str<< "v " << b.x() << ' ' << b.y() << ' ' << b.z() << nl;
423  vertI += 2;
424 
425  str<< "l " << vertI-1 << ' ' << vertI << nl;
426  }
427  }
428  }
429  return *coupledPointsPtr_;
430 }
431 
432 
434 {
435  if (!coupledEdgesPtr_)
436  {
437  const edgeList& pointCouples = coupledPoints();
438 
439  // Build map from points on *this (A) to points on neighbourpatch (B)
440  Map<label> aToB(2*pointCouples.size());
441 
442  forAll(pointCouples, i)
443  {
444  const edge& e = pointCouples[i];
445 
446  aToB.insert(e[0], e[1]);
447  }
448 
449  // Map from edge on A to points (in B indices)
450  EdgeMap<label> edgeMap(nEdges());
451 
452  forAll(*this, patchFacei)
453  {
454  const labelList& fEdges = faceEdges()[patchFacei];
455 
456  forAll(fEdges, i)
457  {
458  label edgeI = fEdges[i];
459 
460  const edge& e = edges()[edgeI];
461 
462  // Convert edge end points to corresponding points on B side.
463  Map<label>::const_iterator fnd0 = aToB.find(e[0]);
464  if (fnd0 != aToB.end())
465  {
466  Map<label>::const_iterator fnd1 = aToB.find(e[1]);
467  if (fnd1 != aToB.end())
468  {
469  edgeMap.insert(edge(fnd0(), fnd1()), edgeI);
470  }
471  }
472  }
473  }
474 
475  // Use the edgeMap to get the edges on the B side.
476 
477  const cyclicPolyPatch& nbrPatch = this->nbrPatch();
478  const labelList& nbrMp = nbrPatch.meshPoints();
479  const labelList& mp = meshPoints();
480 
481 
482 
483  coupledEdgesPtr_ = new edgeList(edgeMap.size());
484  edgeList& coupledEdges = *coupledEdgesPtr_;
485  label coupleI = 0;
486 
487  forAll(nbrPatch, patchFacei)
488  {
489  const labelList& fEdges = nbrPatch.faceEdges()[patchFacei];
490 
491  forAll(fEdges, i)
492  {
493  label edgeI = fEdges[i];
494 
495  const edge& e = nbrPatch.edges()[edgeI];
496 
497  // Look up A edge from HashTable.
498  EdgeMap<label>::iterator iter = edgeMap.find(e);
499 
500  if (iter != edgeMap.end())
501  {
502  label edgeA = iter();
503  const edge& eA = edges()[edgeA];
504 
505  // Store correspondence. Filter out edges on wedge axis.
506  if
507  (
508  edge(mp[eA[0]], mp[eA[1]])
509  != edge(nbrMp[e[0]], nbrMp[e[1]])
510  )
511  {
512  coupledEdges[coupleI++] = edge(edgeA, edgeI);
513  }
514 
515  // Remove so we build unique list
516  edgeMap.erase(iter);
517  }
518  }
519  }
520  coupledEdges.setSize(coupleI);
521 
522 
523  // Some checks
524 
525  forAll(coupledEdges, i)
526  {
527  const edge& e = coupledEdges[i];
528 
529  if (e[0] < 0 || e[1] < 0)
530  {
532  << "Problem : at position " << i
533  << " illegal couple:" << e
534  << abort(FatalError);
535  }
536  }
537 
538  if (debug)
539  {
540  OFstream str
541  (
542  boundaryMesh().mesh().time().path()
543  /name() + "_coupledEdges.obj"
544  );
545  label vertI = 0;
546 
547  Pout<< "Writing file " << str.name() << " with centres of "
548  << "coupled edges" << endl;
549 
550  forAll(coupledEdges, i)
551  {
552  const edge& e = coupledEdges[i];
553 
554  const point& a = edges()[e[0]].centre(localPoints());
555  const point& b = nbrPatch.edges()[e[1]].centre
556  (
557  nbrPatch.localPoints()
558  );
559 
560  str<< "v " << a.x() << ' ' << a.y() << ' ' << a.z() << nl;
561  str<< "v " << b.x() << ' ' << b.y() << ' ' << b.z() << nl;
562  vertI += 2;
563 
564  str<< "l " << vertI-1 << ' ' << vertI << nl;
565  }
566  }
567  }
568  return *coupledEdgesPtr_;
569 }
570 
571 
573 (
575  const primitivePatch& pp
576 ) const
577 {
578  if (pp.empty())
579  {
580  return;
581  }
582 
583  if (owner())
584  {
585  ownToNbrOrderDataPtr_ = new ownToNbrOrderData();
586  if (coupledPolyPatch::debug)
587  {
588  ownToNbrDebugOrderDataPtr_ = new ownToNbrDebugOrderData();
589  }
590 
592  (
593  ownToNbrOrderDataPtr_(),
594  ownToNbrDebugOrderDataPtr_,
595  pp
596  );
597 
598  const scalarField magAreas(mag(pp.faceAreas()));
599 
600  ownToNbrCyclicOrderDataPtr_ = new ownToNbrCyclicOrderData();
601  ownToNbrCyclicOrderDataPtr_->ctr =
602  sum(pp.faceCentres()*magAreas)/sum(magAreas);
603  ownToNbrCyclicOrderDataPtr_->area = sum(pp.faceAreas());
604  }
605 }
606 
607 
609 (
610  PstreamBuffers& pBufs,
611  const primitivePatch& pp,
612  labelList& faceMap,
613  labelList& rotation
614 ) const
615 {
616  if (pp.empty())
617  {
618  return false;
619  }
620 
621  ownToNbrOrderData ownToNbr;
622  autoPtr<ownToNbrDebugOrderData> ownToNbrDebugPtr(nullptr);
623 
624  if (!owner())
625  {
626  ownToNbr = nbrPatch().ownToNbrOrderDataPtr_();
627  ownToNbrDebugPtr = nbrPatch().ownToNbrDebugOrderDataPtr_;
628 
629  cyclicTransform ct
630  (
631  name(),
632  pp.faceCentres(),
633  pp.faceAreas(),
634  *this,
635  nbrPatchName(),
636  pointField(1, nbrPatch().ownToNbrCyclicOrderDataPtr_->ctr),
637  vectorField(1, nbrPatch().ownToNbrCyclicOrderDataPtr_->area),
638  nbrPatch(),
639  matchTolerance()
640  );
641 
642  ownToNbr.transform(ct.transform());
643  if (ownToNbrDebugPtr.valid())
644  {
645  ownToNbrDebugPtr->transform(ct.transform());
646  }
647  }
648 
649  return
651  (
652  ownToNbr,
653  ownToNbrDebugPtr,
654  pp,
655  faceMap,
656  rotation
657  );
658 }
659 
660 
662 {
664 
665  if (!nbrPatchName_.empty())
666  {
667  writeEntry(os, "neighbourPatch", nbrPatchName_);
668  }
669 
670  coupleGroup_.write(os);
671 
673 }
674 
675 
676 // ************************************************************************* //
virtual void write(Ostream &) const
Write the polyPatch data as a dictionary.
static bool valid(char)
Is this character valid for a word.
Definition: wordI.H:115
virtual bool order(const ownToNbrOrderData &ownToNbr, const autoPtr< ownToNbrDebugOrderData > &ownToNbrDebugPtr, const primitivePatch &, labelList &faceMap, labelList &rotation) const
Return new ordering for the given primitivePatch.
#define forAll(list, i)
Loop across all elements in list.
Definition: UList.H:434
intWM_LABEL_SIZE_t label
A label is an int32_t or int64_t as specified by the pre-processor macro WM_LABEL_SIZE.
Definition: label.H:59
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:124
const edgeList & coupledPoints() const
Return connected points (from patch local to neighbour patch local)
static iteratorEnd end()
iteratorEnd set to beyond the end of any HashTable
Definition: HashTable.H:112
A face is a list of labels corresponding to mesh vertices.
Definition: face.H:75
error FatalError
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:158
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:319
const Field< PointType > & faceCentres() const
Return face centres for patch.
virtual void initUpdateMesh(PstreamBuffers &)
Initialise the update of the patch topology.
Definition: polyPatch.H:115
Unit conversion functions.
void transform(const transformer &tr)
Output to file stream.
Definition: OFstream.H:82
void size(const label)
Override size to be inconsistent with allocated storage.
Definition: ListI.H:164
virtual void calcGeometry(PstreamBuffers &)
Calculate the patch geometry.
Addressing for all faces on surface of mesh. Can either be read from polyMesh or from triSurface...
Definition: boundaryMesh.H:59
Ostream & endl(Ostream &os)
Add newline and flush stream.
Definition: Ostream.H:251
virtual void updateMesh(PstreamBuffers &)
Update of the patch topology.
virtual void initMovePoints(PstreamBuffers &, const pointField &)
Initialise the patches for moving points.
const word & nbrPatchName() const
Neighbour patch name.
The coupledPolyPatch is an abstract base class for patches that couple regions of the computational d...
const Cmpt & z() const
Definition: VectorI.H:87
const dimensionedScalar & mp
Proton mass.
cyclicPolyPatch(const word &name, const label size, const label start, const label index, const polyBoundaryMesh &bm, const word &patchType)
Construct from components.
const Field< PointType > & localPoints() const
Return pointField of points in patch.
virtual void initMovePoints(PstreamBuffers &, const pointField &)
Initialise the patches for moving points.
Definition: polyPatch.H:108
const edgeList & coupledEdges() const
Return connected edges (from patch local to neighbour patch local).
const fileName & name() const
Return the name of the stream.
Definition: OFstream.H:120
virtual bool order(PstreamBuffers &, const primitivePatch &, labelList &faceMap, labelList &rotation) const
Return new ordering for primitivePatch.
label size() const
Return number of elements in table.
Definition: HashTableI.H:65
Determine correspondence between points. See below.
const Field< PointType > & faceAreas() const
Return face areas for patch.
Macros for easy insertion into run-time selection tables.
void write(Ostream &os) const
Write the data to a dictionary.
const labelList & meshPoints() const
Return labelList of mesh points in patch. They are constructed.
const Cmpt & y() const
Definition: VectorI.H:81
dimensioned< Type > sum(const DimensionedField< Type, GeoMesh > &df)
bool erase(const iterator &)
Erase a hashedEntry specified by given iterator.
Definition: HashTable.C:371
virtual void movePoints(PstreamBuffers &, const pointField &p)
Correct patches after moving points.
Definition: polyPatch.C:57
bool insert(const Key &, const T &newElmt)
Insert a new hashedEntry.
Definition: HashTableI.H:80
iterator find(const Key &)
Find and return an iterator set at the hashedEntry.
Definition: HashTable.C:142
virtual void initUpdateMesh(PstreamBuffers &)
Initialise the update of the patch topology.
const Vector< Cmpt > & centre(const Foam::List< Vector< Cmpt >> &) const
Return *this (used for point which is a typedef to Vector<scalar>.
Definition: VectorI.H:116
virtual void initOrder(ownToNbrOrderData &ownToNbr, autoPtr< ownToNbrDebugOrderData > &ownToNbrDebugPtr, const primitivePatch &) const
Initialise ordering for the given primitivePatch. Fills the.
Data to pass from owner.initOrder to nbr.order if debugging.
Spatial transformation functions for primitive fields.
A list of faces which address into the list of points.
vectorField pointField
pointField is a vectorField.
Definition: pointFieldFwd.H:42
dynamicFvMesh & mesh
const pointField & points
List< edge > edgeList
Definition: edgeList.H:38
An edge is a list of two point labels. The functionality it provides supports the discretisation on a...
Definition: edge.H:58
const dimensionedScalar & b
Wien displacement law constant: default SI units: [m K].
Definition: createFields.H:27
A class for handling words, derived from string.
Definition: word.H:59
label nPoints
Cyclic plane patch.
Data to pass from owner.initOrder to nbr.order.
static const word null
An empty word.
Definition: word.H:77
virtual void movePoints(PstreamBuffers &, const pointField &)
Correct patches after moving points.
const edgeList & edges() const
Return list of edges, address into LOCAL point list.
virtual void updateMesh(PstreamBuffers &)
Update of the patch topology.
Definition: polyPatch.C:62
bool valid() const
Return true if the autoPtr valid (ie, the pointer is set)
Definition: autoPtrI.H:83
errorManip< error > abort(error &err)
Definition: errorManip.H:131
A 1D vector of objects of type <T>, where the size of the vector is known and can be used for subscri...
Definition: HashTable.H:60
const Cmpt & x() const
Definition: VectorI.H:75
Foam::polyBoundaryMesh.
An Ostream is an abstract base class for all output systems (streams, files, token lists...
Definition: Ostream.H:54
addToRunTimeSelectionTable(ensightPart, ensightPartCells, istream)
static const char nl
Definition: Ostream.H:260
defineTypeNameAndDebug(combustionModel, 0)
virtual void write(Ostream &) const
Write the polyPatch data as a dictionary.
Buffers for inter-processor communications streams (UOPstream, UIPstream).
void writeEntry(Ostream &os, const HashTable< T, Key, Hash > &ht)
Definition: HashTableIO.C:96
word name(const complex &)
Return a string representation of a complex.
Definition: complex.C:47
void setSize(const label)
Reset size of List.
Definition: List.C:281
Template functions to aid in the implementation of demand driven data.
virtual ~cyclicPolyPatch()
Destructor.
T lookupOrDefault(const word &, const T &, bool recursive=false, bool patternMatch=true) const
Find and return a T,.
#define WarningInFunction
Report a warning using Foam::Warning.
#define FatalIOErrorInFunction(ios)
Report an error message using Foam::FatalIOError.
Definition: error.H:331
virtual void initCalcGeometry(PstreamBuffers &)
Initialise the calculation of the patch geometry.
Definition: polyPatch.H:100
prefixOSstream Pout(cout, "Pout")
Definition: IOstreams.H:53
const labelListList & faceEdges() const
Return face-edge addressing.
dimensioned< scalar > mag(const dimensioned< Type > &)
Field< vector > vectorField
Specialisation of Field<T> for vector.
virtual void initOrder(PstreamBuffers &, const primitivePatch &) const
Initialize ordering for primitivePatch. Does not.
const doubleScalar e
Elementary charge.
Definition: doubleScalar.H:105
Cyclic plane tranformation.
virtual void initCalcGeometry(PstreamBuffers &)
Initialise the calculation of the patch geometry.
void deleteDemandDrivenData(DataPtr &dataPtr)
virtual label nbrPatchID() const
Neighbour patchID.
Namespace for OpenFOAM.
fileName path(UMean.rootPath()/UMean.caseName()/functionObjects::writeFile::outputPrefix/"graphs"/UMean.instance())
IOerror FatalIOError