backwardDdtScheme.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-2016 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 "backwardDdtScheme.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 scalar backwardDdtScheme<Type>::deltaT_() const
45 {
46  return mesh().time().deltaTValue();
47 }
48 
49 
50 template<class Type>
51 scalar backwardDdtScheme<Type>::deltaT0_() const
52 {
53  return mesh().time().deltaT0Value();
54 }
55 
56 
57 template<class Type>
58 template<class GeoField>
59 scalar backwardDdtScheme<Type>::deltaT0_(const GeoField& vf) const
60 {
61  if (vf.nOldTimes() < 2)
62  {
63  return GREAT;
64  }
65  else
66  {
67  return deltaT0_();
68  }
69 }
70 
71 
72 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
73 
74 template<class Type>
75 tmp<GeometricField<Type, fvPatchField, volMesh>>
76 backwardDdtScheme<Type>::fvcDdt
77 (
78  const dimensioned<Type>& dt
79 )
80 {
81  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
82 
83  IOobject ddtIOobject
84  (
85  "ddt("+dt.name()+')',
86  mesh().time().timeName(),
87  mesh()
88  );
89 
90  scalar deltaT = deltaT_();
91  scalar deltaT0 = deltaT0_();
92 
93  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
94  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
95  scalar coefft0 = coefft + coefft00;
96 
97  if (mesh().moving())
98  {
99  tmp<GeometricField<Type, fvPatchField, volMesh>> tdtdt
100  (
101  new GeometricField<Type, fvPatchField, volMesh>
102  (
103  ddtIOobject,
104  mesh(),
105  dimensioned<Type>
106  (
107  "0",
108  dt.dimensions()/dimTime,
109  Zero
110  )
111  )
112  );
113 
114  tdtdt.ref().primitiveFieldRef() = rDeltaT.value()*dt.value()*
115  (
116  coefft - (coefft0*mesh().V0() - coefft00*mesh().V00())/mesh().V()
117  );
118 
119  return tdtdt;
120  }
121  else
122  {
123  return tmp<GeometricField<Type, fvPatchField, volMesh>>
124  (
125  new GeometricField<Type, fvPatchField, volMesh>
126  (
127  ddtIOobject,
128  mesh(),
129  dimensioned<Type>
130  (
131  "0",
132  dt.dimensions()/dimTime,
133  Zero
134  ),
135  calculatedFvPatchField<Type>::typeName
136  )
137  );
138  }
139 }
140 
141 
142 template<class Type>
143 tmp<GeometricField<Type, fvPatchField, volMesh>>
144 backwardDdtScheme<Type>::fvcDdt
145 (
146  const GeometricField<Type, fvPatchField, volMesh>& vf
147 )
148 {
149  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
150 
151  IOobject ddtIOobject
152  (
153  "ddt("+vf.name()+')',
154  mesh().time().timeName(),
155  mesh()
156  );
157 
158  scalar deltaT = deltaT_();
159  scalar deltaT0 = deltaT0_(vf);
160 
161  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
162  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
163  scalar coefft0 = coefft + coefft00;
164 
165  if (mesh().moving())
166  {
167  return tmp<GeometricField<Type, fvPatchField, volMesh>>
168  (
169  new GeometricField<Type, fvPatchField, volMesh>
170  (
171  ddtIOobject,
172  mesh(),
173  rDeltaT.dimensions()*vf.dimensions(),
174  rDeltaT.value()*
175  (
176  coefft*vf.primitiveField() -
177  (
178  coefft0*vf.oldTime().primitiveField()*mesh().V0()
179  - coefft00*vf.oldTime().oldTime().primitiveField()
180  *mesh().V00()
181  )/mesh().V()
182  ),
183  rDeltaT.value()*
184  (
185  coefft*vf.boundaryField() -
186  (
187  coefft0*vf.oldTime().boundaryField()
188  - coefft00*vf.oldTime().oldTime().boundaryField()
189  )
190  )
191  )
192  );
193  }
194  else
195  {
196  return tmp<GeometricField<Type, fvPatchField, volMesh>>
197  (
198  new GeometricField<Type, fvPatchField, volMesh>
199  (
200  ddtIOobject,
201  rDeltaT*
202  (
203  coefft*vf
204  - coefft0*vf.oldTime()
205  + coefft00*vf.oldTime().oldTime()
206  )
207  )
208  );
209  }
210 }
211 
212 
213 template<class Type>
214 tmp<GeometricField<Type, fvPatchField, volMesh>>
215 backwardDdtScheme<Type>::fvcDdt
216 (
217  const dimensionedScalar& rho,
218  const GeometricField<Type, fvPatchField, volMesh>& vf
219 )
220 {
221  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
222 
223  IOobject ddtIOobject
224  (
225  "ddt("+rho.name()+','+vf.name()+')',
226  mesh().time().timeName(),
227  mesh()
228  );
229 
230  scalar deltaT = deltaT_();
231  scalar deltaT0 = deltaT0_(vf);
232 
233  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
234  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
235  scalar coefft0 = coefft + coefft00;
236 
237  if (mesh().moving())
238  {
239  return tmp<GeometricField<Type, fvPatchField, volMesh>>
240  (
241  new GeometricField<Type, fvPatchField, volMesh>
242  (
243  ddtIOobject,
244  mesh(),
245  rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
246  rDeltaT.value()*rho.value()*
247  (
248  coefft*vf.primitiveField() -
249  (
250  coefft0*vf.oldTime().primitiveField()*mesh().V0()
251  - coefft00*vf.oldTime().oldTime().primitiveField()
252  *mesh().V00()
253  )/mesh().V()
254  ),
255  rDeltaT.value()*rho.value()*
256  (
257  coefft*vf.boundaryField() -
258  (
259  coefft0*vf.oldTime().boundaryField()
260  - coefft00*vf.oldTime().oldTime().boundaryField()
261  )
262  )
263  )
264  );
265  }
266  else
267  {
268  return tmp<GeometricField<Type, fvPatchField, volMesh>>
269  (
270  new GeometricField<Type, fvPatchField, volMesh>
271  (
272  ddtIOobject,
273  rDeltaT*rho*
274  (
275  coefft*vf
276  - coefft0*vf.oldTime()
277  + coefft00*vf.oldTime().oldTime()
278  )
279  )
280  );
281  }
282 }
283 
284 
285 template<class Type>
286 tmp<GeometricField<Type, fvPatchField, volMesh>>
287 backwardDdtScheme<Type>::fvcDdt
288 (
289  const volScalarField& rho,
290  const GeometricField<Type, fvPatchField, volMesh>& vf
291 )
292 {
293  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
294 
295  IOobject ddtIOobject
296  (
297  "ddt("+rho.name()+','+vf.name()+')',
298  mesh().time().timeName(),
299  mesh()
300  );
301 
302  scalar deltaT = deltaT_();
303  scalar deltaT0 = deltaT0_(vf);
304 
305  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
306  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
307  scalar coefft0 = coefft + coefft00;
308 
309  if (mesh().moving())
310  {
311  return tmp<GeometricField<Type, fvPatchField, volMesh>>
312  (
313  new GeometricField<Type, fvPatchField, volMesh>
314  (
315  ddtIOobject,
316  mesh(),
317  rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
318  rDeltaT.value()*
319  (
320  coefft*rho.primitiveField()*vf.primitiveField() -
321  (
322  coefft0*rho.oldTime().primitiveField()
323  *vf.oldTime().primitiveField()*mesh().V0()
324  - coefft00*rho.oldTime().oldTime().primitiveField()
325  *vf.oldTime().oldTime().primitiveField()*mesh().V00()
326  )/mesh().V()
327  ),
328  rDeltaT.value()*
329  (
330  coefft*rho.boundaryField()*vf.boundaryField() -
331  (
332  coefft0*rho.oldTime().boundaryField()
333  *vf.oldTime().boundaryField()
334  - coefft00*rho.oldTime().oldTime().boundaryField()
335  *vf.oldTime().oldTime().boundaryField()
336  )
337  )
338  )
339  );
340  }
341  else
342  {
343  return tmp<GeometricField<Type, fvPatchField, volMesh>>
344  (
345  new GeometricField<Type, fvPatchField, volMesh>
346  (
347  ddtIOobject,
348  rDeltaT*
349  (
350  coefft*rho*vf
351  - coefft0*rho.oldTime()*vf.oldTime()
352  + coefft00*rho.oldTime().oldTime()*vf.oldTime().oldTime()
353  )
354  )
355  );
356  }
357 }
358 
359 
360 template<class Type>
361 tmp<GeometricField<Type, fvPatchField, volMesh>>
362 backwardDdtScheme<Type>::fvcDdt
363 (
364  const volScalarField& alpha,
365  const volScalarField& rho,
366  const GeometricField<Type, fvPatchField, volMesh>& vf
367 )
368 {
369  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
370 
371  IOobject ddtIOobject
372  (
373  "ddt("+alpha.name()+','+rho.name()+','+vf.name()+')',
374  mesh().time().timeName(),
375  mesh()
376  );
377 
378  scalar deltaT = deltaT_();
379  scalar deltaT0 = deltaT0_(vf);
380 
381  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
382  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
383  scalar coefft0 = coefft + coefft00;
384 
385  if (mesh().moving())
386  {
387  return tmp<GeometricField<Type, fvPatchField, volMesh>>
388  (
389  new GeometricField<Type, fvPatchField, volMesh>
390  (
391  ddtIOobject,
392  mesh(),
393  rDeltaT.dimensions()
394  *alpha.dimensions()*rho.dimensions()*vf.dimensions(),
395  rDeltaT.value()*
396  (
397  coefft
398  *alpha.primitiveField()
399  *rho.primitiveField()
400  *vf.primitiveField() -
401  (
402  coefft0
403  *alpha.oldTime().primitiveField()
404  *rho.oldTime().primitiveField()
405  *vf.oldTime().primitiveField()*mesh().V0()
406 
407  - coefft00
408  *alpha.oldTime().oldTime().primitiveField()
409  *rho.oldTime().oldTime().primitiveField()
410  *vf.oldTime().oldTime().primitiveField()*mesh().V00()
411  )/mesh().V()
412  ),
413  rDeltaT.value()*
414  (
415  coefft
416  *alpha.boundaryField()
417  *rho.boundaryField()
418  *vf.boundaryField() -
419  (
420  coefft0
421  *alpha.oldTime().boundaryField()
422  *rho.oldTime().boundaryField()
423  *vf.oldTime().boundaryField()
424 
425  - coefft00
426  *alpha.oldTime().oldTime().boundaryField()
427  *rho.oldTime().oldTime().boundaryField()
428  *vf.oldTime().oldTime().boundaryField()
429  )
430  )
431  )
432  );
433  }
434  else
435  {
436  return tmp<GeometricField<Type, fvPatchField, volMesh>>
437  (
438  new GeometricField<Type, fvPatchField, volMesh>
439  (
440  ddtIOobject,
441  rDeltaT*
442  (
443  coefft*alpha*rho*vf
444  - coefft0*alpha.oldTime()*rho.oldTime()*vf.oldTime()
445  + coefft00*alpha.oldTime().oldTime()
446  *rho.oldTime().oldTime()*vf.oldTime().oldTime()
447  )
448  )
449  );
450  }
451 }
452 
453 
454 template<class Type>
455 tmp<fvMatrix<Type>>
456 backwardDdtScheme<Type>::fvmDdt
457 (
458  const GeometricField<Type, fvPatchField, volMesh>& vf
459 )
460 {
461  tmp<fvMatrix<Type>> tfvm
462  (
463  new fvMatrix<Type>
464  (
465  vf,
466  vf.dimensions()*dimVol/dimTime
467  )
468  );
469 
470  fvMatrix<Type>& fvm = tfvm.ref();
471 
472  scalar rDeltaT = 1.0/deltaT_();
473 
474  scalar deltaT = deltaT_();
475  scalar deltaT0 = deltaT0_(vf);
476 
477  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
478  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
479  scalar coefft0 = coefft + coefft00;
480 
481  fvm.diag() = (coefft*rDeltaT)*mesh().V();
482 
483  if (mesh().moving())
484  {
485  fvm.source() = rDeltaT*
486  (
487  coefft0*vf.oldTime().primitiveField()*mesh().V0()
488  - coefft00*vf.oldTime().oldTime().primitiveField()
489  *mesh().V00()
490  );
491  }
492  else
493  {
494  fvm.source() = rDeltaT*mesh().V()*
495  (
496  coefft0*vf.oldTime().primitiveField()
497  - coefft00*vf.oldTime().oldTime().primitiveField()
498  );
499  }
500 
501  return tfvm;
502 }
503 
504 
505 template<class Type>
506 tmp<fvMatrix<Type>>
507 backwardDdtScheme<Type>::fvmDdt
508 (
509  const dimensionedScalar& rho,
510  const GeometricField<Type, fvPatchField, volMesh>& vf
511 )
512 {
513  tmp<fvMatrix<Type>> tfvm
514  (
515  new fvMatrix<Type>
516  (
517  vf,
518  rho.dimensions()*vf.dimensions()*dimVol/dimTime
519  )
520  );
521  fvMatrix<Type>& fvm = tfvm.ref();
522 
523  scalar rDeltaT = 1.0/deltaT_();
524 
525  scalar deltaT = deltaT_();
526  scalar deltaT0 = deltaT0_(vf);
527 
528  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
529  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
530  scalar coefft0 = coefft + coefft00;
531 
532  fvm.diag() = (coefft*rDeltaT*rho.value())*mesh().V();
533 
534  if (mesh().moving())
535  {
536  fvm.source() = rDeltaT*rho.value()*
537  (
538  coefft0*vf.oldTime().primitiveField()*mesh().V0()
539  - coefft00*vf.oldTime().oldTime().primitiveField()
540  *mesh().V00()
541  );
542  }
543  else
544  {
545  fvm.source() = rDeltaT*mesh().V()*rho.value()*
546  (
547  coefft0*vf.oldTime().primitiveField()
548  - coefft00*vf.oldTime().oldTime().primitiveField()
549  );
550  }
551 
552  return tfvm;
553 }
554 
555 
556 template<class Type>
557 tmp<fvMatrix<Type>>
558 backwardDdtScheme<Type>::fvmDdt
559 (
560  const volScalarField& rho,
561  const GeometricField<Type, fvPatchField, volMesh>& vf
562 )
563 {
564  tmp<fvMatrix<Type>> tfvm
565  (
566  new fvMatrix<Type>
567  (
568  vf,
569  rho.dimensions()*vf.dimensions()*dimVol/dimTime
570  )
571  );
572  fvMatrix<Type>& fvm = tfvm.ref();
573 
574  scalar rDeltaT = 1.0/deltaT_();
575 
576  scalar deltaT = deltaT_();
577  scalar deltaT0 = deltaT0_(vf);
578 
579  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
580  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
581  scalar coefft0 = coefft + coefft00;
582 
583  fvm.diag() = (coefft*rDeltaT)*rho.primitiveField()*mesh().V();
584 
585  if (mesh().moving())
586  {
587  fvm.source() = rDeltaT*
588  (
589  coefft0*rho.oldTime().primitiveField()
590  *vf.oldTime().primitiveField()*mesh().V0()
591  - coefft00*rho.oldTime().oldTime().primitiveField()
592  *vf.oldTime().oldTime().primitiveField()*mesh().V00()
593  );
594  }
595  else
596  {
597  fvm.source() = rDeltaT*mesh().V()*
598  (
599  coefft0*rho.oldTime().primitiveField()
600  *vf.oldTime().primitiveField()
601  - coefft00*rho.oldTime().oldTime().primitiveField()
602  *vf.oldTime().oldTime().primitiveField()
603  );
604  }
605 
606  return tfvm;
607 }
608 
609 
610 template<class Type>
611 tmp<fvMatrix<Type>>
612 backwardDdtScheme<Type>::fvmDdt
613 (
614  const volScalarField& alpha,
615  const volScalarField& rho,
616  const GeometricField<Type, fvPatchField, volMesh>& vf
617 )
618 {
619  tmp<fvMatrix<Type>> tfvm
620  (
621  new fvMatrix<Type>
622  (
623  vf,
624  alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime
625  )
626  );
627  fvMatrix<Type>& fvm = tfvm.ref();
628 
629  scalar rDeltaT = 1.0/deltaT_();
630 
631  scalar deltaT = deltaT_();
632  scalar deltaT0 = deltaT0_(vf);
633 
634  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
635  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
636  scalar coefft0 = coefft + coefft00;
637 
638  fvm.diag() =
639  (coefft*rDeltaT)*alpha.primitiveField()*rho.primitiveField()*mesh().V();
640 
641  if (mesh().moving())
642  {
643  fvm.source() = rDeltaT*
644  (
645  coefft0
646  *alpha.oldTime().primitiveField()
647  *rho.oldTime().primitiveField()
648  *vf.oldTime().primitiveField()*mesh().V0()
649 
650  - coefft00
651  *alpha.oldTime().oldTime().primitiveField()
652  *rho.oldTime().oldTime().primitiveField()
653  *vf.oldTime().oldTime().primitiveField()*mesh().V00()
654  );
655  }
656  else
657  {
658  fvm.source() = rDeltaT*mesh().V()*
659  (
660  coefft0
661  *alpha.oldTime().primitiveField()
662  *rho.oldTime().primitiveField()
663  *vf.oldTime().primitiveField()
664 
665  - coefft00
666  *alpha.oldTime().oldTime().primitiveField()
667  *rho.oldTime().oldTime().primitiveField()
668  *vf.oldTime().oldTime().primitiveField()
669  );
670  }
671 
672  return tfvm;
673 }
674 
675 
676 template<class Type>
677 tmp<typename backwardDdtScheme<Type>::fluxFieldType>
678 backwardDdtScheme<Type>::fvcDdtUfCorr
679 (
680  const GeometricField<Type, fvPatchField, volMesh>& U,
681  const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf
682 )
683 {
684  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
685 
686  scalar deltaT = deltaT_();
687  scalar deltaT0 = deltaT0_(U);
688 
689  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
690  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
691  scalar coefft0 = coefft + coefft00;
692 
693  return tmp<fluxFieldType>
694  (
695  new fluxFieldType
696  (
697  IOobject
698  (
699  "ddtCorr(" + U.name() + ',' + Uf.name() + ')',
700  mesh().time().timeName(),
701  mesh()
702  ),
703  this->fvcDdtPhiCoeff(U.oldTime(), (mesh().Sf() & Uf.oldTime()))
704  *rDeltaT
705  *(
706  mesh().Sf()
707  & (
708  (coefft0*Uf.oldTime() - coefft00*Uf.oldTime().oldTime())
709  - fvc::interpolate
710  (
711  coefft0*U.oldTime() - coefft00*U.oldTime().oldTime()
712  )
713  )
714  )
715  )
716  );
717 }
718 
719 
720 template<class Type>
721 tmp<typename backwardDdtScheme<Type>::fluxFieldType>
722 backwardDdtScheme<Type>::fvcDdtPhiCorr
723 (
724  const GeometricField<Type, fvPatchField, volMesh>& U,
725  const fluxFieldType& phi
726 )
727 {
728  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
729 
730  scalar deltaT = deltaT_();
731  scalar deltaT0 = deltaT0_(U);
732 
733  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
734  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
735  scalar coefft0 = coefft + coefft00;
736 
737  return tmp<fluxFieldType>
738  (
739  new fluxFieldType
740  (
741  IOobject
742  (
743  "ddtCorr(" + U.name() + ',' + phi.name() + ')',
744  mesh().time().timeName(),
745  mesh()
746  ),
747  this->fvcDdtPhiCoeff(U.oldTime(), phi.oldTime())
748  *rDeltaT
749  *(
750  (coefft0*phi.oldTime() - coefft00*phi.oldTime().oldTime())
751  - fvc::dotInterpolate
752  (
753  mesh().Sf(),
754  coefft0*U.oldTime() - coefft00*U.oldTime().oldTime()
755  )
756  )
757  )
758  );
759 }
760 
761 
762 template<class Type>
763 tmp<typename backwardDdtScheme<Type>::fluxFieldType>
764 backwardDdtScheme<Type>::fvcDdtUfCorr
765 (
766  const volScalarField& rho,
767  const GeometricField<Type, fvPatchField, volMesh>& U,
768  const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf
769 )
770 {
771  if
772  (
773  U.dimensions() == dimVelocity
774  && Uf.dimensions() == rho.dimensions()*dimVelocity
775  )
776  {
777  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
778 
779  scalar deltaT = deltaT_();
780  scalar deltaT0 = deltaT0_(U);
781 
782  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
783  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
784  scalar coefft0 = coefft + coefft00;
785 
786  GeometricField<Type, fvPatchField, volMesh> rhoU0
787  (
788  rho.oldTime()*U.oldTime()
789  );
790 
791  GeometricField<Type, fvPatchField, volMesh> rhoU00
792  (
793  rho.oldTime().oldTime()*U.oldTime().oldTime()
794  );
795 
796  return tmp<fluxFieldType>
797  (
798  new fluxFieldType
799  (
800  IOobject
801  (
802  "ddtCorr("
803  + rho.name() + ',' + U.name() + ',' + Uf.name() + ')',
804  mesh().time().timeName(),
805  mesh()
806  ),
807  this->fvcDdtPhiCoeff(rhoU0, mesh().Sf() & Uf.oldTime())
808  *rDeltaT
809  *(
810  mesh().Sf()
811  & (
812  (coefft0*Uf.oldTime() - coefft00*Uf.oldTime().oldTime())
813  - fvc::interpolate(coefft0*rhoU0 - coefft00*rhoU00)
814  )
815  )
816  )
817  );
818  }
819  else if
820  (
821  U.dimensions() == rho.dimensions()*dimVelocity
822  && Uf.dimensions() == rho.dimensions()*dimVelocity
823  )
824  {
825  return fvcDdtUfCorr(U, Uf);
826  }
827  else
828  {
829  FatalErrorInFunction
830  << "dimensions of phi are not correct"
831  << abort(FatalError);
832 
833  return fluxFieldType::null();
834  }
835 }
836 
837 
838 template<class Type>
839 tmp<typename backwardDdtScheme<Type>::fluxFieldType>
840 backwardDdtScheme<Type>::fvcDdtPhiCorr
841 (
842  const volScalarField& rho,
843  const GeometricField<Type, fvPatchField, volMesh>& U,
844  const fluxFieldType& phi
845 )
846 {
847  if
848  (
849  U.dimensions() == dimVelocity
850  && phi.dimensions() == rho.dimensions()*dimVelocity*dimArea
851  )
852  {
853  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
854 
855  scalar deltaT = deltaT_();
856  scalar deltaT0 = deltaT0_(U);
857 
858  scalar coefft = 1 + deltaT/(deltaT + deltaT0);
859  scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
860  scalar coefft0 = coefft + coefft00;
861 
862  GeometricField<Type, fvPatchField, volMesh> rhoU0
863  (
864  rho.oldTime()*U.oldTime()
865  );
866 
867  GeometricField<Type, fvPatchField, volMesh> rhoU00
868  (
869  rho.oldTime().oldTime()*U.oldTime().oldTime()
870  );
871 
872  return tmp<fluxFieldType>
873  (
874  new fluxFieldType
875  (
876  IOobject
877  (
878  "ddtCorr("
879  + rho.name() + ',' + U.name() + ',' + phi.name() + ')',
880  mesh().time().timeName(),
881  mesh()
882  ),
883  this->fvcDdtPhiCoeff(rhoU0, phi.oldTime())
884  *rDeltaT
885  *(
886  (coefft0*phi.oldTime() - coefft00*phi.oldTime().oldTime())
887  - fvc::dotInterpolate
888  (
889  mesh().Sf(),
890  coefft0*rhoU0 - coefft00*rhoU00
891  )
892  )
893  )
894  );
895  }
896  else if
897  (
898  U.dimensions() == rho.dimensions()*dimVelocity
899  && phi.dimensions() == rho.dimensions()*dimVelocity*dimArea
900  )
901  {
902  return fvcDdtPhiCorr(U, phi);
903  }
904  else
905  {
906  FatalErrorInFunction
907  << "dimensions of phi are not correct"
908  << abort(FatalError);
909 
910  return fluxFieldType::null();
911  }
912 }
913 
914 
915 template<class Type>
916 tmp<surfaceScalarField> backwardDdtScheme<Type>::meshPhi
917 (
918  const GeometricField<Type, fvPatchField, volMesh>& vf
919 )
920 {
921  scalar deltaT = deltaT_();
922  scalar deltaT0 = deltaT0_(vf);
923 
924  // Coefficient for t-3/2 (between times 0 and 00)
925  scalar coefft0_00 = deltaT/(deltaT + deltaT0);
926 
927  // Coefficient for t-1/2 (between times n and 0)
928  scalar coefftn_0 = 1 + coefft0_00;
929 
930  return tmp<surfaceScalarField>
931  (
932  new surfaceScalarField
933  (
934  IOobject
935  (
936  mesh().phi().name(),
937  mesh().time().timeName(),
938  mesh(),
939  IOobject::NO_READ,
940  IOobject::NO_WRITE,
941  false
942  ),
943  coefftn_0*mesh().phi() - coefft0_00*mesh().phi().oldTime()
944  )
945  );
946 }
947 
948 
949 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
950 
951 } // End namespace fv
952 
953 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
954 
955 } // End namespace Foam
956 
957 // ************************************************************************* //
phi
surfaceScalarField & phi
Definition: setRegionFluidFields.H:8
oldTime
rho oldTime()
Foam::fv::backwardDdtScheme::fvmDdt
tmp< fvMatrix< Type > > fvmDdt(const GeometricField< Type, fvPatchField, volMesh > &)
Definition: backwardDdtScheme.C:457
Foam::dimensioned::dimensions
const dimensionSet & dimensions() const
Return const reference to dimensions.
Definition: dimensionedType.C:248
Foam::FatalError
error FatalError
FatalErrorInFunction
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:319
Foam::fvc::dotInterpolate
static tmp< GeometricField< typename innerProduct< vector, Type >::type, fvsPatchField, surfaceMesh > > dotInterpolate(const surfaceVectorField &Sf, const GeometricField< Type, fvPatchField, volMesh > &tvf)
Interpolate field onto faces.
Foam::fv::backwardDdtScheme::fvcDdt
tmp< GeometricField< Type, fvPatchField, volMesh > > fvcDdt(const dimensioned< Type > &)
Definition: backwardDdtScheme.C:77
Foam::dimVol
const dimensionSet dimVol(dimVolume)
Definition: dimensionSets.H:59
Foam::GeometricField::primitiveField
const Internal::FieldType & primitiveField() const
Return a const-reference to the internal field.
Definition: GeometricFieldI.H:51
Foam::dimensioned::value
const Type & value() const
Return const reference to value.
Definition: dimensionedType.C:261
Foam::GeometricField
Generic GeometricField class.
Definition: surfaceFieldsFwd.H:52
Foam::dimensioned
Generic dimensioned Type class.
Definition: dimensionedScalarFwd.H:41
Foam::fv::backwardDdtScheme::meshPhi
tmp< surfaceScalarField > meshPhi(const GeometricField< Type, fvPatchField, volMesh > &)
Definition: backwardDdtScheme.C:917
Foam::dimensioned::name
const word & name() const
Return const reference to name.
Definition: dimensionedType.C:235
Foam::GeometricField::oldTime
const GeometricField< Type, PatchField, GeoMesh > & oldTime() const
Return old time field.
Definition: GeometricField.C:809
mesh
dynamicFvMesh & mesh
Definition: createDynamicFvMesh.H:18
Foam::GeometricField::boundaryField
const Boundary & boundaryField() const
Return const-reference to the boundary field.
Definition: GeometricFieldI.H:60
fv
labelList fv(nPoints)
Foam::calculatedFvPatchField
This boundary condition is not designed to be evaluated; it is assmued that the value is assigned via...
Definition: calculatedFvPatchField.H:64
Foam::fv::backwardDdtScheme::fvcDdtPhiCorr
tmp< fluxFieldType > fvcDdtPhiCorr(const GeometricField< Type, fvPatchField, volMesh > &U, const fluxFieldType &phi)
Definition: backwardDdtScheme.C:723
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:71
timeName
word timeName
Definition: getTimeIndex.H:3
Foam::Zero
static const zero Zero
Definition: zero.H:91
Foam::fv::backwardDdtScheme::fvcDdtUfCorr
tmp< fluxFieldType > fvcDdtUfCorr(const GeometricField< Type, fvPatchField, volMesh > &U, const GeometricField< Type, fvsPatchField, surfaceMesh > &Uf)
Definition: backwardDdtScheme.C:679
Foam::abort
errorManip< error > abort(error &err)
Definition: errorManip.H:131
Foam::DimensionedField::dimensions
const dimensionSet & dimensions() const
Return dimensions.
Definition: DimensionedFieldI.H:46
fvcDiv.H
Calculate the divergence of the given field.
Foam::fvMatrix::source
Field< Type > & source()
Definition: fvMatrix.H:291
Foam::name
word name(const complex &)
Return a string representation of a complex.
Definition: complex.C:47
Foam::fvc::interpolate
static tmp< GeometricField< Type, fvsPatchField, surfaceMesh > > interpolate(const GeometricField< Type, fvPatchField, volMesh > &tvf, const surfaceScalarField &faceFlux, Istream &schemeData)
Interpolate field onto faces using scheme given by Istream.
Foam::dimTime
const dimensionSet dimTime(0, 0, 1, 0, 0, 0, 0)
Definition: dimensionSets.H:51
fvMatrices.H
A special matrix type and solver, designed for finite volume solutions of scalar equations.
Foam::tmp
A class for managing temporary objects.
Definition: PtrList.H:54
Foam::surfaceScalarField
GeometricField< scalar, fvsPatchField, surfaceMesh > surfaceScalarField
Definition: surfaceFieldsFwd.H:52
Foam::lduMatrix::diag
scalarField & diag()
Definition: lduMatrix.C:183
Foam::tmp::ref
T & ref() const
Return non-const reference or generate a fatal error.
Definition: tmpI.H:174
Foam::IOobject
IOobject defines the attributes of an object for which implicit objectRegistry management is supporte...
Definition: IOobject.H:91
Foam::IOobject::name
const word & name() const
Return name.
Definition: IOobject.H:260
Foam::dimArea
const dimensionSet dimArea(sqr(dimLength))
Definition: dimensionSets.H:57
Foam
Namespace for OpenFOAM.
Definition: combustionModel.C:30
Foam::dimVelocity
const dimensionSet dimVelocity
Generated by   doxygen 1.8.11