PilchErdman.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-2024 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 "PilchErdman.H"
27 
28 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
29 
30 template<class CloudType>
32 (
33  const dictionary& dict,
34  CloudType& owner
35 )
36 :
37  BreakupModel<CloudType>(dict, owner, typeName),
38  B1_(0.375),
39  B2_(0.2274)
40 {
41  if (!this->defaultCoeffs(true))
42  {
43  this->coeffDict().lookup("B1") >> B1_;
44  this->coeffDict().lookup("B2") >> B2_;
45  }
46 }
47 
48 
49 template<class CloudType>
51 :
52  BreakupModel<CloudType>(bum),
53  B1_(bum.B1_),
54  B2_(bum.B2_)
55 {}
56 
57 
58 // * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
59 
60 template<class CloudType>
62 {}
63 
64 
65 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
66 
67 template<class CloudType>
69 (
70  const scalar dt,
71  const vector& g,
72  scalar& d,
73  scalar& tc,
74  scalar& ms,
75  scalar& nParticle,
76  scalar& KHindex,
77  scalar& y,
78  scalar& yDot,
79  const scalar d0,
80  const scalar rho,
81  const scalar mu,
82  const scalar sigma,
83  const vector& U,
84  const scalar rhoc,
85  const scalar muc,
86  const vector& Urel,
87  const scalar Urmag,
88  const scalar tMom,
89  const label injectori,
90  scalar& dChild,
91  scalar& massChild
92 )
93 {
94  // Weber number - eq (1)
95  scalar We = rhoc*sqr(Urmag)*d/sigma;
96 
97  // Ohnesorge number - eq (2)
98  scalar Oh = mu/sqrt(rho*d*sigma);
99 
100  // Critical Weber number - eq (5)
101  scalar Wec = 12.0*(1.0 + 1.077*pow(Oh, 1.6));
102 
103  if (We > Wec)
104  {
105  // We > 2670, wave crest stripping - eq (12)
106  scalar taubBar = 5.5;
107 
108  if (We < 2670)
109  {
110  if (We > 351)
111  {
112  // sheet stripping - eq (11)
113  taubBar = 0.766*pow(We - 12.0, 0.25);
114  }
115  else if (We > 45)
116  {
117  // bag-and-stamen breakup - eq (10)
118  //
119  // *** Note that the exponent is erroneously negated in the
120  // original reference. This expression matches the second
121  // reference and results in a continuous expression for
122  // taubBar.
123  //
124  taubBar = 14.1*pow(We - 12.0, -0.25);
125  }
126  else if (We > 18)
127  {
128  // bag breakup - eq (9)
129  taubBar = 2.45*pow(We - 12.0, 0.25);
130  }
131  else if (We > 12)
132  {
133  // vibrational breakup - eq (8)
134  taubBar = 6.0*pow(We - 12.0, -0.25);
135  }
136  else
137  {
138  // no break-up
139  taubBar = great;
140  }
141  }
142 
143  scalar rho12 = sqrt(rhoc/rho);
144 
145  // velocity of fragmenting drop - eq (20)
146  scalar Vd = Urmag*rho12*(B1_*taubBar + B2_*sqr(taubBar));
147 
148  // maximum stable diameter - eq (33)
149  scalar Vd1 = sqr(1.0 - Vd/Urmag);
150  Vd1 = max(Vd1, small);
151  scalar dStable = Wec*sigma/(Vd1*rhoc*sqr(Urmag));
152 
153  if (d < dStable)
154  {
155  // droplet diameter already stable = no break-up
156  // - do not update d and nParticle
157  return false;
158  }
159  else
160  {
161  scalar semiMass = nParticle*pow3(d);
162 
163  // invert eq (3) to create a dimensional break-up time
164  scalar taub = taubBar*d/(Urmag*rho12);
165 
166  // update droplet diameter according to the rate eq (implicitly)
167  scalar frac = dt/taub;
168  d = (d + frac*dStable)/(1.0 + frac);
169 
170  // correct the number of particles to conserve mass
171  nParticle = semiMass/pow3(d);
172  }
173  }
174 
175  return false;
176 }
177 
178 
179 // ************************************************************************* //
scalar y
Templated break-up model class.
Definition: BreakupModel.H:55
Templated base class for dsmc cloud.
Definition: DSMCCloud.H:80
Particle secondary breakup model, based on the references:
Definition: PilchErdman.H:80
PilchErdman(const dictionary &, CloudType &)
Construct from dictionary.
Definition: PilchErdman.C:32
virtual bool update(const scalar dt, const vector &g, scalar &d, scalar &tc, scalar &ms, scalar &nParticle, scalar &KHindex, scalar &y, scalar &yDot, const scalar d0, const scalar rho, const scalar mu, const scalar sigma, const vector &U, const scalar rhoc, const scalar muc, const vector &Urel, const scalar Urmag, const scalar tMom, const label injectori, scalar &dChild, scalar &massChild)
Update the parcel properties.
Definition: PilchErdman.C:69
virtual ~PilchErdman()
Destructor.
Definition: PilchErdman.C:61
A list of keyword definitions, which are a keyword followed by any number of values (e....
Definition: dictionary.H:162
ITstream & lookup(const word &, bool recursive=false, bool patternMatch=true) const
Find and return an entry data stream.
Definition: dictionary.C:710
const dictionary & coeffDict() const
Return const access to the coefficients dictionary.
Definition: subModelBase.C:128
virtual bool defaultCoeffs(const bool printMsg) const
Returns true if defaultCoeffs is true and outputs on printMsg.
Definition: subModelBase.C:140
U
Definition: pEqn.H:72
const dimensionedScalar sigma
Stefan-Boltzmann constant: default SI units: [W/m^2/K^4].
const dimensionedScalar mu
Atomic mass unit.
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
dimensionedSymmTensor sqr(const dimensionedVector &dv)
dimensionedScalar pow3(const dimensionedScalar &ds)
dimensionedScalar pow(const dimensionedScalar &ds, const dimensionedScalar &expt)
dimensionedScalar sqrt(const dimensionedScalar &ds)
layerAndWeight max(const layerAndWeight &a, const layerAndWeight &b)
dictionary dict