34 template<
class ParcelType>
39 template<
class ParcelType>
42 sizeof(SprayParcel<ParcelType>) -
sizeof(ParcelType)
48 template<
class ParcelType>
74 if (is.
format() == IOstream::ASCII)
96 readRawScalar(is, &d0_);
97 readRawScalar(is, position0_.data(), vector::nComponents);
98 readRawScalar(is, &sigma_);
99 readRawScalar(is, &mu_);
100 readRawScalar(is, &liquidCore_);
101 readRawScalar(is, &KHindex_);
102 readRawScalar(is, &y_);
103 readRawScalar(is, &yDot_);
104 readRawScalar(is, &tc_);
105 readRawScalar(is, &ms_);
106 readRawScalar(is, &injector_);
107 readRawScalar(is, &tMom_);
108 readRawScalar(is, &user_);
114 is.
read(
reinterpret_cast<char*
>(&d0_), sizeofFields);
122 template<
class ParcelType>
123 template<
class CloudType>
130 template<
class ParcelType>
131 template<
class CloudType,
class CompositionType>
135 const CompositionType& compModel
138 const bool valid =
c.size();
143 c.checkFieldIOobject(
c, d0);
147 c.fieldIOobject(
"position0", IOobject::MUST_READ),
150 c.checkFieldIOobject(
c, position0);
153 c.checkFieldIOobject(
c,
sigma);
156 c.checkFieldIOobject(
c,
mu);
160 c.fieldIOobject(
"liquidCore", IOobject::MUST_READ),
163 c.checkFieldIOobject(
c, liquidCore);
167 c.fieldIOobject(
"KHindex", IOobject::MUST_READ),
170 c.checkFieldIOobject(
c, KHindex);
174 c.fieldIOobject(
"y", IOobject::MUST_READ),
177 c.checkFieldIOobject(
c,
y);
181 c.fieldIOobject(
"yDot", IOobject::MUST_READ),
184 c.checkFieldIOobject(
c, yDot);
188 c.fieldIOobject(
"tc", IOobject::MUST_READ),
191 c.checkFieldIOobject(
c, tc);
195 c.fieldIOobject(
"ms", IOobject::MUST_READ),
198 c.checkFieldIOobject(
c, ms);
202 c.fieldIOobject(
"injector", IOobject::MUST_READ),
205 c.checkFieldIOobject(
c, injector);
209 c.fieldIOobject(
"tMom", IOobject::MUST_READ),
212 c.checkFieldIOobject(
c, tMom);
216 c.fieldIOobject(
"user", IOobject::MUST_READ),
219 c.checkFieldIOobject(
c, user);
225 p.position0_ = position0[i];
228 p.liquidCore_ = liquidCore[i];
229 p.KHindex_ = KHindex[i];
234 p.injector_ = injector[i];
243 template<
class ParcelType>
244 template<
class CloudType>
251 template<
class ParcelType>
252 template<
class CloudType,
class CompositionType>
256 const CompositionType& compModel
261 const label np =
c.size();
262 const bool valid = np;
268 c.fieldIOobject(
"position0", IOobject::NO_READ),
275 c.fieldIOobject(
"liquidCore", IOobject::NO_READ),
285 c.fieldIOobject(
"injector", IOobject::NO_READ),
295 position0[i] =
p.position0_;
298 liquidCore[i] =
p.liquidCore_;
299 KHindex[i] =
p.KHindex_;
304 injector[i] =
p.injector_;
311 position0.write(valid);
314 liquidCore.write(valid);
315 KHindex.write(valid);
320 injector.write(valid);
326 template<
class ParcelType>
335 ParcelType::writeProperties(os, filters, delim, namesOnly);
338 #define writeProp(Name, Value) \
339 ParcelType::writeProperty(os, Name, Value, namesOnly, delim, filters)
359 template<
class ParcelType>
360 template<
class CloudType>
367 ParcelType::readObjects(
c, obr);
371 template<
class ParcelType>
372 template<
class CloudType>
379 ParcelType::writeObjects(
c, obr);
383 template<
class ParcelType>
384 template<
class CloudType,
class CompositionType>
388 const CompositionType& compModel,
392 ParcelType::readObjects(
c, compModel, obr);
394 if (!
c.size())
return;
396 const auto& d0 = cloud::lookupIOField<scalar>(
"d0", obr);
397 const auto& position0 = cloud::lookupIOField<vector>(
"position0", obr);
398 const auto&
sigma = cloud::lookupIOField<scalar>(
"sigma", obr);
399 const auto&
mu = cloud::lookupIOField<scalar>(
"mu", obr);
400 const auto& liquidCore = cloud::lookupIOField<scalar>(
"liquidCore", obr);
401 const auto& KHindex = cloud::lookupIOField<scalar>(
"KHindex", obr);
402 const auto&
y = cloud::lookupIOField<scalar>(
"y", obr);
403 const auto& yDot = cloud::lookupIOField<scalar>(
"yDot", obr);
404 const auto& tc = cloud::lookupIOField<scalar>(
"tc", obr);
405 const auto& ms = cloud::lookupIOField<scalar>(
"ms", obr);
406 const auto& injector = cloud::lookupIOField<scalar>(
"injector", obr);
407 const auto& tMom = cloud::lookupIOField<scalar>(
"tMom", obr);
408 const auto& user = cloud::lookupIOField<scalar>(
"user", obr);
414 p.position0_ = position0[i];
417 p.liquidCore_ = liquidCore[i];
418 p.KHindex_ = KHindex[i];
423 p.injector_ = injector[i];
432 template<
class ParcelType>
433 template<
class CloudType,
class CompositionType>
437 const CompositionType& compModel,
441 ParcelType::writeObjects(
c, compModel, obr);
443 const label np =
c.size();
445 auto& d0 = cloud::createIOField<scalar>(
"d0", np, obr);
446 auto& position0 = cloud::createIOField<vector>(
"position0", np, obr);
447 auto&
sigma = cloud::createIOField<scalar>(
"sigma", np, obr);
448 auto&
mu = cloud::createIOField<scalar>(
"mu", np, obr);
449 auto& liquidCore = cloud::createIOField<scalar>(
"liquidCore", np, obr);
450 auto& KHindex = cloud::createIOField<scalar>(
"KHindex", np, obr);
451 auto&
y = cloud::createIOField<scalar>(
"y", np, obr);
452 auto& yDot= cloud::createIOField<scalar>(
"yDot", np, obr);
453 auto& tc = cloud::createIOField<scalar>(
"tc", np, obr);
454 auto& ms = cloud::createIOField<scalar>(
"ms", np, obr);
455 auto& injector = cloud::createIOField<scalar>(
"injector", np, obr);
456 auto& tMom = cloud::createIOField<scalar>(
"tMom", np, obr);
457 auto& user = cloud::createIOField<scalar>(
"user", np, obr);
463 position0[i] =
p.position0_;
466 liquidCore[i] =
p.liquidCore_;
467 KHindex[i] =
p.KHindex_;
472 injector[i] =
p.injector_;
483 template<
class ParcelType>
490 if (os.format() == IOstream::ASCII)
492 os << static_cast<const ParcelType&>(
p)
493 << token::SPACE <<
p.d0()
494 << token::SPACE <<
p.position0()
495 << token::SPACE <<
p.sigma()
496 << token::SPACE <<
p.mu()
497 << token::SPACE <<
p.liquidCore()
498 << token::SPACE <<
p.KHindex()
499 << token::SPACE <<
p.y()
500 << token::SPACE <<
p.yDot()
501 << token::SPACE <<
p.tc()
502 << token::SPACE <<
p.ms()
503 << token::SPACE <<
p.injector()
504 << token::SPACE <<
p.tMom()
505 << token::SPACE <<
p.user();
509 os << static_cast<const ParcelType&>(
p);
512 reinterpret_cast<const char*
>(&
p.d0_),
513 SprayParcel<ParcelType>::sizeofFields