FreeFOAM The Cross-Platform CFD Toolkit
parcelIO.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 "parcel.H"
27 #include <OpenFOAM/IOstreams.H>
28 
29 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
30 
32 (
33  const Cloud<parcel>& cloud,
34  Istream& is,
35  bool readFields
36 )
37 :
38  Particle<parcel>(cloud, is, readFields),
39 
40  liquidComponents_
41  (
42  (cloud.pMesh().lookupObject<dictionary>("thermophysicalProperties"))
43  .lookup("liquidComponents")
44  ),
45  X_(liquidComponents_.size(), 0.0),
46 
47  tMom_(GREAT)
48 {
49 
50  label nX = X_.size();
51 
52  if (readFields)
53  {
54  if (is.format() == IOstream::ASCII)
55  {
56  d_ = readScalar(is);
57  T_ = readScalar(is);
58  m_ = readScalar(is);
59  y_ = readScalar(is);
60  yDot_ = readScalar(is);
61  ct_ = readScalar(is);
62  ms_ = readScalar(is);
63  tTurb_ = readScalar(is);
64  liquidCore_ = readScalar(is);
65  injector_ = readScalar(is);
66  is >> U_;
67  is >> Uturb_;
68  is >> n_;
69  for (label j=0; j<nX; j++)
70  {
71  X_[j] = readScalar(is);
72  }
73  }
74  else
75  {
76  is.read
77  (
78  reinterpret_cast<char*>(&d_),
79  sizeof(d_) + sizeof(T_) + sizeof(m_) + sizeof(y_)
80  + sizeof(yDot_) + sizeof(ct_) + sizeof(ms_) + sizeof(tTurb_)
81  + sizeof(liquidCore_) + sizeof(injector_)
82  + sizeof(U_) + sizeof(Uturb_) + sizeof(n_)
83  );
84 
85  is.read
86  (
87  reinterpret_cast<char*>(X_.begin()),
88  X_.size()*sizeof(scalar)
89  );
90  }
91  }
92 
93  // Check state of Istream
94  is.check("parcel::parcel(Istream&)");
95 }
96 
97 
99 (
100  Cloud<parcel>& c
101 )
102 {
103  if (!c.size())
104  {
105  return;
106  }
107 
109 
110  IOField<scalar> d(c.fieldIOobject("d", IOobject::MUST_READ));
111  c.checkFieldIOobject(c, d);
112 
113  IOField<scalar> T(c.fieldIOobject("T", IOobject::MUST_READ));
114  c.checkFieldIOobject(c, T);
115 
116  IOField<scalar> m(c.fieldIOobject("m", IOobject::MUST_READ));
117  c.checkFieldIOobject(c, m);
118 
119  IOField<scalar> y(c.fieldIOobject("y", IOobject::MUST_READ));
120  c.checkFieldIOobject(c, y);
121 
122  IOField<scalar> yDot(c.fieldIOobject("yDot", IOobject::MUST_READ));
123  c.checkFieldIOobject(c, yDot);
124 
125  IOField<scalar> ct(c.fieldIOobject("ct", IOobject::MUST_READ));
126  c.checkFieldIOobject(c, ct);
127 
128  IOField<scalar> ms(c.fieldIOobject("ms", IOobject::MUST_READ));
129  c.checkFieldIOobject(c, ms);
130 
131  IOField<scalar> tTurb(c.fieldIOobject("tTurb", IOobject::MUST_READ));
132  c.checkFieldIOobject(c, tTurb);
133 
134  IOField<scalar> liquidCore
135  (
136  c.fieldIOobject("liquidCore", IOobject::MUST_READ)
137  );
138  c.checkFieldIOobject(c, liquidCore);
139 
140  IOField<scalar> injector(c.fieldIOobject("injector", IOobject::MUST_READ));
142 
143  IOField<vector> U(c.fieldIOobject("U", IOobject::MUST_READ));
144  c.checkFieldIOobject(c, U);
145 
146  IOField<vector> Uturb(c.fieldIOobject("Uturb", IOobject::MUST_READ));
147  c.checkFieldIOobject(c, Uturb);
148 
149  IOField<vector> n(c.fieldIOobject("n", IOobject::MUST_READ));
150  c.checkFieldIOobject(c, n);
151 
152  label i = 0;
153  forAllIter(Cloud<parcel>, c, iter)
154  {
155  parcel& p = iter();
156 
157  p.d_ = d[i];
158  p.T_ = T[i];
159  p.m_ = m[i];
160  p.y_ = y[i];
161  p.yDot_ = yDot[i];
162  p.ct_ = ct[i];
163  p.ms_ = ms[i];
164  p.tTurb_ = tTurb[i];
165  p.liquidCore_ = liquidCore[i];
166  p.injector_ = injector[i];
167 
168  p.U_ = U[i];
169  p.Uturb_ = Uturb[i];
170  p.n_ = n[i];
171 
172  i++;
173  }
174 
175  // read the liquid molar fractions
176  if (c.size())
177  {
179  const parcel& p0 = iter();
180 
181  label nX = p0.X().size();
182  const List<word>& names = p0.liquidNames();
183 
184  for (label j=0; j<nX; j++)
185  {
186  IOField<scalar> X(c.fieldIOobject(names[j], IOobject::MUST_READ));
187 
188  label i = 0;
189  forAllIter(Cloud<parcel>, c, iter)
190  {
191  parcel& p = iter();
192  p.X_[j] = X[i++];
193  }
194  }
195  }
196 }
197 
198 
200 (
201  const Cloud<parcel>& c
202 )
203 {
205 
206  label np = c.size();
207 
208  IOField<scalar> d(c.fieldIOobject("d", IOobject::NO_READ), np);
209  IOField<scalar> T(c.fieldIOobject("T", IOobject::NO_READ), np);
210  IOField<scalar> m(c.fieldIOobject("m", IOobject::NO_READ), np);
211  IOField<scalar> y(c.fieldIOobject("y", IOobject::NO_READ), np);
212  IOField<scalar> yDot(c.fieldIOobject("yDot", IOobject::NO_READ), np);
213  IOField<scalar> ct(c.fieldIOobject("ct", IOobject::NO_READ), np);
214  IOField<scalar> ms(c.fieldIOobject("ms", IOobject::NO_READ), np);
215  IOField<scalar> tTurb(c.fieldIOobject("tTurb", IOobject::NO_READ), np);
216  IOField<scalar> liquidCore
217  (
218  c.fieldIOobject("liquidCore", IOobject::NO_READ),
219  np
220  );
222  (
223  c.fieldIOobject("injector", IOobject::NO_READ),
224  np
225  );
226  IOField<vector> U(c.fieldIOobject("U", IOobject::NO_READ), np);
227  IOField<vector> Uturb(c.fieldIOobject("Uturb", IOobject::NO_READ), np);
228  IOField<vector> n(c.fieldIOobject("n", IOobject::NO_READ), np);
229 
230  label i = 0;
232  {
233  const parcel& p = iter();
234 
235  d[i] = p.d_;
236  T[i] = p.T_;
237  m[i] = p.m_;
238  y[i] = p.y_;
239  yDot[i] = p.yDot_;
240  ct[i] = p.ct_;
241  ms[i] = p.ms_;
242  tTurb[i] = p.tTurb_;
243  liquidCore[i] = p.liquidCore_;
244  injector[i] = p.injector_;
245 
246  U[i] = p.U_;
247  Uturb[i] = p.Uturb_;
248  n[i] = p.n_;
249 
250  i++;
251  }
252 
253  d.write();
254  T.write();
255  m.write();
256  y.write();
257  yDot.write();
258  ct.write();
259  ms.write();
260  tTurb.write();
261  liquidCore.write();
262  injector.write();
263 
264  U.write();
265  Uturb.write();
266  n.write();
267 
268  // write the liquid molar fractions
269  if (np > 0)
270  {
272  const parcel& p0 = iter();
273 
274  label nX = p0.X().size();
275  const List<word>& names = p0.liquidNames();
276 
277  for (label j=0; j<nX; j++)
278  {
279  IOField<scalar> X(c.fieldIOobject(names[j], IOobject::NO_READ), np);
280 
281  label i = 0;
283  {
284  const parcel& p = iter();
285  X[i++] = p.X()[j];
286  }
287 
288  X.write();
289  }
290  }
291 }
292 
293 
294 // * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
295 
297 {
298 
299  if (os.format() == IOstream::ASCII)
300  {
301  os << static_cast<const Particle<parcel>&>(p)
302  << token::SPACE << p.d_
303  << token::SPACE << p.T_
304  << token::SPACE << p.m_
305  << token::SPACE << p.y_
306  << token::SPACE << p.yDot_
307  << token::SPACE << p.ct_
308  << token::SPACE << p.ms_
309  << token::SPACE << p.tTurb_
310  << token::SPACE << p.liquidCore_
311  << token::SPACE << p.injector_
312  << token::SPACE << p.U_
313  << token::SPACE << p.Uturb_
314  << token::SPACE << p.n_
315  << token::SPACE << p.X_;
316  }
317  else
318  {
319  os << static_cast<const Particle<parcel>&>(p);
320  os.write
321  (
322  reinterpret_cast<const char*>(&p.d_),
323  sizeof(p.d_) + sizeof(p.T_) + sizeof(p.m_) + sizeof(p.y_)
324  + sizeof(p.yDot_) + sizeof(p.ct_) + sizeof(p.ms_) + sizeof(p.tTurb_)
325  + sizeof(p.liquidCore_) + sizeof(p.injector_)
326  + sizeof(p.U_) + sizeof(p.Uturb_) + sizeof(p.n_)
327  );
328 
329  os.write
330  (
331  reinterpret_cast<const char*>(p.X_.begin()),
332  p.X_.size()*sizeof(scalar)
333  );
334  }
335 
336  // Check state of Ostream
337  os.check("Ostream& operator<<(Ostream&, const parcel&)");
338 
339  return os;
340 }
341 
342 
343 // ************************ vim: set sw=4 sts=4 et: ************************ //