fvBoundaryMesh.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 "fvBoundaryMesh.H"
27 #include "fvMesh.H"
28 
29 
30 // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
31 
32 void Foam::fvBoundaryMesh::addPatches(const polyBoundaryMesh& basicBdry)
33 {
34  setSize(basicBdry.size());
35 
36  // Set boundary patches
37  fvPatchList& Patches = *this;
38 
39  forAll(Patches, patchi)
40  {
41  Patches.set(patchi, fvPatch::New(basicBdry[patchi], *this));
42  }
43 }
44 
45 
46 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
47 
49 (
50  const fvMesh& m
51 )
52 :
53  fvPatchList(0),
54  mesh_(m)
55 {}
56 
57 
59 (
60  const fvMesh& m,
61  const polyBoundaryMesh& basicBdry
62 )
63 :
64  fvPatchList(basicBdry.size()),
65  mesh_(m)
66 {
67  addPatches(basicBdry);
68 }
69 
70 
71 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
72 
74 {
75  const fvPatchList& patches = *this;
76 
77  forAll(patches, patchi)
78  {
79  if (patches[patchi].name() == patchName)
80  {
81  return patchi;
82  }
83  }
84 
85  // Not found, return -1
86  return -1;
87 }
88 
89 
91 (
92  const wordRe& key,
93  const bool usePatchGroups
94 ) const
95 {
96  return mesh().boundaryMesh().findIndices(key, usePatchGroups);
97 }
98 
99 
101 {
102  forAll(*this, patchi)
103  {
105  }
106 
107  forAll(*this, patchi)
108  {
110  }
111 }
112 
113 
115 (
116  const labelUList& newToOld,
117  const bool validBoundary
118 )
119 {
120  fvPatchList& patches = *this;
121  patches.shuffle(newToOld);
122 }
123 
124 
126 {
128 
129  forAll(interfaces, patchi)
130  {
131  if (isA<lduInterface>(this->operator[](patchi)))
132  {
133  interfaces.set
134  (
135  patchi,
136  &refCast<const lduInterface>(this->operator[](patchi))
137  );
138  }
139  }
140 
141  return interfaces;
142 }
143 
144 
145 // * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
146 
148 {
149  clear();
150  addPatches(basicBdry);
151 }
152 
153 
154 // * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
155 
157 (
158  const word& patchName
159 ) const
160 {
161  const label patchi = findPatchID(patchName);
162 
163  if (patchi < 0)
164  {
166  << "Patch named " << patchName << " not found." << nl
167  << abort(FatalError);
168  }
169 
170  return operator[](patchi);
171 }
172 
173 
175 (
176  const word& patchName
177 )
178 {
179  const label patchi = findPatchID(patchName);
180 
181  if (patchi < 0)
182  {
184  << "Patch named " << patchName << " not found." << nl
185  << abort(FatalError);
186  }
187 
188  return operator[](patchi);
189 }
190 
191 
192 // ************************************************************************* //
const polyBoundaryMesh & boundaryMesh() const
Return boundary mesh.
Definition: polyMesh.H:434
virtual void initMovePoints()
Initialise the patches for moving points.
Definition: fvPatch.C:162
#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
error FatalError
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:323
label findPatchID(const word &patchName) const
Find patch index given a name.
A finiteVolume patch using a polyPatch and a fvBoundaryMesh.
Definition: fvPatch.H:62
patches[0]
fvBoundaryMesh(const fvMesh &)
Construct with zero size.
friend Ostream & operator(Ostream &, const UPtrList< T > &)
Write UPtrList to Ostream.
void readUpdate(const polyBoundaryMesh &)
Update boundary based on new polyBoundaryMesh.
const fvPatch & operator[](const word &) const
Return const reference to fvPatch by name.
const fvMesh & mesh() const
Return the mesh reference.
A class for handling words, derived from string.
Definition: word.H:59
void shuffle(const labelUList &newToOld, const bool validBoundary)
Reorders patches. Ordering does not have to be done in.
errorManip< error > abort(error &err)
Definition: errorManip.H:131
A wordRe is a word, but can also have a regular expression for matching words.
Definition: wordRe.H:74
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
void setSize(const label)
Reset size of PtrList. If extending the PtrList, new entries are.
Definition: PtrList.C:131
Foam::polyBoundaryMesh.
static const char nl
Definition: Ostream.H:260
bool set(const label) const
Is element set.
Definition: UPtrListI.H:78
lduInterfacePtrsList interfaces() const
Return a list of pointers for each patch.
word name(const complex &)
Return a string representation of a complex.
Definition: complex.C:47
label size() const
Return the number of elements in the UPtrList.
Definition: UPtrListI.H:29
PtrList< fvPatch > fvPatchList
container classes for fvPatch
Definition: fvPatchList.H:45
label patchi
A templated 1D list of pointers to objects of type <T>, where the size of the array is known and used...
Definition: List.H:70
Mesh data needed to do the Finite Volume discretisation.
Definition: fvMesh.H:78
labelList findIndices(const wordRe &, const bool useGroups) const
Find patch indices given a name.
void movePoints()
Correct patches after moving points.
void clear()
Clear the PtrList, i.e. set size to zero deleting all the.
Definition: PtrList.C:174
void shuffle(const labelUList &newToOld)
Reorders elements. Ordering does not have to be done in.
Definition: PtrList.C:248
static autoPtr< fvPatch > New(const polyPatch &, const fvBoundaryMesh &)
Return a pointer to a new patch created on freestore from polyPatch.
Definition: fvPatchNew.C:32
labelList findIndices(const wordRe &, const bool usePatchGroups=true) const
Return patch indices for all matches. Optionally matches patchGroups.
virtual void movePoints()
Correct patches after moving points.
Definition: fvPatch.C:166