CoEulerDdtScheme.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 "CoEulerDdtScheme.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<volScalarField> CoEulerDdtScheme<Type>::CorDeltaT() const
45 {
46  const surfaceScalarField cofrDeltaT(CofrDeltaT());
47 
48  tmp<volScalarField> tcorDeltaT
49  (
50  new volScalarField
51  (
52  IOobject
53  (
54  "CorDeltaT",
55  cofrDeltaT.instance(),
56  mesh()
57  ),
58  mesh(),
59  dimensionedScalar("CorDeltaT", cofrDeltaT.dimensions(), 0.0),
60  zeroGradientFvPatchScalarField::typeName
61  )
62  );
63 
64  volScalarField& corDeltaT = tcorDeltaT();
65 
66  const labelUList& owner = mesh().owner();
67  const labelUList& neighbour = mesh().neighbour();
68 
69  forAll(owner, faceI)
70  {
71  corDeltaT[owner[faceI]] =
72  max(corDeltaT[owner[faceI]], cofrDeltaT[faceI]);
73 
74  corDeltaT[neighbour[faceI]] =
75  max(corDeltaT[neighbour[faceI]], cofrDeltaT[faceI]);
76  }
77 
78  volScalarField::GeometricBoundaryField& bcorDeltaT =
79  corDeltaT.boundaryField();
80 
81  forAll(bcorDeltaT, patchi)
82  {
83  const fvsPatchScalarField& pcofrDeltaT =
84  cofrDeltaT.boundaryField()[patchi];
85 
86  const fvPatch& p = pcofrDeltaT.patch();
87  const labelUList& faceCells = p.patch().faceCells();
88 
89  forAll(pcofrDeltaT, patchFacei)
90  {
91  corDeltaT[faceCells[patchFacei]] = max
92  (
93  corDeltaT[faceCells[patchFacei]],
94  pcofrDeltaT[patchFacei]
95  );
96  }
97  }
98 
99  corDeltaT.correctBoundaryConditions();
100 
101  //corDeltaT = max(corDeltaT, max(corDeltaT)/100.0);
102 
103  return tcorDeltaT;
104 }
105 
106 
107 template<class Type>
108 tmp<surfaceScalarField> CoEulerDdtScheme<Type>::CofrDeltaT() const
109 {
110  const dimensionedScalar& deltaT = mesh().time().deltaT();
111 
112  const surfaceScalarField& phi =
113  static_cast<const objectRegistry&>(mesh())
114  .lookupObject<surfaceScalarField>(phiName_);
115 
116  if (phi.dimensions() == dimensionSet(0, 3, -1, 0, 0))
117  {
118  surfaceScalarField Co
119  (
120  mesh().surfaceInterpolation::deltaCoeffs()
121  *(mag(phi)/mesh().magSf())
122  *deltaT
123  );
124 
125  return max(Co/maxCo_, scalar(1))/deltaT;
126  }
127  else if (phi.dimensions() == dimensionSet(1, 0, -1, 0, 0))
128  {
129  const volScalarField& rho =
130  static_cast<const objectRegistry&>(mesh())
131  .lookupObject<volScalarField>(rhoName_).oldTime();
132 
133  surfaceScalarField Co
134  (
135  mesh().surfaceInterpolation::deltaCoeffs()
136  *(mag(phi)/(fvc::interpolate(rho)*mesh().magSf()))
137  *deltaT
138  );
139 
140  return max(Co/maxCo_, scalar(1))/deltaT;
141  }
142  else
143  {
144  FatalErrorIn("CoEulerDdtScheme<Type>::CofrDeltaT() const")
145  << "Incorrect dimensions of phi: " << phi.dimensions()
146  << abort(FatalError);
147 
148  return tmp<surfaceScalarField>(NULL);
149  }
150 }
151 
152 
153 template<class Type>
154 tmp<GeometricField<Type, fvPatchField, volMesh> >
155 CoEulerDdtScheme<Type>::fvcDdt
156 (
157  const dimensioned<Type>& dt
158 )
159 {
160  const volScalarField rDeltaT(CorDeltaT());
161 
162  IOobject ddtIOobject
163  (
164  "ddt("+dt.name()+')',
165  mesh().time().timeName(),
166  mesh()
167  );
168 
169  if (mesh().moving())
170  {
171  tmp<GeometricField<Type, fvPatchField, volMesh> > tdtdt
172  (
173  new GeometricField<Type, fvPatchField, volMesh>
174  (
175  ddtIOobject,
176  mesh(),
177  dimensioned<Type>
178  (
179  "0",
180  dt.dimensions()/dimTime,
181  pTraits<Type>::zero
182  )
183  )
184  );
185 
186  tdtdt().internalField() =
187  rDeltaT.internalField()*dt.value()
188  *(1.0 - mesh().Vsc0()/mesh().Vsc());
189 
190  return tdtdt;
191  }
192  else
193  {
194  return tmp<GeometricField<Type, fvPatchField, volMesh> >
195  (
196  new GeometricField<Type, fvPatchField, volMesh>
197  (
198  ddtIOobject,
199  mesh(),
200  dimensioned<Type>
201  (
202  "0",
203  dt.dimensions()/dimTime,
204  pTraits<Type>::zero
205  ),
206  calculatedFvPatchField<Type>::typeName
207  )
208  );
209  }
210 }
211 
212 
213 template<class Type>
214 tmp<GeometricField<Type, fvPatchField, volMesh> >
215 CoEulerDdtScheme<Type>::fvcDdt
216 (
217  const GeometricField<Type, fvPatchField, volMesh>& vf
218 )
219 {
220  const volScalarField rDeltaT(CorDeltaT());
221 
222  IOobject ddtIOobject
223  (
224  "ddt("+vf.name()+')',
225  mesh().time().timeName(),
226  mesh()
227  );
228 
229  if (mesh().moving())
230  {
231  return tmp<GeometricField<Type, fvPatchField, volMesh> >
232  (
233  new GeometricField<Type, fvPatchField, volMesh>
234  (
235  ddtIOobject,
236  mesh(),
237  rDeltaT.dimensions()*vf.dimensions(),
238  rDeltaT.internalField()*
239  (
240  vf.internalField()
241  - vf.oldTime().internalField()*mesh().Vsc0()/mesh().Vsc()
242  ),
243  rDeltaT.boundaryField()*
244  (
245  vf.boundaryField() - vf.oldTime().boundaryField()
246  )
247  )
248  );
249  }
250  else
251  {
252  return tmp<GeometricField<Type, fvPatchField, volMesh> >
253  (
254  new GeometricField<Type, fvPatchField, volMesh>
255  (
256  ddtIOobject,
257  rDeltaT*(vf - vf.oldTime())
258  )
259  );
260  }
261 }
262 
263 
264 template<class Type>
265 tmp<GeometricField<Type, fvPatchField, volMesh> >
266 CoEulerDdtScheme<Type>::fvcDdt
267 (
268  const dimensionedScalar& rho,
269  const GeometricField<Type, fvPatchField, volMesh>& vf
270 )
271 {
272  const volScalarField rDeltaT(CorDeltaT());
273 
274  IOobject ddtIOobject
275  (
276  "ddt("+rho.name()+','+vf.name()+')',
277  mesh().time().timeName(),
278  mesh()
279  );
280 
281  if (mesh().moving())
282  {
283  return tmp<GeometricField<Type, fvPatchField, volMesh> >
284  (
285  new GeometricField<Type, fvPatchField, volMesh>
286  (
287  ddtIOobject,
288  mesh(),
289  rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
290  rDeltaT.internalField()*rho.value()*
291  (
292  vf.internalField()
293  - vf.oldTime().internalField()*mesh().Vsc0()/mesh().Vsc()
294  ),
295  rDeltaT.boundaryField()*rho.value()*
296  (
297  vf.boundaryField() - vf.oldTime().boundaryField()
298  )
299  )
300  );
301  }
302  else
303  {
304  return tmp<GeometricField<Type, fvPatchField, volMesh> >
305  (
306  new GeometricField<Type, fvPatchField, volMesh>
307  (
308  ddtIOobject,
309  rDeltaT*rho*(vf - vf.oldTime())
310  )
311  );
312  }
313 }
314 
315 
316 template<class Type>
317 tmp<GeometricField<Type, fvPatchField, volMesh> >
318 CoEulerDdtScheme<Type>::fvcDdt
319 (
320  const volScalarField& rho,
321  const GeometricField<Type, fvPatchField, volMesh>& vf
322 )
323 {
324  const volScalarField rDeltaT(CorDeltaT());
325 
326  IOobject ddtIOobject
327  (
328  "ddt("+rho.name()+','+vf.name()+')',
329  mesh().time().timeName(),
330  mesh()
331  );
332 
333  if (mesh().moving())
334  {
335  return tmp<GeometricField<Type, fvPatchField, volMesh> >
336  (
337  new GeometricField<Type, fvPatchField, volMesh>
338  (
339  ddtIOobject,
340  mesh(),
341  rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
342  rDeltaT.internalField()*
343  (
344  rho.internalField()*vf.internalField()
345  - rho.oldTime().internalField()
346  *vf.oldTime().internalField()*mesh().Vsc0()/mesh().Vsc()
347  ),
348  rDeltaT.boundaryField()*
349  (
350  rho.boundaryField()*vf.boundaryField()
351  - rho.oldTime().boundaryField()
352  *vf.oldTime().boundaryField()
353  )
354  )
355  );
356  }
357  else
358  {
359  return tmp<GeometricField<Type, fvPatchField, volMesh> >
360  (
361  new GeometricField<Type, fvPatchField, volMesh>
362  (
363  ddtIOobject,
364  rDeltaT*(rho*vf - rho.oldTime()*vf.oldTime())
365  )
366  );
367  }
368 }
369 
370 
371 template<class Type>
372 tmp<GeometricField<Type, fvPatchField, volMesh> >
373 CoEulerDdtScheme<Type>::fvcDdt
374 (
375  const volScalarField& alpha,
376  const volScalarField& rho,
377  const GeometricField<Type, fvPatchField, volMesh>& vf
378 )
379 {
380  const volScalarField rDeltaT(CorDeltaT());
381 
382  IOobject ddtIOobject
383  (
384  "ddt("+alpha.name()+','+rho.name()+','+vf.name()+')',
385  mesh().time().timeName(),
386  mesh()
387  );
388 
389  if (mesh().moving())
390  {
391  return tmp<GeometricField<Type, fvPatchField, volMesh> >
392  (
393  new GeometricField<Type, fvPatchField, volMesh>
394  (
395  ddtIOobject,
396  mesh(),
397  rDeltaT.dimensions()
398  *alpha.dimensions()*rho.dimensions()*vf.dimensions(),
399  rDeltaT.internalField()*
400  (
401  alpha.internalField()
402  *rho.internalField()
403  *vf.internalField()
404 
405  - alpha.oldTime().internalField()
406  *rho.oldTime().internalField()
407  *vf.oldTime().internalField()*mesh().Vsc0()/mesh().Vsc()
408  ),
409  rDeltaT.boundaryField()*
410  (
411  alpha.boundaryField()
412  *rho.boundaryField()
413  *vf.boundaryField()
414 
415  - alpha.oldTime().boundaryField()
416  *rho.oldTime().boundaryField()
417  *vf.oldTime().boundaryField()
418  )
419  )
420  );
421  }
422  else
423  {
424  return tmp<GeometricField<Type, fvPatchField, volMesh> >
425  (
426  new GeometricField<Type, fvPatchField, volMesh>
427  (
428  ddtIOobject,
429  rDeltaT
430  *(
431  alpha*rho*vf
432  - alpha.oldTime()*rho.oldTime()*vf.oldTime()
433  )
434  )
435  );
436  }
437 }
438 
439 
440 template<class Type>
441 tmp<fvMatrix<Type> >
442 CoEulerDdtScheme<Type>::fvmDdt
443 (
444  const GeometricField<Type, fvPatchField, volMesh>& vf
445 )
446 {
447  tmp<fvMatrix<Type> > tfvm
448  (
449  new fvMatrix<Type>
450  (
451  vf,
452  vf.dimensions()*dimVol/dimTime
453  )
454  );
455 
456  fvMatrix<Type>& fvm = tfvm();
457 
458  scalarField rDeltaT(CorDeltaT()().internalField());
459 
460  fvm.diag() = rDeltaT*mesh().Vsc();
461 
462  if (mesh().moving())
463  {
464  fvm.source() = rDeltaT*vf.oldTime().internalField()*mesh().Vsc0();
465  }
466  else
467  {
468  fvm.source() = rDeltaT*vf.oldTime().internalField()*mesh().Vsc();
469  }
470 
471  return tfvm;
472 }
473 
474 
475 template<class Type>
476 tmp<fvMatrix<Type> >
477 CoEulerDdtScheme<Type>::fvmDdt
478 (
479  const dimensionedScalar& rho,
480  const GeometricField<Type, fvPatchField, volMesh>& vf
481 )
482 {
483  tmp<fvMatrix<Type> > tfvm
484  (
485  new fvMatrix<Type>
486  (
487  vf,
488  rho.dimensions()*vf.dimensions()*dimVol/dimTime
489  )
490  );
491  fvMatrix<Type>& fvm = tfvm();
492 
493  scalarField rDeltaT(CorDeltaT()().internalField());
494 
495  fvm.diag() = rDeltaT*rho.value()*mesh().Vsc();
496 
497  if (mesh().moving())
498  {
499  fvm.source() = rDeltaT
500  *rho.value()*vf.oldTime().internalField()*mesh().Vsc0();
501  }
502  else
503  {
504  fvm.source() = rDeltaT
505  *rho.value()*vf.oldTime().internalField()*mesh().Vsc();
506  }
507 
508  return tfvm;
509 }
510 
511 
512 template<class Type>
513 tmp<fvMatrix<Type> >
514 CoEulerDdtScheme<Type>::fvmDdt
515 (
516  const volScalarField& rho,
517  const GeometricField<Type, fvPatchField, volMesh>& vf
518 )
519 {
520  tmp<fvMatrix<Type> > tfvm
521  (
522  new fvMatrix<Type>
523  (
524  vf,
525  rho.dimensions()*vf.dimensions()*dimVol/dimTime
526  )
527  );
528  fvMatrix<Type>& fvm = tfvm();
529 
530  scalarField rDeltaT(CorDeltaT()().internalField());
531 
532  fvm.diag() = rDeltaT*rho.internalField()*mesh().Vsc();
533 
534  if (mesh().moving())
535  {
536  fvm.source() = rDeltaT
537  *rho.oldTime().internalField()
538  *vf.oldTime().internalField()*mesh().Vsc0();
539  }
540  else
541  {
542  fvm.source() = rDeltaT
543  *rho.oldTime().internalField()
544  *vf.oldTime().internalField()*mesh().Vsc();
545  }
546 
547  return tfvm;
548 }
549 
550 
551 template<class Type>
552 tmp<fvMatrix<Type> >
553 CoEulerDdtScheme<Type>::fvmDdt
554 (
555  const volScalarField& alpha,
556  const volScalarField& rho,
557  const GeometricField<Type, fvPatchField, volMesh>& vf
558 )
559 {
560  tmp<fvMatrix<Type> > tfvm
561  (
562  new fvMatrix<Type>
563  (
564  vf,
565  alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime
566  )
567  );
568  fvMatrix<Type>& fvm = tfvm();
569 
570  scalarField rDeltaT(CorDeltaT()().internalField());
571 
572  fvm.diag() = rDeltaT*alpha.internalField()*rho.internalField()*mesh().Vsc();
573 
574  if (mesh().moving())
575  {
576  fvm.source() = rDeltaT
577  *alpha.oldTime().internalField()
578  *rho.oldTime().internalField()
579  *vf.oldTime().internalField()*mesh().Vsc0();
580  }
581  else
582  {
583  fvm.source() = rDeltaT
584  *alpha.oldTime().internalField()
585  *rho.oldTime().internalField()
586  *vf.oldTime().internalField()*mesh().Vsc();
587  }
588 
589  return tfvm;
590 }
591 
592 
593 template<class Type>
594 tmp<typename CoEulerDdtScheme<Type>::fluxFieldType>
595 CoEulerDdtScheme<Type>::fvcDdtUfCorr
596 (
597  const GeometricField<Type, fvPatchField, volMesh>& U,
598  const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf
599 )
600 {
601  const surfaceScalarField rDeltaT(fvc::interpolate(CorDeltaT()));
602 
603  fluxFieldType phiCorr
604  (
605  mesh().Sf() & (Uf.oldTime() - fvc::interpolate(U.oldTime()))
606  );
607 
608  return tmp<fluxFieldType>
609  (
610  new fluxFieldType
611  (
612  IOobject
613  (
614  "ddtCorr(" + U.name() + ',' + Uf.name() + ')',
615  mesh().time().timeName(),
616  mesh()
617  ),
618  this->fvcDdtPhiCoeff
619  (
620  U.oldTime(),
621  (mesh().Sf() & Uf.oldTime()),
622  phiCorr
623  )
624  *rDeltaT*phiCorr
625  )
626  );
627 }
628 
629 
630 template<class Type>
631 tmp<typename CoEulerDdtScheme<Type>::fluxFieldType>
632 CoEulerDdtScheme<Type>::fvcDdtPhiCorr
633 (
634  const GeometricField<Type, fvPatchField, volMesh>& U,
635  const fluxFieldType& phi
636 )
637 {
638  const surfaceScalarField rDeltaT(fvc::interpolate(CorDeltaT()));
639 
640  fluxFieldType phiCorr
641  (
642  phi.oldTime() - (mesh().Sf() & fvc::interpolate(U.oldTime()))
643  );
644 
645  return tmp<fluxFieldType>
646  (
647  new fluxFieldType
648  (
649  IOobject
650  (
651  "ddtCorr(" + U.name() + ',' + phi.name() + ')',
652  mesh().time().timeName(),
653  mesh()
654  ),
655  this->fvcDdtPhiCoeff(U.oldTime(), phi.oldTime(), phiCorr)
656  *rDeltaT*phiCorr
657  )
658  );
659 }
660 
661 
662 template<class Type>
663 tmp<typename CoEulerDdtScheme<Type>::fluxFieldType>
664 CoEulerDdtScheme<Type>::fvcDdtUfCorr
665 (
666  const volScalarField& rho,
667  const GeometricField<Type, fvPatchField, volMesh>& U,
668  const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf
669 )
670 {
671  if
672  (
673  U.dimensions() == dimVelocity
674  && Uf.dimensions() == dimDensity*dimVelocity
675  )
676  {
677  const surfaceScalarField rDeltaT(fvc::interpolate(CorDeltaT()));
678 
679  GeometricField<Type, fvPatchField, volMesh> rhoU0
680  (
681  rho.oldTime()*U.oldTime()
682  );
683 
684  fluxFieldType phiCorr
685  (
686  mesh().Sf() & (Uf.oldTime() - fvc::interpolate(rhoU0))
687  );
688 
689  return tmp<fluxFieldType>
690  (
691  new fluxFieldType
692  (
693  IOobject
694  (
695  "ddtCorr("
696  + rho.name() + ',' + U.name() + ',' + Uf.name() + ')',
697  mesh().time().timeName(),
698  mesh()
699  ),
700  this->fvcDdtPhiCoeff
701  (
702  rhoU0,
703  mesh().Sf() & Uf.oldTime(),
704  phiCorr
705  )
706  *rDeltaT*phiCorr
707  )
708  );
709  }
710  else if
711  (
712  U.dimensions() == dimDensity*dimVelocity
713  && Uf.dimensions() == dimDensity*dimVelocity
714  )
715  {
716  return fvcDdtUfCorr(U, Uf);
717  }
718  else
719  {
720  FatalErrorIn
721  (
722  "CoEulerDdtScheme<Type>::fvcDdtPhiCorr"
723  ) << "dimensions of Uf are not correct"
724  << abort(FatalError);
725 
726  return fluxFieldType::null();
727  }
728 }
729 
730 
731 template<class Type>
732 tmp<typename CoEulerDdtScheme<Type>::fluxFieldType>
733 CoEulerDdtScheme<Type>::fvcDdtPhiCorr
734 (
735  const volScalarField& rho,
736  const GeometricField<Type, fvPatchField, volMesh>& U,
737  const fluxFieldType& phi
738 )
739 {
740  if
741  (
742  U.dimensions() == dimVelocity
743  && phi.dimensions() == rho.dimensions()*dimVelocity*dimArea
744  )
745  {
746  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
747 
748  GeometricField<Type, fvPatchField, volMesh> rhoU0
749  (
750  rho.oldTime()*U.oldTime()
751  );
752 
753  fluxFieldType phiCorr
754  (
755  phi.oldTime() - (mesh().Sf() & fvc::interpolate(rhoU0))
756  );
757 
758  return tmp<fluxFieldType>
759  (
760  new fluxFieldType
761  (
762  IOobject
763  (
764  "ddtCorr("
765  + rho.name() + ',' + U.name() + ',' + phi.name() + ')',
766  mesh().time().timeName(),
767  mesh()
768  ),
769  this->fvcDdtPhiCoeff(rhoU0, phi.oldTime(), phiCorr)
770  *rDeltaT*phiCorr
771  )
772  );
773  }
774  else if
775  (
776  U.dimensions() == rho.dimensions()*dimVelocity
777  && phi.dimensions() == rho.dimensions()*dimVelocity*dimArea
778  )
779  {
780  return fvcDdtPhiCorr(U, phi);
781  }
782  else
783  {
784  FatalErrorIn
785  (
786  "CoEulerDdtScheme<Type>::fvcDdtPhiCorr"
787  ) << "dimensions of phi are not correct"
788  << abort(FatalError);
789 
790  return fluxFieldType::null();
791  }
792 }
793 
794 
795 template<class Type>
796 tmp<surfaceScalarField> CoEulerDdtScheme<Type>::meshPhi
797 (
798  const GeometricField<Type, fvPatchField, volMesh>&
799 )
800 {
801  return tmp<surfaceScalarField>
802  (
803  new surfaceScalarField
804  (
805  IOobject
806  (
807  "meshPhi",
808  mesh().time().timeName(),
809  mesh(),
810  IOobject::NO_READ,
811  IOobject::NO_WRITE
812  ),
813  mesh(),
814  dimensionedScalar("0", dimVolume/dimTime, 0.0)
815  )
816  );
817 }
818 
819 
820 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
821 
822 } // End namespace fv
823 
824 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
825 
826 } // End namespace Foam
827 
828 // ************************************************************************* //
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::labelUList
UList< label > labelUList
Definition: UList.H:63
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::mag
dimensioned< scalar > mag(const dimensioned< Type > &)
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::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
surfaceInterpolate.H
Surface Interpolation.
Foam::surfaceInterpolation::deltaCoeffs
const surfaceScalarField & deltaCoeffs() const
Return reference to cell-centre difference coefficients.
Definition: surfaceInterpolation.C:89
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
mesh
dynamicFvMesh & mesh
Definition: createDynamicFvMesh.H:18
Foam::dimDensity
const dimensionSet dimDensity
Foam
Namespace for OpenFOAM.
Definition: combustionModel.C:30
Foam::fvsPatchScalarField
fvsPatchField< scalar > fvsPatchScalarField
Definition: fvsPatchFieldsFwd.H:43
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::volScalarField
GeometricField< scalar, fvPatchField, volMesh > volScalarField
Definition: volFieldsFwd.H:52
Foam::dimensioned::name
const word & name() const
Return const reference to name.
Definition: dimensionedType.C:237
Foam::max
dimensioned< Type > max(const dimensioned< Type > &, const dimensioned< Type > &)
forAll
#define forAll(list, i)
Definition: UList.H:421
Foam::surfaceScalarField
GeometricField< scalar, fvsPatchField, surfaceMesh > surfaceScalarField
Definition: surfaceFieldsFwd.H:52
patchi
label patchi
Definition: getPatchFieldScalar.H:1
Foam::fv::CoEulerDdtScheme::fvmDdt
tmp< fvMatrix< Type > > fvmDdt(const GeometricField< Type, fvPatchField, volMesh > &)
Definition: CoEulerDdtScheme.C:443
Foam::fv::CoEulerDdtScheme::meshPhi
tmp< surfaceScalarField > meshPhi(const GeometricField< Type, fvPatchField, volMesh > &)
Definition: CoEulerDdtScheme.C:797
Foam::DimensionedField::dimensions
const dimensionSet & dimensions() const
Return dimensions.
Definition: DimensionedFieldI.H:46
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::fv::CoEulerDdtScheme::fvcDdtUfCorr
tmp< fluxFieldType > fvcDdtUfCorr(const GeometricField< Type, fvPatchField, volMesh > &U, const GeometricField< Type, fvsPatchField, surfaceMesh > &Uf)
Definition: CoEulerDdtScheme.C:596
Foam::fv::CoEulerDdtScheme::fvcDdtPhiCorr
tmp< fluxFieldType > fvcDdtPhiCorr(const GeometricField< Type, fvPatchField, volMesh > &U, const fluxFieldType &phi)
Definition: CoEulerDdtScheme.C:633
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
Foam::dimVolume
const dimensionSet dimVolume(pow3(dimLength))
Definition: dimensionSets.H:58
fv
labelList fv(nPoints)
Foam::fv::CoEulerDdtScheme::fvcDdt
tmp< GeometricField< Type, fvPatchField, volMesh > > fvcDdt(const dimensioned< Type > &)
Definition: CoEulerDdtScheme.C:156
Foam::fvMatrix::source
Field< Type > & source()
Definition: fvMatrix.H:291
Foam::dimVelocity
const dimensionSet dimVelocity
Foam::dimensionedScalar
dimensioned< scalar > dimensionedScalar
Dimensioned scalar obtained from generic dimensioned type.
Definition: dimensionedScalarFwd.H:41
Foam::tmp
A class for managing temporary objects.
Definition: PtrList.H:118
internalField
conserve internalField()+
Foam::dimensioned::value
const Type & value() const
Return const reference to value.
Definition: dimensionedType.C:263
timeName
word timeName
Definition: getTimeIndex.H:3
fvMatrices.H
A special matrix type and solver, designed for finite volume solutions of scalar equations.
Generated by   doxygen 1.8.11