EulerDdtScheme.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-2014 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 "EulerDdtScheme.H"
27 #include "surfaceInterpolate.H"
28 #include "fvcDiv.H"
29 #include "fvMatrices.H"
30 
31 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
32 
33 namespace Foam
34 {
35 
36 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
37 
38 namespace fv
39 {
40 
41 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
42 
43 template<class Type>
44 tmp<GeometricField<Type, fvPatchField, volMesh> >
45 EulerDdtScheme<Type>::fvcDdt
46 (
47  const dimensioned<Type>& dt
48 )
49 {
50  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
51 
52  IOobject ddtIOobject
53  (
54  "ddt("+dt.name()+')',
55  mesh().time().timeName(),
56  mesh()
57  );
58 
59  if (mesh().moving())
60  {
61  tmp<GeometricField<Type, fvPatchField, volMesh> > tdtdt
62  (
63  new GeometricField<Type, fvPatchField, volMesh>
64  (
65  ddtIOobject,
66  mesh(),
67  dimensioned<Type>
68  (
69  "0",
70  dt.dimensions()/dimTime,
71  pTraits<Type>::zero
72  )
73  )
74  );
75 
76  tdtdt().internalField() =
77  rDeltaT.value()*dt.value()*(1.0 - mesh().Vsc0()/mesh().Vsc());
78 
79  return tdtdt;
80  }
81  else
82  {
83  return tmp<GeometricField<Type, fvPatchField, volMesh> >
84  (
85  new GeometricField<Type, fvPatchField, volMesh>
86  (
87  ddtIOobject,
88  mesh(),
89  dimensioned<Type>
90  (
91  "0",
92  dt.dimensions()/dimTime,
93  pTraits<Type>::zero
94  ),
95  calculatedFvPatchField<Type>::typeName
96  )
97  );
98  }
99 }
100 
101 
102 template<class Type>
103 tmp<GeometricField<Type, fvPatchField, volMesh> >
104 EulerDdtScheme<Type>::fvcDdt
105 (
106  const GeometricField<Type, fvPatchField, volMesh>& vf
107 )
108 {
109  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
110 
111  IOobject ddtIOobject
112  (
113  "ddt("+vf.name()+')',
114  mesh().time().timeName(),
115  mesh()
116  );
117 
118  if (mesh().moving())
119  {
120  return tmp<GeometricField<Type, fvPatchField, volMesh> >
121  (
122  new GeometricField<Type, fvPatchField, volMesh>
123  (
124  ddtIOobject,
125  mesh(),
126  rDeltaT.dimensions()*vf.dimensions(),
127  rDeltaT.value()*
128  (
129  vf.internalField()
130  - vf.oldTime().internalField()*mesh().Vsc0()/mesh().Vsc()
131  ),
132  rDeltaT.value()*
133  (
134  vf.boundaryField() - vf.oldTime().boundaryField()
135  )
136  )
137  );
138  }
139  else
140  {
141  return tmp<GeometricField<Type, fvPatchField, volMesh> >
142  (
143  new GeometricField<Type, fvPatchField, volMesh>
144  (
145  ddtIOobject,
146  rDeltaT*(vf - vf.oldTime())
147  )
148  );
149  }
150 }
151 
152 
153 template<class Type>
154 tmp<GeometricField<Type, fvPatchField, volMesh> >
155 EulerDdtScheme<Type>::fvcDdt
156 (
157  const dimensionedScalar& rho,
158  const GeometricField<Type, fvPatchField, volMesh>& vf
159 )
160 {
161  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
162 
163  IOobject ddtIOobject
164  (
165  "ddt("+rho.name()+','+vf.name()+')',
166  mesh().time().timeName(),
167  mesh()
168  );
169 
170  if (mesh().moving())
171  {
172  return tmp<GeometricField<Type, fvPatchField, volMesh> >
173  (
174  new GeometricField<Type, fvPatchField, volMesh>
175  (
176  ddtIOobject,
177  mesh(),
178  rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
179  rDeltaT.value()*rho.value()*
180  (
181  vf.internalField()
182  - vf.oldTime().internalField()*mesh().Vsc0()/mesh().Vsc()
183  ),
184  rDeltaT.value()*rho.value()*
185  (
186  vf.boundaryField() - vf.oldTime().boundaryField()
187  )
188  )
189  );
190  }
191  else
192  {
193  return tmp<GeometricField<Type, fvPatchField, volMesh> >
194  (
195  new GeometricField<Type, fvPatchField, volMesh>
196  (
197  ddtIOobject,
198  rDeltaT*rho*(vf - vf.oldTime())
199  )
200  );
201  }
202 }
203 
204 
205 template<class Type>
206 tmp<GeometricField<Type, fvPatchField, volMesh> >
207 EulerDdtScheme<Type>::fvcDdt
208 (
209  const volScalarField& rho,
210  const GeometricField<Type, fvPatchField, volMesh>& vf
211 )
212 {
213  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
214 
215  IOobject ddtIOobject
216  (
217  "ddt("+rho.name()+','+vf.name()+')',
218  mesh().time().timeName(),
219  mesh()
220  );
221 
222  if (mesh().moving())
223  {
224  return tmp<GeometricField<Type, fvPatchField, volMesh> >
225  (
226  new GeometricField<Type, fvPatchField, volMesh>
227  (
228  ddtIOobject,
229  mesh(),
230  rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
231  rDeltaT.value()*
232  (
233  rho.internalField()*vf.internalField()
234  - rho.oldTime().internalField()
235  *vf.oldTime().internalField()*mesh().Vsc0()/mesh().Vsc()
236  ),
237  rDeltaT.value()*
238  (
239  rho.boundaryField()*vf.boundaryField()
240  - rho.oldTime().boundaryField()
241  *vf.oldTime().boundaryField()
242  )
243  )
244  );
245  }
246  else
247  {
248  return tmp<GeometricField<Type, fvPatchField, volMesh> >
249  (
250  new GeometricField<Type, fvPatchField, volMesh>
251  (
252  ddtIOobject,
253  rDeltaT*(rho*vf - rho.oldTime()*vf.oldTime())
254  )
255  );
256  }
257 }
258 
259 
260 template<class Type>
261 tmp<GeometricField<Type, fvPatchField, volMesh> >
262 EulerDdtScheme<Type>::fvcDdt
263 (
264  const volScalarField& alpha,
265  const volScalarField& rho,
266  const GeometricField<Type, fvPatchField, volMesh>& vf
267 )
268 {
269  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
270 
271  IOobject ddtIOobject
272  (
273  "ddt("+alpha.name()+','+rho.name()+','+vf.name()+')',
274  mesh().time().timeName(),
275  mesh()
276  );
277 
278  if (mesh().moving())
279  {
280  return tmp<GeometricField<Type, fvPatchField, volMesh> >
281  (
282  new GeometricField<Type, fvPatchField, volMesh>
283  (
284  ddtIOobject,
285  mesh(),
286  rDeltaT.dimensions()
287  *alpha.dimensions()*rho.dimensions()*vf.dimensions(),
288  rDeltaT.value()*
289  (
290  alpha.internalField()
291  *rho.internalField()
292  *vf.internalField()
293 
294  - alpha.oldTime().internalField()
295  *rho.oldTime().internalField()
296  *vf.oldTime().internalField()*mesh().Vsc0()/mesh().Vsc()
297  ),
298  rDeltaT.value()*
299  (
300  alpha.boundaryField()
301  *rho.boundaryField()
302  *vf.boundaryField()
303 
304  - alpha.oldTime().boundaryField()
305  *rho.oldTime().boundaryField()
306  *vf.oldTime().boundaryField()
307  )
308  )
309  );
310  }
311  else
312  {
313  return tmp<GeometricField<Type, fvPatchField, volMesh> >
314  (
315  new GeometricField<Type, fvPatchField, volMesh>
316  (
317  ddtIOobject,
318  rDeltaT
319  *(
320  alpha*rho*vf
321  - alpha.oldTime()*rho.oldTime()*vf.oldTime()
322  )
323  )
324  );
325  }
326 }
327 
328 
329 template<class Type>
330 tmp<fvMatrix<Type> >
331 EulerDdtScheme<Type>::fvmDdt
332 (
333  const GeometricField<Type, fvPatchField, volMesh>& vf
334 )
335 {
336  tmp<fvMatrix<Type> > tfvm
337  (
338  new fvMatrix<Type>
339  (
340  vf,
341  vf.dimensions()*dimVol/dimTime
342  )
343  );
344 
345  fvMatrix<Type>& fvm = tfvm();
346 
347  scalar rDeltaT = 1.0/mesh().time().deltaTValue();
348 
349  fvm.diag() = rDeltaT*mesh().Vsc();
350 
351  if (mesh().moving())
352  {
353  fvm.source() = rDeltaT*vf.oldTime().internalField()*mesh().Vsc0();
354  }
355  else
356  {
357  fvm.source() = rDeltaT*vf.oldTime().internalField()*mesh().Vsc();
358  }
359 
360  return tfvm;
361 }
362 
363 
364 template<class Type>
365 tmp<fvMatrix<Type> >
366 EulerDdtScheme<Type>::fvmDdt
367 (
368  const dimensionedScalar& rho,
369  const GeometricField<Type, fvPatchField, volMesh>& vf
370 )
371 {
372  tmp<fvMatrix<Type> > tfvm
373  (
374  new fvMatrix<Type>
375  (
376  vf,
377  rho.dimensions()*vf.dimensions()*dimVol/dimTime
378  )
379  );
380  fvMatrix<Type>& fvm = tfvm();
381 
382  scalar rDeltaT = 1.0/mesh().time().deltaTValue();
383 
384  fvm.diag() = rDeltaT*rho.value()*mesh().Vsc();
385 
386  if (mesh().moving())
387  {
388  fvm.source() = rDeltaT
389  *rho.value()*vf.oldTime().internalField()*mesh().Vsc0();
390  }
391  else
392  {
393  fvm.source() = rDeltaT
394  *rho.value()*vf.oldTime().internalField()*mesh().Vsc();
395  }
396 
397  return tfvm;
398 }
399 
400 
401 template<class Type>
402 tmp<fvMatrix<Type> >
403 EulerDdtScheme<Type>::fvmDdt
404 (
405  const volScalarField& rho,
406  const GeometricField<Type, fvPatchField, volMesh>& vf
407 )
408 {
409  tmp<fvMatrix<Type> > tfvm
410  (
411  new fvMatrix<Type>
412  (
413  vf,
414  rho.dimensions()*vf.dimensions()*dimVol/dimTime
415  )
416  );
417  fvMatrix<Type>& fvm = tfvm();
418 
419  scalar rDeltaT = 1.0/mesh().time().deltaTValue();
420 
421  fvm.diag() = rDeltaT*rho.internalField()*mesh().Vsc();
422 
423  if (mesh().moving())
424  {
425  fvm.source() = rDeltaT
426  *rho.oldTime().internalField()
427  *vf.oldTime().internalField()*mesh().Vsc0();
428  }
429  else
430  {
431  fvm.source() = rDeltaT
432  *rho.oldTime().internalField()
433  *vf.oldTime().internalField()*mesh().Vsc();
434  }
435 
436  return tfvm;
437 }
438 
439 
440 template<class Type>
441 tmp<fvMatrix<Type> >
442 EulerDdtScheme<Type>::fvmDdt
443 (
444  const volScalarField& alpha,
445  const volScalarField& rho,
446  const GeometricField<Type, fvPatchField, volMesh>& vf
447 )
448 {
449  tmp<fvMatrix<Type> > tfvm
450  (
451  new fvMatrix<Type>
452  (
453  vf,
454  alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime
455  )
456  );
457  fvMatrix<Type>& fvm = tfvm();
458 
459  scalar rDeltaT = 1.0/mesh().time().deltaTValue();
460 
461  fvm.diag() = rDeltaT*alpha.internalField()*rho.internalField()*mesh().Vsc();
462 
463  if (mesh().moving())
464  {
465  fvm.source() = rDeltaT
466  *alpha.oldTime().internalField()
467  *rho.oldTime().internalField()
468  *vf.oldTime().internalField()*mesh().Vsc0();
469  }
470  else
471  {
472  fvm.source() = rDeltaT
473  *alpha.oldTime().internalField()
474  *rho.oldTime().internalField()
475  *vf.oldTime().internalField()*mesh().Vsc();
476  }
477 
478  return tfvm;
479 }
480 
481 
482 template<class Type>
483 tmp<typename EulerDdtScheme<Type>::fluxFieldType>
484 EulerDdtScheme<Type>::fvcDdtUfCorr
485 (
486  const GeometricField<Type, fvPatchField, volMesh>& U,
487  const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf
488 )
489 {
490  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
491 
492  fluxFieldType phiCorr
493  (
494  mesh().Sf() & (Uf.oldTime() - fvc::interpolate(U.oldTime()))
495  );
496 
497  return tmp<fluxFieldType>
498  (
499  new fluxFieldType
500  (
501  IOobject
502  (
503  "ddtCorr(" + U.name() + ',' + Uf.name() + ')',
504  mesh().time().timeName(),
505  mesh()
506  ),
507  this->fvcDdtPhiCoeff
508  (
509  U.oldTime(),
510  mesh().Sf() & Uf.oldTime(),
511  phiCorr
512  )
513  *rDeltaT*phiCorr
514  )
515  );
516 }
517 
518 
519 template<class Type>
520 tmp<typename EulerDdtScheme<Type>::fluxFieldType>
521 EulerDdtScheme<Type>::fvcDdtPhiCorr
522 (
523  const GeometricField<Type, fvPatchField, volMesh>& U,
524  const fluxFieldType& phi
525 )
526 {
527  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
528 
529  fluxFieldType phiCorr
530  (
531  phi.oldTime() - (mesh().Sf() & fvc::interpolate(U.oldTime()))
532  );
533 
534  return tmp<fluxFieldType>
535  (
536  new fluxFieldType
537  (
538  IOobject
539  (
540  "ddtCorr(" + U.name() + ',' + phi.name() + ')',
541  mesh().time().timeName(),
542  mesh()
543  ),
544  this->fvcDdtPhiCoeff(U.oldTime(), phi.oldTime(), phiCorr)
545  *rDeltaT*phiCorr
546  )
547  );
548 }
549 
550 
551 template<class Type>
552 tmp<typename EulerDdtScheme<Type>::fluxFieldType>
553 EulerDdtScheme<Type>::fvcDdtUfCorr
554 (
555  const volScalarField& rho,
556  const GeometricField<Type, fvPatchField, volMesh>& U,
557  const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf
558 )
559 {
560  if
561  (
562  U.dimensions() == dimVelocity
563  && Uf.dimensions() == rho.dimensions()*dimVelocity
564  )
565  {
566  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
567 
568  GeometricField<Type, fvPatchField, volMesh> rhoU0
569  (
570  rho.oldTime()*U.oldTime()
571  );
572 
573  fluxFieldType phiCorr
574  (
575  mesh().Sf() & (Uf.oldTime() - fvc::interpolate(rhoU0))
576  );
577 
578  return tmp<fluxFieldType>
579  (
580  new fluxFieldType
581  (
582  IOobject
583  (
584  "ddtCorr("
585  + rho.name() + ',' + U.name() + ',' + Uf.name() + ')',
586  mesh().time().timeName(),
587  mesh()
588  ),
589  this->fvcDdtPhiCoeff
590  (
591  rhoU0,
592  mesh().Sf() & Uf.oldTime(),
593  phiCorr
594  )
595  *rDeltaT*phiCorr
596  )
597  );
598  }
599  else if
600  (
601  U.dimensions() == rho.dimensions()*dimVelocity
602  && Uf.dimensions() == rho.dimensions()*dimVelocity
603  )
604  {
605  return fvcDdtUfCorr(U, Uf);
606  }
607  else
608  {
609  FatalErrorIn
610  (
611  "EulerDdtScheme<Type>::fvcDdtPhiCorr"
612  ) << "dimensions of Uf are not correct"
613  << abort(FatalError);
614 
615  return fluxFieldType::null();
616  }
617 }
618 
619 
620 template<class Type>
621 tmp<typename EulerDdtScheme<Type>::fluxFieldType>
622 EulerDdtScheme<Type>::fvcDdtPhiCorr
623 (
624  const volScalarField& rho,
625  const GeometricField<Type, fvPatchField, volMesh>& U,
626  const fluxFieldType& phi
627 )
628 {
629  if
630  (
631  U.dimensions() == dimVelocity
632  && phi.dimensions() == rho.dimensions()*dimVelocity*dimArea
633  )
634  {
635  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
636 
637  GeometricField<Type, fvPatchField, volMesh> rhoU0
638  (
639  rho.oldTime()*U.oldTime()
640  );
641 
642  fluxFieldType phiCorr
643  (
644  phi.oldTime() - (mesh().Sf() & fvc::interpolate(rhoU0))
645  );
646 
647  return tmp<fluxFieldType>
648  (
649  new fluxFieldType
650  (
651  IOobject
652  (
653  "ddtCorr("
654  + rho.name() + ',' + U.name() + ',' + phi.name() + ')',
655  mesh().time().timeName(),
656  mesh()
657  ),
658  this->fvcDdtPhiCoeff(rhoU0, phi.oldTime(), phiCorr)
659  *rDeltaT*phiCorr
660  )
661  );
662  }
663  else if
664  (
665  U.dimensions() == rho.dimensions()*dimVelocity
666  && phi.dimensions() == rho.dimensions()*dimVelocity*dimArea
667  )
668  {
669  return fvcDdtPhiCorr(U, phi);
670  }
671  else
672  {
673  FatalErrorIn
674  (
675  "EulerDdtScheme<Type>::fvcDdtPhiCorr"
676  ) << "dimensions of phi are not correct"
677  << abort(FatalError);
678 
679  return fluxFieldType::null();
680  }
681 }
682 
683 
684 template<class Type>
685 tmp<surfaceScalarField> EulerDdtScheme<Type>::meshPhi
686 (
687  const GeometricField<Type, fvPatchField, volMesh>&
688 )
689 {
690  return mesh().phi();
691 }
692 
693 
694 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
695 
696 } // End namespace fv
697 
698 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
699 
700 } // End namespace Foam
701 
702 // ************************************************************************* //
Foam::fvc::interpolate
tmp< GeometricField< Type, fvsPatchField, surfaceMesh > > interpolate(const GeometricField< Type, fvPatchField, volMesh > &vf, const surfaceScalarField &faceFlux, Istream &schemeData)
Definition: surfaceInterpolate.C:110
Foam::calculatedFvPatchField
This boundary condition is not designed to be evaluated; it is assmued that the value is assigned via...
Definition: calculatedFvPatchField.H:65
Foam::GeometricField::boundaryField
GeometricBoundaryField & boundaryField()
Return reference to GeometricBoundaryField.
Definition: GeometricField.C:699
Foam::dimTime
const dimensionSet dimTime(0, 0, 1, 0, 0, 0, 0)
Definition: dimensionSets.H:51
Foam::fv::EulerDdtScheme::fvmDdt
tmp< fvMatrix< Type > > fvmDdt(const GeometricField< Type, fvPatchField, volMesh > &)
Definition: EulerDdtScheme.C:332
Foam::dimVol
const dimensionSet dimVol(dimVolume)
Definition: dimensionSets.H:59
Foam::dimArea
const dimensionSet dimArea(sqr(dimLength))
Definition: dimensionSets.H:57
Foam::GeometricField::internalField
InternalField & internalField()
Return internal field.
Definition: GeometricField.C:688
Foam::fv::EulerDdtScheme::fvcDdtPhiCorr
tmp< fluxFieldType > fvcDdtPhiCorr(const GeometricField< Type, fvPatchField, volMesh > &U, const fluxFieldType &phi)
Definition: EulerDdtScheme.C:522
surfaceInterpolate.H
Surface Interpolation.
Foam::fvMatrix
A special matrix type and solver, designed for finite volume solutions of scalar equations. Face addressing is used to make all matrix assembly and solution loops vectorise.
Definition: fvPatchField.H:68
Foam::fv::EulerDdtScheme::fvcDdt
tmp< GeometricField< Type, fvPatchField, volMesh > > fvcDdt(const dimensioned< Type > &)
Definition: EulerDdtScheme.C:46
mesh
dynamicFvMesh & mesh
Definition: createDynamicFvMesh.H:18
Foam::fv::EulerDdtScheme::meshPhi
tmp< surfaceScalarField > meshPhi(const GeometricField< Type, fvPatchField, volMesh > &)
Definition: EulerDdtScheme.C:686
Foam
Namespace for OpenFOAM.
Definition: combustionModel.C:30
Foam::dimensioned::dimensions
const dimensionSet & dimensions() const
Return const reference to dimensions.
Definition: dimensionedType.C:250
Foam::dimensioned
Generic dimensioned Type class.
Definition: dimensionedScalarFwd.H:41
Foam::IOobject
IOobject defines the attributes of an object for which implicit objectRegistry management is supporte...
Definition: IOobject.H:91
Foam::dimensioned::name
const word & name() const
Return const reference to name.
Definition: dimensionedType.C:237
Foam::DimensionedField::dimensions
const dimensionSet & dimensions() const
Return dimensions.
Definition: DimensionedFieldI.H:46
Foam::fv::EulerDdtScheme::fvcDdtUfCorr
tmp< fluxFieldType > fvcDdtUfCorr(const GeometricField< Type, fvPatchField, volMesh > &U, const GeometricField< Type, fvsPatchField, surfaceMesh > &Uf)
Definition: EulerDdtScheme.C:485
Foam::abort
errorManip< error > abort(error &err)
Definition: errorManip.H:131
Foam::IOobject::name
const word & name() const
Return name.
Definition: IOobject.H:260
Foam::lduMatrix::diag
scalarField & diag()
Definition: lduMatrix.C:183
FatalErrorIn
#define FatalErrorIn(functionName)
Report an error message using Foam::FatalError.
Definition: error.H:314
Foam::GeometricField
Generic GeometricField class.
Definition: surfaceFieldsFwd.H:52
fvcDiv.H
Calculate the divergence of the given field.
Foam::pTraits
Traits class for primitives.
Definition: pTraits.H:50
Foam::GeometricField::oldTime
const GeometricField< Type, PatchField, GeoMesh > & oldTime() const
Return old time field.
Definition: GeometricField.C:768
Foam::FatalError
error FatalError
fv
labelList fv(nPoints)
Foam::fvMatrix::source
Field< Type > & source()
Definition: fvMatrix.H:291
Foam::dimVelocity
const dimensionSet dimVelocity
Foam::tmp
A class for managing temporary objects.
Definition: PtrList.H:118
Foam::dimensioned::value
const Type & value() const
Return const reference to value.
Definition: dimensionedType.C:263
fvMatrices.H
A special matrix type and solver, designed for finite volume solutions of scalar equations.
Generated by   doxygen 1.8.11