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-2019 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 keyType& 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
A class for handling keywords in dictionaries.
Definition: keyType.H:64
virtual void initMovePoints()
Initialise the patches for moving points.
Definition: fvPatch.C:156
#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:319
label findPatchID(const word &patchName) const
Find patch index given a name.
A finiteVolume patch using a polyPatch and a fvBoundaryMesh.
Definition: fvPatch.H:61
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.
labelList findIndices(const keyType &, const bool useGroups) const
Find patch indices given a 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 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:265
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 keyType &, const bool usePatchGroups=true) const
Return patch indices for all matches. Optionally matches patchGroups.
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
virtual void movePoints()
Correct patches after moving points.
Definition: fvPatch.C:160