KinematicCloudI.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | www.openfoam.com
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8  Copyright (C) 2011-2017 OpenFOAM Foundation
9  Copyright (C) 2019-2020 OpenCFD Ltd.
10 -------------------------------------------------------------------------------
11 License
12  This file is part of OpenFOAM.
13 
14  OpenFOAM is free software: you can redistribute it and/or modify it
15  under the terms of the GNU General Public License as published by
16  the Free Software Foundation, either version 3 of the License, or
17  (at your option) any later version.
18 
19  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
20  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22  for more details.
23 
24  You should have received a copy of the GNU General Public License
25  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
26 
27 \*---------------------------------------------------------------------------*/
28 
29 #include "fvmSup.H"
30 
31 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
32 
33 template<class CloudType>
34 inline const Foam::KinematicCloud<CloudType>&
35 Foam::KinematicCloud<CloudType>::cloudCopy() const
36 {
37  return *cloudCopyPtr_;
38 }
39 
40 
41 template<class CloudType>
42 inline const Foam::fvMesh& Foam::KinematicCloud<CloudType>::mesh() const
43 {
44  return mesh_;
45 }
46 
47 
48 template<class CloudType>
49 inline const Foam::IOdictionary&
50 Foam::KinematicCloud<CloudType>::particleProperties() const
51 {
52  return particleProperties_;
53 }
54 
55 
56 template<class CloudType>
57 inline const Foam::IOdictionary&
58 Foam::KinematicCloud<CloudType>::outputProperties() const
59 {
60  return outputProperties_;
61 }
62 
63 
64 template<class CloudType>
65 inline Foam::IOdictionary& Foam::KinematicCloud<CloudType>::outputProperties()
66 {
67  return outputProperties_;
68 }
69 
70 
71 template<class CloudType>
72 inline const Foam::cloudSolution&
73 Foam::KinematicCloud<CloudType>::solution() const
74 {
75  return solution_;
76 }
77 
78 
79 template<class CloudType>
80 inline Foam::cloudSolution& Foam::KinematicCloud<CloudType>::solution()
81 {
82  return solution_;
83 }
84 
85 
86 template<class CloudType>
87 inline const typename CloudType::particleType::constantProperties&
88 Foam::KinematicCloud<CloudType>::constProps() const
89 {
90  return constProps_;
91 }
92 
93 
94 template<class CloudType>
95 inline typename CloudType::particleType::constantProperties&
96 Foam::KinematicCloud<CloudType>::constProps()
97 {
98  return constProps_;
99 }
100 
101 
102 template<class CloudType>
103 inline const Foam::dictionary&
104 Foam::KinematicCloud<CloudType>::subModelProperties() const
105 {
106  return subModelProperties_;
107 }
108 
109 
110 template<class CloudType>
111 inline const Foam::volScalarField& Foam::KinematicCloud<CloudType>::rho() const
112 {
113  return rho_;
114 }
115 
116 
117 template<class CloudType>
118 inline const Foam::volVectorField& Foam::KinematicCloud<CloudType>::U() const
119 {
120  return U_;
121 }
122 
123 
124 template<class CloudType>
125 inline const Foam::volScalarField& Foam::KinematicCloud<CloudType>::mu() const
126 {
127  return mu_;
128 }
129 
130 
131 template<class CloudType>
132 inline const Foam::dimensionedVector& Foam::KinematicCloud<CloudType>::g() const
133 {
134  return g_;
135 }
136 
137 
138 template<class CloudType>
139 inline Foam::scalar Foam::KinematicCloud<CloudType>::pAmbient() const
140 {
141  return pAmbient_;
142 }
143 
144 
145 template<class CloudType>
146 inline Foam::scalar& Foam::KinematicCloud<CloudType>::pAmbient()
147 {
148  return pAmbient_;
149 }
150 
151 
152 template<class CloudType>
153 //inline const typename CloudType::parcelType::forceType&
154 inline const typename Foam::KinematicCloud<CloudType>::forceType&
155 Foam::KinematicCloud<CloudType>::forces() const
156 {
157  return forces_;
158 }
159 
160 
161 template<class CloudType>
162 inline typename Foam::KinematicCloud<CloudType>::forceType&
163 Foam::KinematicCloud<CloudType>::forces()
164 {
165  return forces_;
166 }
167 
168 
169 template<class CloudType>
170 inline typename Foam::KinematicCloud<CloudType>::functionType&
171 Foam::KinematicCloud<CloudType>::functions()
172 {
173  return functions_;
174 }
175 
176 
177 template<class CloudType>
178 inline const Foam::InjectionModelList<Foam::KinematicCloud<CloudType>>&
179 Foam::KinematicCloud<CloudType>::injectors() const
180 {
181  return injectors_;
182 }
183 
184 
185 template<class CloudType>
186 inline Foam::InjectionModelList<Foam::KinematicCloud<CloudType>>&
187 Foam::KinematicCloud<CloudType>::injectors()
188 {
189  return injectors_;
190 }
191 
192 
193 template<class CloudType>
194 inline const Foam::DispersionModel<Foam::KinematicCloud<CloudType>>&
195 Foam::KinematicCloud<CloudType>::dispersion() const
196 {
197  return *dispersionModel_;
198 }
199 
200 
201 template<class CloudType>
202 inline Foam::DispersionModel<Foam::KinematicCloud<CloudType>>&
203 Foam::KinematicCloud<CloudType>::dispersion()
204 {
205  return *dispersionModel_;
206 }
207 
208 
209 template<class CloudType>
210 inline const Foam::PatchInteractionModel<Foam::KinematicCloud<CloudType>>&
211 Foam::KinematicCloud<CloudType>::patchInteraction() const
212 {
213  return *patchInteractionModel_;
214 }
215 
216 
217 template<class CloudType>
218 inline Foam::PatchInteractionModel<Foam::KinematicCloud<CloudType>>&
219 Foam::KinematicCloud<CloudType>::patchInteraction()
220 {
221  return *patchInteractionModel_;
222 }
223 
224 
225 template<class CloudType>
226 inline const Foam::StochasticCollisionModel<Foam::KinematicCloud<CloudType>>&
227 Foam::KinematicCloud<CloudType>::stochasticCollision() const
228 {
229  return *stochasticCollisionModel_;
230 }
231 
232 
233 template<class CloudType>
234 inline Foam::StochasticCollisionModel<Foam::KinematicCloud<CloudType>>&
235 Foam::KinematicCloud<CloudType>::stochasticCollision()
236 {
237  return *stochasticCollisionModel_;
238 }
239 
240 
241 template<class CloudType>
242 inline const Foam::SurfaceFilmModel<Foam::KinematicCloud<CloudType>>&
243 Foam::KinematicCloud<CloudType>::surfaceFilm() const
244 {
245  return *surfaceFilmModel_;
246 }
247 
248 
249 template<class CloudType>
250 inline Foam::SurfaceFilmModel<Foam::KinematicCloud<CloudType>>&
251 Foam::KinematicCloud<CloudType>::surfaceFilm()
252 {
253  return *surfaceFilmModel_;
254 }
255 
256 
257 template<class CloudType>
258 inline const Foam::PackingModel<Foam::KinematicCloud<CloudType>>&
259 Foam::KinematicCloud<CloudType>::packingModel() const
260 {
261  return *packingModel_;
262 }
263 
264 
265 template<class CloudType>
266 inline Foam::PackingModel<Foam::KinematicCloud<CloudType>>&
267 Foam::KinematicCloud<CloudType>::packingModel()
268 {
269  return *packingModel_;
270 }
271 
272 
273 template<class CloudType>
274 inline const Foam::DampingModel<Foam::KinematicCloud<CloudType>>&
275 Foam::KinematicCloud<CloudType>::dampingModel() const
276 {
277  return *dampingModel_;
278 }
279 
280 
281 template<class CloudType>
282 inline Foam::DampingModel<Foam::KinematicCloud<CloudType>>&
283 Foam::KinematicCloud<CloudType>::dampingModel()
284 {
285  return *dampingModel_;
286 }
287 
288 
289 template<class CloudType>
290 inline const Foam::IsotropyModel<Foam::KinematicCloud<CloudType>>&
291 Foam::KinematicCloud<CloudType>::isotropyModel() const
292 {
293  return *isotropyModel_;
294 }
295 
296 
297 template<class CloudType>
298 inline Foam::IsotropyModel<Foam::KinematicCloud<CloudType>>&
299 Foam::KinematicCloud<CloudType>::isotropyModel()
300 {
301  return *isotropyModel_;
302 }
303 
304 
305 template<class CloudType>
306 inline const Foam::integrationScheme&
307 Foam::KinematicCloud<CloudType>::UIntegrator() const
308 {
309  return *UIntegrator_;
310 }
311 
312 
313 template<class CloudType>
314 inline Foam::scalar Foam::KinematicCloud<CloudType>::massInSystem() const
315 {
316  scalar sysMass = 0.0;
317  for (const parcelType& p : *this)
318  {
319  sysMass += p.nParticle()*p.mass();
320  }
321 
322  return sysMass;
323 }
324 
325 
326 template<class CloudType>
327 inline Foam::vector
328 Foam::KinematicCloud<CloudType>::linearMomentumOfSystem() const
329 {
330  vector linearMomentum(Zero);
331 
332  for (const parcelType& p : *this)
333  {
334  linearMomentum += p.nParticle()*p.mass()*p.U();
335  }
336 
337  return linearMomentum;
338 }
339 
340 
341 template<class CloudType>
342 inline Foam::scalar
343 Foam::KinematicCloud<CloudType>::totalParticlePerParcel() const
344 {
345  scalar parPerParcel = 0;
346 
347  for (const parcelType& p : *this)
348  {
349  parPerParcel += p.nParticle();
350  }
351 
352  return parPerParcel;
353 }
354 
355 
356 template<class CloudType>
357 inline Foam::scalar
358 Foam::KinematicCloud<CloudType>::linearKineticEnergyOfSystem() const
359 {
360  scalar linearKineticEnergy = 0;
361 
362  for (const parcelType& p : *this)
363  {
364  linearKineticEnergy += p.nParticle()*0.5*p.mass()*(p.U() & p.U());
365  }
366 
367  return linearKineticEnergy;
368 }
369 
370 
371 template<class CloudType>
372 inline Foam::scalar Foam::KinematicCloud<CloudType>::Dij
373 (
374  const label i,
375  const label j
376 ) const
377 {
378  scalar si = 0.0;
379  scalar sj = 0.0;
380  for (const parcelType& p : *this)
381  {
382  si += p.nParticle()*pow(p.d(), i);
383  sj += p.nParticle()*pow(p.d(), j);
384  }
385 
386  reduce(si, sumOp<scalar>());
387  reduce(sj, sumOp<scalar>());
388  sj = max(sj, VSMALL);
389 
390  return si/sj;
391 }
392 
393 
394 template<class CloudType>
395 inline Foam::scalar Foam::KinematicCloud<CloudType>::Dmax() const
396 {
397  scalar d = -GREAT;
398  for (const parcelType& p : *this)
399  {
400  d = max(d, p.d());
401  }
402 
403  reduce(d, maxOp<scalar>());
404 
405  return max(0.0, d);
406 }
407 
408 
409 template<class CloudType>
410 inline Foam::Random& Foam::KinematicCloud<CloudType>::rndGen() const
411 {
412  return rndGen_;
413 }
414 
415 
416 template<class CloudType>
417 inline Foam::List<Foam::DynamicList<typename CloudType::particleType*>>&
418 Foam::KinematicCloud<CloudType>::cellOccupancy()
419 {
420  if (!cellOccupancyPtr_)
421  {
422  buildCellOccupancy();
423  }
424 
425  return *cellOccupancyPtr_;
426 }
427 
428 
429 template<class CloudType>
430 inline const Foam::scalarField&
431 Foam::KinematicCloud<CloudType>::cellLengthScale() const
432 {
433  return cellLengthScale_;
434 }
435 
436 
437 template<class CloudType>
438 inline Foam::DimensionedField<Foam::vector, Foam::volMesh>&
439 Foam::KinematicCloud<CloudType>::UTrans()
440 {
441  return *UTrans_;
442 }
443 
444 
445 template<class CloudType>
446 inline const Foam::DimensionedField<Foam::vector, Foam::volMesh>&
447 Foam::KinematicCloud<CloudType>::UTrans() const
448 {
449  return *UTrans_;
450 }
451 
452 
453 template<class CloudType>
454 inline Foam::DimensionedField<Foam::scalar, Foam::volMesh>&
455 Foam::KinematicCloud<CloudType>::UCoeff()
456 {
457  return *UCoeff_;
458 }
459 
460 
461 template<class CloudType>
462 inline const Foam::DimensionedField<Foam::scalar, Foam::volMesh>&
463 Foam::KinematicCloud<CloudType>::UCoeff() const
464 {
465  return *UCoeff_;
466 }
467 
468 
469 template<class CloudType>
470 inline Foam::tmp<Foam::fvVectorMatrix>
471 Foam::KinematicCloud<CloudType>::SU(volVectorField& U, bool incompressible)
472 const
473 {
474  if (debug)
475  {
476  Pout<< "UTrans min/max = " << min(UTrans()).value() << ", "
477  << max(UTrans()).value() << nl
478  << "UCoeff min/max = " << min(UCoeff()).value() << ", "
479  << max(UCoeff()).value() << endl;
480  }
481 
482  dimensionSet dim(dimForce);
483  if (incompressible)
484  {
485  dim.reset(dimForce/dimDensity);
486  }
487 
488  if (solution_.coupled())
489  {
490  if (solution_.semiImplicit("U"))
491  {
492  volScalarField::Internal
493  Vdt(mesh_.V()*this->db().time().deltaT());
494 
495  if (incompressible)
496  {
497  Vdt.dimensions() *= dimDensity;
498  }
499 
500  return UTrans()/Vdt - fvm::Sp(UCoeff()/Vdt, U) + UCoeff()/Vdt*U;
501  }
502  else
503  {
504  tmp<fvVectorMatrix> tfvm(new fvVectorMatrix(U, dim));
505  fvVectorMatrix& fvm = tfvm.ref();
506 
507  fvm.source() = -UTrans()/(this->db().time().deltaT());
508 
509  return tfvm;
510  }
511  }
512 
513  return tmp<fvVectorMatrix>::New(U, dim);
514 }
515 
516 
517 template<class CloudType>
518 inline const Foam::tmp<Foam::volScalarField>
519 Foam::KinematicCloud<CloudType>::vDotSweep() const
520 {
521  tmp<volScalarField> tvDotSweep
522  (
523  new volScalarField
524  (
525  IOobject
526  (
527  this->name() + ":vDotSweep",
528  this->db().time().timeName(),
529  this->db(),
530  IOobject::NO_READ,
531  IOobject::NO_WRITE,
532  false
533  ),
534  mesh_,
535  dimensionedScalar(dimless/dimTime, Zero),
536  extrapolatedCalculatedFvPatchScalarField::typeName
537  )
538  );
539 
540  volScalarField& vDotSweep = tvDotSweep.ref();
541  for (const parcelType& p : *this)
542  {
543  const label celli = p.cell();
544 
545  vDotSweep[celli] += p.nParticle()*p.areaP()*mag(p.U() - U_[celli]);
546  }
547 
548  vDotSweep.primitiveFieldRef() /= mesh_.V();
549  vDotSweep.correctBoundaryConditions();
550 
551  return tvDotSweep;
552 }
553 
554 
555 template<class CloudType>
556 inline const Foam::tmp<Foam::volScalarField>
557 Foam::KinematicCloud<CloudType>::theta() const
558 {
559  tmp<volScalarField> ttheta
560  (
561  new volScalarField
562  (
563  IOobject
564  (
565  this->name() + ":theta",
566  this->db().time().timeName(),
567  this->db(),
568  IOobject::NO_READ,
569  IOobject::NO_WRITE,
570  false
571  ),
572  mesh_,
573  dimensionedScalar(dimless, Zero),
574  extrapolatedCalculatedFvPatchScalarField::typeName
575  )
576  );
577 
578  volScalarField& theta = ttheta.ref();
579  for (const parcelType& p : *this)
580  {
581  const label celli = p.cell();
582 
583  theta[celli] += p.nParticle()*p.volume();
584  }
585 
586  theta.primitiveFieldRef() /= mesh_.V();
587  theta.correctBoundaryConditions();
588 
589  return ttheta;
590 }
591 
592 
593 template<class CloudType>
594 inline const Foam::tmp<Foam::volScalarField>
595 Foam::KinematicCloud<CloudType>::alpha() const
596 {
597  tmp<volScalarField> talpha
598  (
599  new volScalarField
600  (
601  IOobject
602  (
603  this->name() + ":alpha",
604  this->db().time().timeName(),
605  this->db(),
606  IOobject::NO_READ,
607  IOobject::NO_WRITE,
608  false
609  ),
610  mesh_,
611  dimensionedScalar(dimless, Zero)
612  )
613  );
614 
615  scalarField& alpha = talpha.ref().primitiveFieldRef();
616  for (const parcelType& p : *this)
617  {
618  const label celli = p.cell();
619 
620  alpha[celli] += p.nParticle()*p.mass();
621  }
622 
623  alpha /= (mesh_.V()*rho_);
624 
625  return talpha;
626 }
627 
628 
629 template<class CloudType>
630 inline const Foam::tmp<Foam::volScalarField>
631 Foam::KinematicCloud<CloudType>::rhoEff() const
632 {
633  tmp<volScalarField> trhoEff
634  (
635  new volScalarField
636  (
637  IOobject
638  (
639  this->name() + ":rhoEff",
640  this->db().time().timeName(),
641  this->db(),
642  IOobject::NO_READ,
643  IOobject::NO_WRITE,
644  false
645  ),
646  mesh_,
647  dimensionedScalar(dimDensity, Zero)
648  )
649  );
650 
651  scalarField& rhoEff = trhoEff.ref().primitiveFieldRef();
652  for (const parcelType& p : *this)
653  {
654  const label celli = p.cell();
655 
656  rhoEff[celli] += p.nParticle()*p.mass();
657  }
658 
659  rhoEff /= mesh_.V();
660 
661  return trhoEff;
662 }
663 
664 
665 // ************************************************************************* //
Foam::expressions::patchExpr::debug
int debug
Static debugging option.
Foam::IOdictionary
IOdictionary is derived from dictionary and IOobject to give the dictionary automatic IO functionalit...
Definition: IOdictionary.H:54
Foam::KinematicCloud::SU
tmp< fvVectorMatrix > SU(volVectorField &U, bool incompressible=false) const
Return tmp momentum source term (compressible)
Definition: KinematicCloudI.H:471
Foam::KinematicCloud::dispersion
const DispersionModel< KinematicCloud< CloudType > > & dispersion() const
Return const-access to the dispersion model.
Definition: KinematicCloudI.H:195
Foam::Random
Random number generator.
Definition: Random.H:59
Foam::maxOp
Definition: ops.H:223
Foam::IOobject
Defines the attributes of an object for which implicit objectRegistry management is supported,...
Definition: IOobject.H:169
Foam::KinematicCloud::UIntegrator
const integrationScheme & UIntegrator() const
Return reference to velocity integration.
Definition: KinematicCloudI.H:307
p
volScalarField & p
Definition: createFieldRefs.H:8
Foam::KinematicCloud::outputProperties
const IOdictionary & outputProperties() const
Return output properties dictionary.
Definition: KinematicCloudI.H:58
Foam::KinematicCloud::functions
functionType & functions()
Optional cloud function objects.
Definition: KinematicCloudI.H:171
Foam::KinematicCloud::pAmbient
scalar pAmbient() const
Return const-access to the ambient pressure.
Definition: KinematicCloudI.H:139
Foam::tmp
A class for managing temporary objects.
Definition: PtrList.H:61
Foam::DispersionModel
Base class for dispersion modelling.
Definition: KinematicCloud.H:86
Foam::Zero
static constexpr const zero Zero
Global zero (0)
Definition: zero.H:131
Foam::dimDensity
const dimensionSet dimDensity
Foam::KinematicCloud::totalParticlePerParcel
scalar totalParticlePerParcel() const
Average particle per parcel.
Definition: KinematicCloudI.H:343
Foam::KinematicCloud::mesh
const fvMesh & mesh() const
Return reference to the mesh.
Definition: KinematicCloudI.H:42
Foam::constant::atomic::alpha
const dimensionedScalar alpha
Fine-structure constant: default SI units: [].
Definition: readThermalProperties.H:212
Foam::KinematicCloud::mu
const volScalarField & mu() const
Return carrier gas dynamic viscosity.
Definition: KinematicCloudI.H:125
Foam::KinematicCloud::massInSystem
scalar massInSystem() const
Total mass in system.
Definition: KinematicCloudI.H:314
Foam::KinematicCloud::rhoEff
const tmp< volScalarField > rhoEff() const
Return the particle effective density field.
Definition: KinematicCloudI.H:631
Foam::KinematicCloud::dampingModel
const DampingModel< KinematicCloud< CloudType > > & dampingModel() const
Return const access to the damping model.
Definition: KinematicCloudI.H:275
Sp
zeroField Sp
Definition: alphaSuSp.H:2
Foam::KinematicCloud::UCoeff
volScalarField::Internal & UCoeff()
Return coefficient for carrier phase U equation.
Definition: KinematicCloudI.H:455
Foam::KinematicCloud::cloudCopy
const KinematicCloud & cloudCopy() const
Return a reference to the cloud copy.
Definition: KinematicCloudI.H:35
Foam::endl
Ostream & endl(Ostream &os)
Add newline and flush stream.
Definition: Ostream.H:369
Foam::KinematicCloud::UTrans
volVectorField::Internal & UTrans()
Return reference to momentum source.
Definition: KinematicCloudI.H:439
Foam::dimensionSet
Dimension set for the base types, which can be used to implement rigorous dimension checking for alge...
Definition: dimensionSet.H:108
Foam::DampingModel
Base class for collisional damping models.
Definition: KinematicCloud.H:101
Foam::Pout
prefixOSstream Pout
OSstream wrapped stdout (std::cout) with parallel prefix.
Foam::dimForce
const dimensionSet dimForce
Foam::integrationScheme
Base for a set of schemes which integrate simple ODEs which arise from semi-implcit rate expressions.
Definition: integrationScheme.H:90
Foam::min
label min(const labelHashSet &set, label minValue=labelMax)
Find the min value in labelHashSet, optionally limited by second argument.
Definition: hashSets.C:33
Foam::sumOp
Definition: ops.H:213
Foam::KinematicCloud::forces
const forceType & forces() const
Optional particle forces.
Definition: KinematicCloudI.H:155
Foam::KinematicCloud::stochasticCollision
const StochasticCollisionModel< KinematicCloud< CloudType > > & stochasticCollision() const
Return const-access to the stochastic collision model.
Definition: KinematicCloudI.H:227
Foam::KinematicCloud::constProps
const parcelType::constantProperties & constProps() const
Return the constant properties.
Definition: KinematicCloudI.H:88
Foam::KinematicCloud::vDotSweep
const tmp< volScalarField > vDotSweep() const
Volume swept rate of parcels per cell.
Definition: KinematicCloudI.H:519
Foam::dimTime
const dimensionSet dimTime(0, 0, 1, 0, 0, 0, 0)
Definition: dimensionSets.H:53
Foam::KinematicCloud
Templated base class for kinematic cloud.
Definition: KinematicCloud.H:112
Foam::PatchInteractionModel
Templated patch interaction model class.
Definition: KinematicCloud.H:89
Foam::tmp::ref
T & ref() const
Definition: tmpI.H:227
Foam::fvVectorMatrix
fvMatrix< vector > fvVectorMatrix
Definition: fvMatricesFwd.H:47
Foam::StochasticCollisionModel
Templated stochastic collision model class.
Definition: KinematicCloud.H:95
Foam::Field< scalar >
Foam::KinematicCloud::cellOccupancy
List< DynamicList< parcelType * > > & cellOccupancy()
Return the cell occupancy information for each.
Definition: KinematicCloudI.H:418
Foam::SurfaceFilmModel
Templated wall surface film model class.
Definition: KinematicCloud.H:92
Foam::cloudSolution
Stores all relevant solution info for cloud.
Definition: cloudSolution.H:53
Foam::CollidingParcel
Wrapper around kinematic parcel types to add collision modelling.
Definition: CollidingParcel.H:61
Foam::dimensionedScalar
dimensioned< scalar > dimensionedScalar
Dimensioned scalar obtained from generic dimensioned type.
Definition: dimensionedScalarFwd.H:42
Foam::KinematicCloud::packingModel
const PackingModel< KinematicCloud< CloudType > > & packingModel() const
Return const access to the packing model.
Definition: KinematicCloudI.H:259
Foam::pow
dimensionedScalar pow(const dimensionedScalar &ds, const dimensionedScalar &expt)
Definition: dimensionedScalar.C:75
Foam::max
label max(const labelHashSet &set, label maxValue=labelMin)
Find the max value in labelHashSet, optionally limited by second argument.
Definition: hashSets.C:47
timeName
word timeName
Definition: getTimeIndex.H:3
Foam::PackingModel
Base class for packing models.
Definition: KinematicCloud.H:98
Foam::KinematicCloud::solution
const cloudSolution & solution() const
Return const access to the solution properties.
Definition: KinematicCloudI.H:73
Foam::dictionary
A list of keyword definitions, which are a keyword followed by a number of values (eg,...
Definition: dictionary.H:123
reduce
reduce(hasMovingMesh, orOp< bool >())
Foam::dimensioned< vector >
Foam::fvMesh
Mesh data needed to do the Finite Volume discretisation.
Definition: fvMesh.H:85
Foam::DimensionedField::dimensions
const dimensionSet & dimensions() const
Return dimensions.
Definition: DimensionedFieldI.H:49
Foam::KinematicCloud::particleProperties
const IOdictionary & particleProperties() const
Return particle properties dictionary.
Definition: KinematicCloudI.H:50
fvmSup.H
Calculate the matrix for implicit and explicit sources.
Foam::CloudFunctionObjectList< KinematicCloud< CloudType > >
Foam::GeometricField::primitiveFieldRef
Internal::FieldType & primitiveFieldRef(const bool updateAccessTime=true)
Return a reference to the internal field.
Definition: GeometricField.C:766
Foam::GeometricField::correctBoundaryConditions
void correctBoundaryConditions()
Correct boundary field.
Definition: GeometricField.C:940
Foam::New
tmp< DimensionedField< TypeR, GeoMesh > > New(const tmp< DimensionedField< TypeR, GeoMesh >> &tdf1, const word &name, const dimensionSet &dimensions)
Global function forwards to reuseTmpDimensionedField::New.
Definition: DimensionedFieldReuseFunctions.H:105
Foam::KinematicCloud::rndGen
Random & rndGen() const
Return reference to the random object.
Definition: KinematicCloudI.H:410
U
U
Definition: pEqn.H:72
Foam::KinematicCloud::isotropyModel
const IsotropyModel< KinematicCloud< CloudType > > & isotropyModel() const
Return const access to the isotropy model.
Definition: KinematicCloudI.H:291
Foam::KinematicCloud::patchInteraction
const PatchInteractionModel< KinematicCloud< CloudType > > & patchInteraction() const
Return const-access to the patch interaction model.
Definition: KinematicCloudI.H:211
Foam::nl
constexpr char nl
Definition: Ostream.H:404
Foam::Vector< scalar >
Foam::List
A 1D array of objects of type <T>, where the size of the vector is known and used for subscript bound...
Definition: BitOps.H:63
Foam::KinematicCloud::g
const dimensionedVector & g() const
Gravity.
Definition: KinematicCloudI.H:132
Foam::mag
dimensioned< typename typeOfMag< Type >::type > mag(const dimensioned< Type > &dt)
Foam::fvMatrix::source
Field< Type > & source()
Definition: fvMatrix.H:445
Foam::KinematicCloud::theta
const tmp< volScalarField > theta() const
Return the particle volume fraction field.
Definition: KinematicCloudI.H:557
Foam::KinematicCloud::injectors
const InjectionModelList< KinematicCloud< CloudType > > & injectors() const
Return const access to the injection model.
Definition: KinematicCloudI.H:179
Foam::fvMatrix
A special matrix type and solver, designed for finite volume solutions of scalar equations....
Definition: fvPatchField.H:68
Foam::KinematicCloud::Dij
scalar Dij(const label i, const label j) const
Mean diameter Dij.
Definition: KinematicCloudI.H:373
Foam::name
word name(const expressions::valueTypeCode typeCode)
A word representation of a valueTypeCode. Empty for INVALID.
Definition: exprTraits.C:59
Foam::KinematicCloud::subModelProperties
const dictionary & subModelProperties() const
Return reference to the sub-models dictionary.
Definition: KinematicCloudI.H:104
Foam::IsotropyModel
Base class for collisional return-to-isotropy models.
Definition: KinematicCloud.H:104
Foam::KinematicCloud::U
const volVectorField & U() const
Return carrier gas velocity.
Definition: KinematicCloudI.H:118
Foam::KinematicCloud::linearKineticEnergyOfSystem
scalar linearKineticEnergyOfSystem() const
Total linear kinetic energy in the system.
Definition: KinematicCloudI.H:358
Foam::GeometricField< scalar, fvPatchField, volMesh >
Foam::KinematicCloud::linearMomentumOfSystem
vector linearMomentumOfSystem() const
Total linear momentum of the system.
Definition: KinematicCloudI.H:328
Foam::KinematicCloud::Dmax
scalar Dmax() const
Max diameter.
Definition: KinematicCloudI.H:395
Foam::KinematicCloud::surfaceFilm
const SurfaceFilmModel< KinematicCloud< CloudType > > & surfaceFilm() const
Return const-access to the surface film model.
Definition: KinematicCloudI.H:243
Foam::ParticleForceList< KinematicCloud< CloudType > >
Foam::dimensionSet::reset
void reset(const dimensionSet &ds)
Copy assign the exponents from the dimensionSet.
Definition: dimensionSet.C:149
Foam::InjectionModelList
List of injection models.
Definition: KinematicCloud.H:83
Foam::KinematicCloud::alpha
const tmp< volScalarField > alpha() const
Return the particle mass fraction field.
Definition: KinematicCloudI.H:595
Foam::DimensionedField
Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a...
Definition: DimensionedField.H:54
Foam::dimless
const dimensionSet dimless
Dimensionless.
Definition: dimensionSets.C:189
Foam::KinematicCloud::rho
const volScalarField & rho() const
Return carrier gas density.
Definition: KinematicCloudI.H:111
Foam::KinematicCloud::cellLengthScale
const scalarField & cellLengthScale() const
Return the cell length scale.
Definition: KinematicCloudI.H:431