ReactingMultiphaseParcel.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) 2011-2015 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 "ReactingMultiphaseParcel.H"
27 #include "mathematicalConstants.H"
28 
29 using namespace Foam::constant::mathematical;
30 
31 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
32 
33 template<class ParcelType>
34 const Foam::label Foam::ReactingMultiphaseParcel<ParcelType>::GAS(0);
35 
36 template<class ParcelType>
37 const Foam::label Foam::ReactingMultiphaseParcel<ParcelType>::LIQ(1);
38 
39 template<class ParcelType>
40 const Foam::label Foam::ReactingMultiphaseParcel<ParcelType>::SLD(2);
41 
42 
43 // * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
44 
45 template<class ParcelType>
46 template<class TrackData>
47 Foam::scalar Foam::ReactingMultiphaseParcel<ParcelType>::CpEff
48 (
49  TrackData& td,
50  const scalar p,
51  const scalar T,
52  const label idG,
53  const label idL,
54  const label idS
55 ) const
56 {
57  return
58  this->Y_[GAS]*td.cloud().composition().Cp(idG, YGas_, p, T)
59  + this->Y_[LIQ]*td.cloud().composition().Cp(idL, YLiquid_, p, T)
60  + this->Y_[SLD]*td.cloud().composition().Cp(idS, YSolid_, p, T);
61 }
62 
63 
64 template<class ParcelType>
65 template<class TrackData>
66 Foam::scalar Foam::ReactingMultiphaseParcel<ParcelType>::HsEff
67 (
68  TrackData& td,
69  const scalar p,
70  const scalar T,
71  const label idG,
72  const label idL,
73  const label idS
74 ) const
75 {
76  return
77  this->Y_[GAS]*td.cloud().composition().Hs(idG, YGas_, p, T)
78  + this->Y_[LIQ]*td.cloud().composition().Hs(idL, YLiquid_, p, T)
79  + this->Y_[SLD]*td.cloud().composition().Hs(idS, YSolid_, p, T);
80 }
81 
82 
83 template<class ParcelType>
84 template<class TrackData>
85 Foam::scalar Foam::ReactingMultiphaseParcel<ParcelType>::LEff
86 (
87  TrackData& td,
88  const scalar p,
89  const scalar T,
90  const label idG,
91  const label idL,
92  const label idS
93 ) const
94 {
95  return
96  this->Y_[GAS]*td.cloud().composition().L(idG, YGas_, p, T)
97  + this->Y_[LIQ]*td.cloud().composition().L(idL, YLiquid_, p, T)
98  + this->Y_[SLD]*td.cloud().composition().L(idS, YSolid_, p, T);
99 }
100 
101 
102 template<class ParcelType>
103 Foam::scalar Foam::ReactingMultiphaseParcel<ParcelType>::updateMassFractions
104 (
105  const scalar mass0,
106  const scalarField& dMassGas,
107  const scalarField& dMassLiquid,
108  const scalarField& dMassSolid
109 )
110 {
111  scalarField& YMix = this->Y_;
112 
113  scalar massGas =
114  this->updateMassFraction(mass0*YMix[GAS], dMassGas, YGas_);
115  scalar massLiquid =
116  this->updateMassFraction(mass0*YMix[LIQ], dMassLiquid, YLiquid_);
117  scalar massSolid =
118  this->updateMassFraction(mass0*YMix[SLD], dMassSolid, YSolid_);
119 
120  scalar massNew = max(massGas + massLiquid + massSolid, ROOTVSMALL);
121 
122  YMix[GAS] = massGas/massNew;
123  YMix[LIQ] = massLiquid/massNew;
124  YMix[SLD] = massSolid/massNew;
125 
126  scalar Ytotal = sum(YMix);
127 
128  YMix[GAS] /= Ytotal;
129  YMix[LIQ] /= Ytotal;
130  YMix[SLD] /= Ytotal;
131 
132  return massNew;
133 }
134 
135 
136 // * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * * //
137 
138 template<class ParcelType>
139 template<class TrackData>
140 void Foam::ReactingMultiphaseParcel<ParcelType>::setCellValues
141 (
142  TrackData& td,
143  const scalar dt,
144  const label cellI
145 )
146 {
147  ParcelType::setCellValues(td, dt, cellI);
148 }
149 
150 
151 template<class ParcelType>
152 template<class TrackData>
153 void Foam::ReactingMultiphaseParcel<ParcelType>::cellValueSourceCorrection
154 (
155  TrackData& td,
156  const scalar dt,
157  const label cellI
158 )
159 {
160  // Re-use correction from reacting parcel
161  ParcelType::cellValueSourceCorrection(td, dt, cellI);
162 }
163 
164 
165 template<class ParcelType>
166 template<class TrackData>
167 void Foam::ReactingMultiphaseParcel<ParcelType>::calc
168 (
169  TrackData& td,
170  const scalar dt,
171  const label cellI
172 )
173 {
174  typedef typename TrackData::cloudType::reactingCloudType reactingCloudType;
175  const CompositionModel<reactingCloudType>& composition =
176  td.cloud().composition();
177 
178  // Define local properties at beginning of timestep
179  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
180 
181  const scalar np0 = this->nParticle_;
182  const scalar d0 = this->d_;
183  const vector& U0 = this->U_;
184  const scalar T0 = this->T_;
185  const scalar mass0 = this->mass();
186 
187  const scalar pc = this->pc_;
188 
189  const scalarField& YMix = this->Y_;
190  const label idG = composition.idGas();
191  const label idL = composition.idLiquid();
192  const label idS = composition.idSolid();
193 
194 
195  // Calc surface values
196  scalar Ts, rhos, mus, Prs, kappas;
197  this->calcSurfaceValues(td, cellI, T0, Ts, rhos, mus, Prs, kappas);
198  scalar Res = this->Re(U0, d0, rhos, mus);
199 
200 
201  // Sources
202  //~~~~~~~~
203 
204  // Explicit momentum source for particle
205  vector Su = vector::zero;
206 
207  // Linearised momentum source coefficient
208  scalar Spu = 0.0;
209 
210  // Momentum transfer from the particle to the carrier phase
211  vector dUTrans = vector::zero;
212 
213  // Explicit enthalpy source for particle
214  scalar Sh = 0.0;
215 
216  // Linearised enthalpy source coefficient
217  scalar Sph = 0.0;
218 
219  // Sensible enthalpy transfer from the particle to the carrier phase
220  scalar dhsTrans = 0.0;
221 
222 
223  // 1. Compute models that contribute to mass transfer - U, T held constant
224  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
225 
226  // Phase change in liquid phase
227  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
228 
229  // Mass transfer due to phase change
230  scalarField dMassPC(YLiquid_.size(), 0.0);
231 
232  // Molar flux of species emitted from the particle (kmol/m^2/s)
233  scalar Ne = 0.0;
234 
235  // Sum Ni*Cpi*Wi of emission species
236  scalar NCpW = 0.0;
237 
238  // Surface concentrations of emitted species
239  scalarField Cs(composition.carrier().species().size(), 0.0);
240 
241  // Calc mass and enthalpy transfer due to phase change
242  this->calcPhaseChange
243  (
244  td,
245  dt,
246  cellI,
247  Res,
248  Prs,
249  Ts,
250  mus/rhos,
251  d0,
252  T0,
253  mass0,
254  idL,
255  YMix[LIQ],
256  YLiquid_,
257  dMassPC,
258  Sh,
259  Ne,
260  NCpW,
261  Cs
262  );
263 
264 
265  // Devolatilisation
266  // ~~~~~~~~~~~~~~~~
267 
268  // Mass transfer due to devolatilisation
269  scalarField dMassDV(YGas_.size(), 0.0);
270 
271  // Calc mass and enthalpy transfer due to devolatilisation
272  calcDevolatilisation
273  (
274  td,
275  dt,
276  this->age_,
277  Ts,
278  d0,
279  T0,
280  mass0,
281  this->mass0_,
282  YMix[GAS]*YGas_,
283  YMix[LIQ]*YLiquid_,
284  YMix[SLD]*YSolid_,
285  canCombust_,
286  dMassDV,
287  Sh,
288  Ne,
289  NCpW,
290  Cs
291  );
292 
293  // Surface reactions
294  // ~~~~~~~~~~~~~~~~~
295 
296  // Change in carrier phase composition due to surface reactions
297  scalarField dMassSRGas(YGas_.size(), 0.0);
298  scalarField dMassSRLiquid(YLiquid_.size(), 0.0);
299  scalarField dMassSRSolid(YSolid_.size(), 0.0);
300  scalarField dMassSRCarrier(composition.carrier().species().size(), 0.0);
301 
302  // Calc mass and enthalpy transfer due to surface reactions
303  calcSurfaceReactions
304  (
305  td,
306  dt,
307  cellI,
308  d0,
309  T0,
310  mass0,
311  canCombust_,
312  Ne,
313  YMix,
314  YGas_,
315  YLiquid_,
316  YSolid_,
317  dMassSRGas,
318  dMassSRLiquid,
319  dMassSRSolid,
320  dMassSRCarrier,
321  Sh,
322  dhsTrans
323  );
324 
325  // 2. Update the parcel properties due to change in mass
326  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
327 
328  scalarField dMassGas(dMassDV + dMassSRGas);
329  scalarField dMassLiquid(dMassPC + dMassSRLiquid);
330  scalarField dMassSolid(dMassSRSolid);
331 
332  scalar mass1 = mass0 - sum(dMassGas) - sum(dMassLiquid) - sum(dMassSolid);
333 
334  // Remove the particle when mass falls below minimum threshold
335  if (np0*mass1 < td.cloud().constProps().minParcelMass())
336  {
337  td.keepParticle = false;
338 
339  if (td.cloud().solution().coupled())
340  {
341  scalar dm = np0*mass0;
342 
343  // Absorb parcel into carrier phase
344  forAll(YGas_, i)
345  {
346  label gid = composition.localToCarrierId(GAS, i);
347  td.cloud().rhoTrans(gid)[cellI] += dm*YMix[GAS]*YGas_[i];
348  }
349  forAll(YLiquid_, i)
350  {
351  label gid = composition.localToCarrierId(LIQ, i);
352  td.cloud().rhoTrans(gid)[cellI] += dm*YMix[LIQ]*YLiquid_[i];
353  }
354 
355  // No mapping between solid components and carrier phase
356  /*
357  forAll(YSolid_, i)
358  {
359  label gid = composition.localToCarrierId(SLD, i);
360  td.cloud().rhoTrans(gid)[cellI] += dm*YMix[SLD]*YSolid_[i];
361  }
362  */
363 
364  td.cloud().UTrans()[cellI] += dm*U0;
365 
366  td.cloud().hsTrans()[cellI] += dm*HsEff(td, pc, T0, idG, idL, idS);
367 
368  td.cloud().phaseChange().addToPhaseChangeMass(np0*mass1);
369  }
370 
371  return;
372  }
373 
374  (void)updateMassFractions(mass0, dMassGas, dMassLiquid, dMassSolid);
375 
376  // Update particle density or diameter
377  if (td.cloud().constProps().constantVolume())
378  {
379  this->rho_ = mass1/this->volume();
380  }
381  else
382  {
383  this->d_ = cbrt(mass1/this->rho_*6.0/pi);
384  }
385 
386  // Correct surface values due to emitted species
387  this->correctSurfaceValues(td, cellI, Ts, Cs, rhos, mus, Prs, kappas);
388  Res = this->Re(U0, this->d_, rhos, mus);
389 
390 
391  // 3. Compute heat- and momentum transfers
392  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
393 
394  // Heat transfer
395  // ~~~~~~~~~~~~~
396 
397  // Calculate new particle temperature
398  this->T_ =
399  this->calcHeatTransfer
400  (
401  td,
402  dt,
403  cellI,
404  Res,
405  Prs,
406  kappas,
407  NCpW,
408  Sh,
409  dhsTrans,
410  Sph
411  );
412 
413 
414  this->Cp_ = CpEff(td, pc, this->T_, idG, idL, idS);
415 
416 
417  // Motion
418  // ~~~~~~
419 
420  // Calculate new particle velocity
421  this->U_ =
422  this->calcVelocity(td, dt, cellI, Res, mus, mass1, Su, dUTrans, Spu);
423 
424 
425  // 4. Accumulate carrier phase source terms
426  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
427 
428  if (td.cloud().solution().coupled())
429  {
430  // Transfer mass lost to carrier mass, momentum and enthalpy sources
431  forAll(YGas_, i)
432  {
433  scalar dm = np0*dMassGas[i];
434  label gid = composition.localToCarrierId(GAS, i);
435  scalar hs = composition.carrier().Hs(gid, pc, T0);
436  td.cloud().rhoTrans(gid)[cellI] += dm;
437  td.cloud().UTrans()[cellI] += dm*U0;
438  td.cloud().hsTrans()[cellI] += dm*hs;
439  }
440  forAll(YLiquid_, i)
441  {
442  scalar dm = np0*dMassLiquid[i];
443  label gid = composition.localToCarrierId(LIQ, i);
444  scalar hs = composition.carrier().Hs(gid, pc, T0);
445  td.cloud().rhoTrans(gid)[cellI] += dm;
446  td.cloud().UTrans()[cellI] += dm*U0;
447  td.cloud().hsTrans()[cellI] += dm*hs;
448  }
449 
450  // No mapping between solid components and carrier phase
451  /*
452  forAll(YSolid_, i)
453  {
454  scalar dm = np0*dMassSolid[i];
455  label gid = composition.localToCarrierId(SLD, i);
456  scalar hs = composition.carrier().Hs(gid, pc, T0);
457  td.cloud().rhoTrans(gid)[cellI] += dm;
458  td.cloud().UTrans()[cellI] += dm*U0;
459  td.cloud().hsTrans()[cellI] += dm*hs;
460  }
461  */
462 
463  forAll(dMassSRCarrier, i)
464  {
465  scalar dm = np0*dMassSRCarrier[i];
466  scalar hs = composition.carrier().Hs(i, pc, T0);
467  td.cloud().rhoTrans(i)[cellI] += dm;
468  td.cloud().UTrans()[cellI] += dm*U0;
469  td.cloud().hsTrans()[cellI] += dm*hs;
470  }
471 
472  // Update momentum transfer
473  td.cloud().UTrans()[cellI] += np0*dUTrans;
474  td.cloud().UCoeff()[cellI] += np0*Spu;
475 
476  // Update sensible enthalpy transfer
477  td.cloud().hsTrans()[cellI] += np0*dhsTrans;
478  td.cloud().hsCoeff()[cellI] += np0*Sph;
479 
480  // Update radiation fields
481  if (td.cloud().radiation())
482  {
483  const scalar ap = this->areaP();
484  const scalar T4 = pow4(T0);
485  td.cloud().radAreaP()[cellI] += dt*np0*ap;
486  td.cloud().radT4()[cellI] += dt*np0*T4;
487  td.cloud().radAreaPT4()[cellI] += dt*np0*ap*T4;
488  }
489  }
490 }
491 
492 
493 template<class ParcelType>
494 template<class TrackData>
495 void Foam::ReactingMultiphaseParcel<ParcelType>::calcDevolatilisation
496 (
497  TrackData& td,
498  const scalar dt,
499  const scalar age,
500  const scalar Ts,
501  const scalar d,
502  const scalar T,
503  const scalar mass,
504  const scalar mass0,
505  const scalarField& YGasEff,
506  const scalarField& YLiquidEff,
507  const scalarField& YSolidEff,
508  label& canCombust,
509  scalarField& dMassDV,
510  scalar& Sh,
511  scalar& N,
512  scalar& NCpW,
513  scalarField& Cs
514 ) const
515 {
516  // Check that model is active
517  if (!td.cloud().devolatilisation().active())
518  {
519  return;
520  }
521 
522  // Initialise demand-driven constants
523  (void)td.cloud().constProps().TDevol();
524  (void)td.cloud().constProps().LDevol();
525 
526  // Check that the parcel temperature is within necessary limits for
527  // devolatilisation to occur
528  if (T < td.cloud().constProps().TDevol() || canCombust == -1)
529  {
530  return;
531  }
532 
533  typedef typename TrackData::cloudType::reactingCloudType reactingCloudType;
534  const CompositionModel<reactingCloudType>& composition =
535  td.cloud().composition();
536 
537 
538  // Total mass of volatiles evolved
539  td.cloud().devolatilisation().calculate
540  (
541  dt,
542  age,
543  mass0,
544  mass,
545  T,
546  YGasEff,
547  YLiquidEff,
548  YSolidEff,
549  canCombust,
550  dMassDV
551  );
552 
553  scalar dMassTot = sum(dMassDV);
554 
555  td.cloud().devolatilisation().addToDevolatilisationMass
556  (
557  this->nParticle_*dMassTot
558  );
559 
560  Sh -= dMassTot*td.cloud().constProps().LDevol()/dt;
561 
562  // Update molar emissions
563  if (td.cloud().heatTransfer().BirdCorrection())
564  {
565  // Molar average molecular weight of carrier mix
566  const scalar Wc =
567  max(SMALL, this->rhoc_*RR*this->Tc_/this->pc_);
568 
569  // Note: hardcoded gaseous diffusivities for now
570  // TODO: add to carrier thermo
571  const scalar beta = sqr(cbrt(15.0) + cbrt(15.0));
572 
573  forAll(dMassDV, i)
574  {
575  const label id = composition.localToCarrierId(GAS, i);
576  const scalar Cp = composition.carrier().Cp(id, this->pc_, Ts);
577  const scalar W = composition.carrier().W(id);
578  const scalar Ni = dMassDV[i]/(this->areaS(d)*dt*W);
579 
580  // Dab calc'd using API vapour mass diffusivity function
581  const scalar Dab =
582  3.6059e-3*(pow(1.8*Ts, 1.75))
583  *sqrt(1.0/W + 1.0/Wc)
584  /(this->pc_*beta);
585 
586  N += Ni;
587  NCpW += Ni*Cp*W;
588  Cs[id] += Ni*d/(2.0*Dab);
589  }
590  }
591 }
592 
593 
594 template<class ParcelType>
595 template<class TrackData>
596 void Foam::ReactingMultiphaseParcel<ParcelType>::calcSurfaceReactions
597 (
598  TrackData& td,
599  const scalar dt,
600  const label cellI,
601  const scalar d,
602  const scalar T,
603  const scalar mass,
604  const label canCombust,
605  const scalar N,
606  const scalarField& YMix,
607  const scalarField& YGas,
608  const scalarField& YLiquid,
609  const scalarField& YSolid,
610  scalarField& dMassSRGas,
611  scalarField& dMassSRLiquid,
612  scalarField& dMassSRSolid,
613  scalarField& dMassSRCarrier,
614  scalar& Sh,
615  scalar& dhsTrans
616 ) const
617 {
618  // Check that model is active
619  if (!td.cloud().surfaceReaction().active())
620  {
621  return;
622  }
623 
624  // Initialise demand-driven constants
625  (void)td.cloud().constProps().hRetentionCoeff();
626  (void)td.cloud().constProps().TMax();
627 
628  // Check that model is active
629  if (canCombust != 1)
630  {
631  return;
632  }
633 
634 
635  // Update surface reactions
636  const scalar hReaction = td.cloud().surfaceReaction().calculate
637  (
638  dt,
639  cellI,
640  d,
641  T,
642  this->Tc_,
643  this->pc_,
644  this->rhoc_,
645  mass,
646  YGas,
647  YLiquid,
648  YSolid,
649  YMix,
650  N,
651  dMassSRGas,
652  dMassSRLiquid,
653  dMassSRSolid,
654  dMassSRCarrier
655  );
656 
657  td.cloud().surfaceReaction().addToSurfaceReactionMass
658  (
659  this->nParticle_
660  *(sum(dMassSRGas) + sum(dMassSRLiquid) + sum(dMassSRSolid))
661  );
662 
663  const scalar xsi = min(T/td.cloud().constProps().TMax(), 1.0);
664  const scalar coeff =
665  (1.0 - xsi*xsi)*td.cloud().constProps().hRetentionCoeff();
666 
667  Sh += coeff*hReaction/dt;
668 
669  dhsTrans += (1.0 - coeff)*hReaction;
670 }
671 
672 
673 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
674 
675 template<class ParcelType>
676 Foam::ReactingMultiphaseParcel<ParcelType>::ReactingMultiphaseParcel
677 (
678  const ReactingMultiphaseParcel<ParcelType>& p
679 )
680 :
681  ParcelType(p),
682  YGas_(p.YGas_),
683  YLiquid_(p.YLiquid_),
684  YSolid_(p.YSolid_),
685  canCombust_(p.canCombust_)
686 {}
687 
688 
689 template<class ParcelType>
690 Foam::ReactingMultiphaseParcel<ParcelType>::ReactingMultiphaseParcel
691 (
692  const ReactingMultiphaseParcel<ParcelType>& p,
693  const polyMesh& mesh
694 )
695 :
696  ParcelType(p, mesh),
697  YGas_(p.YGas_),
698  YLiquid_(p.YLiquid_),
699  YSolid_(p.YSolid_),
700  canCombust_(p.canCombust_)
701 {}
702 
703 
704 // * * * * * * * * * * * * * * IOStream operators * * * * * * * * * * * * * //
705 
706 #include "ReactingMultiphaseParcelIO.C"
707 
708 // ************************************************************************* //
Foam::constant::thermodynamic::RR
const scalar RR
Universal gas constant (default in [J/(kmol K)])
Definition: thermodynamicConstants.C:44
beta
dimensionedScalar beta("beta", dimless/dimTemperature, laminarTransport)
mathematicalConstants.H
Foam::Vector< scalar >::zero
static const Vector zero
Definition: Vector.H:80
p
p
Definition: pEqn.H:62
Sh
scalar Sh
Definition: solveChemistry.H:2
forAll
#define forAll(list, i)
Loop across all elements in list.
Definition: UList.H:406
Foam::ReactingMultiphaseParcel::SLD
static const label SLD
Definition: ReactingMultiphaseParcel.H:80
Foam::Re
scalarField Re(const UList< complex > &cf)
Definition: complexFields.C:97
Foam::CompositionModel
Templated reacting parcel composition model class Consists of carrier species (via thermo package),...
Definition: ReactingCloud.H:52
Foam::pow4
dimensionedScalar pow4(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:98
Foam::label
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
Foam::Field
Pre-declare SubField and related Field type.
Definition: Field.H:57
Foam::fvc::Su
tmp< GeometricField< Type, fvPatchField, volMesh > > Su(const GeometricField< Type, fvPatchField, volMesh > &su, const GeometricField< Type, fvPatchField, volMesh > &vf)
Definition: fvcSup.C:44
ReactingMultiphaseParcelIO.C
Foam::ReactingMultiphaseParcel
Multiphase variant of the reacting parcel class with one/two-way coupling with the continuous phase.
Definition: ReactingMultiphaseParcel.H:50
ReactingMultiphaseParcel.H
Foam::T
void T(FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
Definition: FieldFieldFunctions.C:55
Foam::ReactingMultiphaseParcel::setCellValues
void setCellValues(TrackData &td, const scalar dt, const label cellI)
Set cell values.
Definition: ReactingMultiphaseParcel.C:141
Foam::pow
dimensionedScalar pow(const dimensionedScalar &ds, const dimensionedScalar &expt)
Definition: dimensionedScalar.C:73
mesh
dynamicFvMesh & mesh
Definition: createDynamicFvMesh.H:18
coeff
const scalar coeff[]
Definition: Test-Polynomial.C:38
Foam::ReactingMultiphaseParcel::CpEff
scalar CpEff(TrackData &td, const scalar p, const scalar T, const label idG, const label idL, const label idS) const
Return the mixture effective specific heat capacity.
Foam::ReactingMultiphaseParcel::calcDevolatilisation
void calcDevolatilisation(TrackData &td, const scalar dt, const scalar age, const scalar Ts, const scalar d, const scalar T, const scalar mass, const scalar mass0, const scalarField &YGasEff, const scalarField &YLiquidEff, const scalarField &YSolidEff, label &canCombust, scalarField &dMassDV, scalar &Sh, scalar &N, scalar &NCpW, scalarField &Cs) const
Calculate Devolatilisation.
Definition: ReactingMultiphaseParcel.C:496
Foam::ReactingMultiphaseParcel::LIQ
static const label LIQ
Definition: ReactingMultiphaseParcel.H:79
Foam::max
dimensioned< Type > max(const dimensioned< Type > &, const dimensioned< Type > &)
Foam::ReactingMultiphaseParcel::HsEff
scalar HsEff(TrackData &td, const scalar p, const scalar T, const label idG, const label idL, const label idS) const
Return the mixture effective sensible enthalpy.
Foam::ReactingMultiphaseParcel::GAS
static const label GAS
Definition: ReactingMultiphaseParcel.H:78
Foam::ReactingMultiphaseParcel::cellValueSourceCorrection
void cellValueSourceCorrection(TrackData &td, const scalar dt, const label cellI)
Correct cell values using latest transfer information.
Definition: ReactingMultiphaseParcel.C:154
Foam::sqr
dimensionedSymmTensor sqr(const dimensionedVector &dv)
Definition: dimensionedSymmTensor.C:49
Foam::constant::mathematical
mathematical constants.
Foam::ReactingMultiphaseParcel::calcSurfaceReactions
void calcSurfaceReactions(TrackData &td, const scalar dt, const label cellI, const scalar d, const scalar T, const scalar mass, const label canCombust, const scalar N, const scalarField &YMix, const scalarField &YGas, const scalarField &YLiquid, const scalarField &YSolid, scalarField &dMassSRGas, scalarField &dMassSRLiquid, scalarField &dMassSRSolid, scalarField &dMassSRCarrier, scalar &Sh, scalar &dhsTrans) const
Calculate surface reactions.
Definition: ReactingMultiphaseParcel.C:597
Foam::Vector< scalar >
Foam::sqrt
dimensionedScalar sqrt(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:142
Foam::ReactingMultiphaseParcel::updateMassFractions
scalar updateMassFractions(const scalar mass0, const scalarField &dMassGas, const scalarField &dMassLiquid, const scalarField &dMassSolid)
Update the mass fractions (Y, YGas, YLiquid, YSolid)
Definition: ReactingMultiphaseParcel.C:104
composition
basicMultiComponentMixture & composition
Definition: createFields.H:35
Foam::sum
dimensioned< Type > sum(const DimensionedField< Type, GeoMesh > &df)
Definition: DimensionedFieldFunctions.C:333
Foam::constant::mathematical::pi
const scalar pi(M_PI)
Foam::ReactingMultiphaseParcel::ReactingMultiphaseParcel
ReactingMultiphaseParcel(const polyMesh &mesh, const vector &position, const label cellI, const label tetFaceI, const label tetPtI)
Construct from owner, position, and cloud owner.
Definition: ReactingMultiphaseParcelI.H:69
Foam::cbrt
dimensionedScalar cbrt(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:153
Foam::ReactingMultiphaseParcel::calc
void calc(TrackData &td, const scalar dt, const label cellI)
Update parcel properties over the time interval.
Definition: ReactingMultiphaseParcel.C:168
Foam::min
dimensioned< Type > min(const dimensioned< Type > &, const dimensioned< Type > &)
Foam::ReactingMultiphaseParcel::LEff
scalar LEff(TrackData &td, const scalar p, const scalar T, const label idG, const label idL, const label idS) const
Return the mixture effective latent heat.
N
label N
Definition: createFields.H:22

Copyright © 2011-2018  OpenFOAM | OPENFOAM® is a registered trademark of OpenCFD Ltd.

Generated by   doxygen 1.8.17