FreeFOAM The Cross-Platform CFD Toolkit
lduMatrix.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 "lduMatrix.H"
27 #include <OpenFOAM/IOstreams.H>
28 
29 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
30 
31 namespace Foam
32 {
33  defineTypeNameAndDebug(lduMatrix, 1);
34 }
35 
36 const Foam::scalar Foam::lduMatrix::great_ = 1.0e+20;
37 const Foam::scalar Foam::lduMatrix::small_ = 1.0e-20;
38 
39 
40 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
41 
43 :
44  lduMesh_(mesh),
45  lowerPtr_(NULL),
46  diagPtr_(NULL),
47  upperPtr_(NULL)
48 {}
49 
50 
52 :
53  lduMesh_(A.lduMesh_),
54  lowerPtr_(NULL),
55  diagPtr_(NULL),
56  upperPtr_(NULL)
57 {
58  if (A.lowerPtr_)
59  {
60  lowerPtr_ = new scalarField(*(A.lowerPtr_));
61  }
62 
63  if (A.diagPtr_)
64  {
65  diagPtr_ = new scalarField(*(A.diagPtr_));
66  }
67 
68  if (A.upperPtr_)
69  {
70  upperPtr_ = new scalarField(*(A.upperPtr_));
71  }
72 }
73 
74 
76 :
77  lduMesh_(A.lduMesh_),
78  lowerPtr_(NULL),
79  diagPtr_(NULL),
80  upperPtr_(NULL)
81 {
82  if (reUse)
83  {
84  if (A.lowerPtr_)
85  {
86  lowerPtr_ = A.lowerPtr_;
87  A.lowerPtr_ = NULL;
88  }
89 
90  if (A.diagPtr_)
91  {
92  diagPtr_ = A.diagPtr_;
93  A.diagPtr_ = NULL;
94  }
95 
96  if (A.upperPtr_)
97  {
98  upperPtr_ = A.upperPtr_;
99  A.upperPtr_ = NULL;
100  }
101  }
102  else
103  {
104  if (A.lowerPtr_)
105  {
106  lowerPtr_ = new scalarField(*(A.lowerPtr_));
107  }
108 
109  if (A.diagPtr_)
110  {
111  diagPtr_ = new scalarField(*(A.diagPtr_));
112  }
113 
114  if (A.upperPtr_)
115  {
116  upperPtr_ = new scalarField(*(A.upperPtr_));
117  }
118  }
119 }
120 
121 
123 (
124  const lduMesh& mesh,
125  Istream& is
126 )
127 :
128  lduMesh_(mesh),
129  lowerPtr_(new scalarField(is)),
130  diagPtr_(new scalarField(is)),
131  upperPtr_(new scalarField(is))
132 {}
133 
134 
136 {
137  if (lowerPtr_)
138  {
139  delete lowerPtr_;
140  }
141 
142  if (diagPtr_)
143  {
144  delete diagPtr_;
145  }
146 
147  if (upperPtr_)
148  {
149  delete upperPtr_;
150  }
151 }
152 
153 
155 {
156  if (!lowerPtr_)
157  {
158  if (upperPtr_)
159  {
160  lowerPtr_ = new scalarField(*upperPtr_);
161  }
162  else
163  {
164  lowerPtr_ = new scalarField(lduAddr().lowerAddr().size(), 0.0);
165  }
166  }
167 
168  return *lowerPtr_;
169 }
170 
171 
173 {
174  if (!diagPtr_)
175  {
176  diagPtr_ = new scalarField(lduAddr().size(), 0.0);
177  }
178 
179  return *diagPtr_;
180 }
181 
182 
184 {
185  if (!upperPtr_)
186  {
187  if (lowerPtr_)
188  {
189  upperPtr_ = new scalarField(*lowerPtr_);
190  }
191  else
192  {
193  upperPtr_ = new scalarField(lduAddr().lowerAddr().size(), 0.0);
194  }
195  }
196 
197  return *upperPtr_;
198 }
199 
200 
202 {
203  if (!lowerPtr_ && !upperPtr_)
204  {
205  FatalErrorIn("lduMatrix::lower() const")
206  << "lowerPtr_ or upperPtr_ unallocated"
207  << abort(FatalError);
208  }
209 
210  if (lowerPtr_)
211  {
212  return *lowerPtr_;
213  }
214  else
215  {
216  return *upperPtr_;
217  }
218 }
219 
220 
222 {
223  if (!diagPtr_)
224  {
225  FatalErrorIn("const scalarField& lduMatrix::diag() const")
226  << "diagPtr_ unallocated"
227  << abort(FatalError);
228  }
229 
230  return *diagPtr_;
231 }
232 
233 
235 {
236  if (!lowerPtr_ && !upperPtr_)
237  {
238  FatalErrorIn("lduMatrix::upper() const")
239  << "lowerPtr_ or upperPtr_ unallocated"
240  << abort(FatalError);
241  }
242 
243  if (upperPtr_)
244  {
245  return *upperPtr_;
246  }
247  else
248  {
249  return *lowerPtr_;
250  }
251 }
252 
253 
254 // * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
255 
257 {
258  if (ldum.lowerPtr_)
259  {
260  os << "Lower triangle = "
261  << *ldum.lowerPtr_
262  << endl << endl;
263  }
264 
265  if (ldum.diagPtr_)
266  {
267  os << "diagonal = "
268  << *ldum.diagPtr_
269  << endl << endl;
270  }
271 
272  if (ldum.upperPtr_)
273  {
274  os << "Upper triangle = "
275  << *ldum.upperPtr_
276  << endl << endl;
277  }
278 
279  os.check("Ostream& operator<<(Ostream&, const lduMatrix&");
280 
281  return os;
282 }
283 
284 
285 // ************************ vim: set sw=4 sts=4 et: ************************ //