EulerDdtScheme.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2018 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  Zero
72  )
73  )
74  );
75 
76  tdtdt.ref().primitiveFieldRef() =
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  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  rDeltaT*
126  (
127  vf()
128  - vf.oldTime()()*mesh().Vsc0()/mesh().Vsc()
129  ),
130  rDeltaT.value()*
131  (
132  vf.boundaryField() - vf.oldTime().boundaryField()
133  )
134  )
135  );
136  }
137  else
138  {
139  return tmp<GeometricField<Type, fvPatchField, volMesh>>
140  (
141  new GeometricField<Type, fvPatchField, volMesh>
142  (
143  ddtIOobject,
144  rDeltaT*(vf - vf.oldTime())
145  )
146  );
147  }
148 }
149 
150 
151 template<class Type>
152 tmp<GeometricField<Type, fvPatchField, volMesh>>
153 EulerDdtScheme<Type>::fvcDdt
154 (
155  const dimensionedScalar& rho,
156  const GeometricField<Type, fvPatchField, volMesh>& vf
157 )
158 {
159  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
160 
161  IOobject ddtIOobject
162  (
163  "ddt("+rho.name()+','+vf.name()+')',
164  mesh().time().timeName(),
165  mesh()
166  );
167 
168  if (mesh().moving())
169  {
170  return tmp<GeometricField<Type, fvPatchField, volMesh>>
171  (
172  new GeometricField<Type, fvPatchField, volMesh>
173  (
174  ddtIOobject,
175  rDeltaT*rho*
176  (
177  vf()
178  - vf.oldTime()()*mesh().Vsc0()/mesh().Vsc()
179  ),
180  rDeltaT.value()*rho.value()*
181  (
182  vf.boundaryField() - vf.oldTime().boundaryField()
183  )
184  )
185  );
186  }
187  else
188  {
189  return tmp<GeometricField<Type, fvPatchField, volMesh>>
190  (
191  new GeometricField<Type, fvPatchField, volMesh>
192  (
193  ddtIOobject,
194  rDeltaT*rho*(vf - vf.oldTime())
195  )
196  );
197  }
198 }
199 
200 
201 template<class Type>
202 tmp<GeometricField<Type, fvPatchField, volMesh>>
203 EulerDdtScheme<Type>::fvcDdt
204 (
205  const volScalarField& rho,
206  const GeometricField<Type, fvPatchField, volMesh>& vf
207 )
208 {
209  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
210 
211  IOobject ddtIOobject
212  (
213  "ddt("+rho.name()+','+vf.name()+')',
214  mesh().time().timeName(),
215  mesh()
216  );
217 
218  if (mesh().moving())
219  {
220  return tmp<GeometricField<Type, fvPatchField, volMesh>>
221  (
222  new GeometricField<Type, fvPatchField, volMesh>
223  (
224  ddtIOobject,
225  rDeltaT*
226  (
227  rho()*vf()
228  - rho.oldTime()()
229  *vf.oldTime()()*mesh().Vsc0()/mesh().Vsc()
230  ),
231  rDeltaT.value()*
232  (
233  rho.boundaryField()*vf.boundaryField()
234  - rho.oldTime().boundaryField()
235  *vf.oldTime().boundaryField()
236  )
237  )
238  );
239  }
240  else
241  {
242  return tmp<GeometricField<Type, fvPatchField, volMesh>>
243  (
244  new GeometricField<Type, fvPatchField, volMesh>
245  (
246  ddtIOobject,
247  rDeltaT*(rho*vf - rho.oldTime()*vf.oldTime())
248  )
249  );
250  }
251 }
252 
253 
254 template<class Type>
255 tmp<GeometricField<Type, fvPatchField, volMesh>>
256 EulerDdtScheme<Type>::fvcDdt
257 (
258  const volScalarField& alpha,
259  const volScalarField& rho,
260  const GeometricField<Type, fvPatchField, volMesh>& vf
261 )
262 {
263  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
264 
265  IOobject ddtIOobject
266  (
267  "ddt("+alpha.name()+','+rho.name()+','+vf.name()+')',
268  mesh().time().timeName(),
269  mesh()
270  );
271 
272  if (mesh().moving())
273  {
274  return tmp<GeometricField<Type, fvPatchField, volMesh>>
275  (
276  new GeometricField<Type, fvPatchField, volMesh>
277  (
278  ddtIOobject,
279  rDeltaT*
280  (
281  alpha()
282  *rho()
283  *vf()
284 
285  - alpha.oldTime()()
286  *rho.oldTime()()
287  *vf.oldTime()()*mesh().Vsc0()/mesh().Vsc()
288  ),
289  rDeltaT.value()*
290  (
291  alpha.boundaryField()
292  *rho.boundaryField()
293  *vf.boundaryField()
294 
295  - alpha.oldTime().boundaryField()
296  *rho.oldTime().boundaryField()
297  *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
310  *(
311  alpha*rho*vf
312  - alpha.oldTime()*rho.oldTime()*vf.oldTime()
313  )
314  )
315  );
316  }
317 }
318 
319 
320 template<class Type>
321 tmp<GeometricField<Type, fvsPatchField, surfaceMesh>>
322 EulerDdtScheme<Type>::fvcDdt
323 (
324  const GeometricField<Type, fvsPatchField, surfaceMesh>& sf
325 )
326 {
327  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
328 
329  IOobject ddtIOobject
330  (
331  "ddt("+sf.name()+')',
332  mesh().time().timeName(),
333  mesh()
334  );
335 
336  return tmp<GeometricField<Type, fvsPatchField, surfaceMesh>>
337  (
338  new GeometricField<Type, fvsPatchField, surfaceMesh>
339  (
340  ddtIOobject,
341  rDeltaT*(sf - sf.oldTime())
342  )
343  );
344 }
345 
346 
347 template<class Type>
348 tmp<fvMatrix<Type>>
349 EulerDdtScheme<Type>::fvmDdt
350 (
351  const GeometricField<Type, fvPatchField, volMesh>& vf
352 )
353 {
354  tmp<fvMatrix<Type>> tfvm
355  (
356  new fvMatrix<Type>
357  (
358  vf,
359  vf.dimensions()*dimVol/dimTime
360  )
361  );
362 
363  fvMatrix<Type>& fvm = tfvm.ref();
364 
365  scalar rDeltaT = 1.0/mesh().time().deltaTValue();
366 
367  fvm.diag() = rDeltaT*mesh().Vsc();
368 
369  if (mesh().moving())
370  {
371  fvm.source() = rDeltaT*vf.oldTime().primitiveField()*mesh().Vsc0();
372  }
373  else
374  {
375  fvm.source() = rDeltaT*vf.oldTime().primitiveField()*mesh().Vsc();
376  }
377 
378  return tfvm;
379 }
380 
381 
382 template<class Type>
383 tmp<fvMatrix<Type>>
384 EulerDdtScheme<Type>::fvmDdt
385 (
386  const dimensionedScalar& rho,
387  const GeometricField<Type, fvPatchField, volMesh>& vf
388 )
389 {
390  tmp<fvMatrix<Type>> tfvm
391  (
392  new fvMatrix<Type>
393  (
394  vf,
395  rho.dimensions()*vf.dimensions()*dimVol/dimTime
396  )
397  );
398  fvMatrix<Type>& fvm = tfvm.ref();
399 
400  scalar rDeltaT = 1.0/mesh().time().deltaTValue();
401 
402  fvm.diag() = rDeltaT*rho.value()*mesh().Vsc();
403 
404  if (mesh().moving())
405  {
406  fvm.source() = rDeltaT
407  *rho.value()*vf.oldTime().primitiveField()*mesh().Vsc0();
408  }
409  else
410  {
411  fvm.source() = rDeltaT
412  *rho.value()*vf.oldTime().primitiveField()*mesh().Vsc();
413  }
414 
415  return tfvm;
416 }
417 
418 
419 template<class Type>
420 tmp<fvMatrix<Type>>
421 EulerDdtScheme<Type>::fvmDdt
422 (
423  const volScalarField& rho,
424  const GeometricField<Type, fvPatchField, volMesh>& vf
425 )
426 {
427  tmp<fvMatrix<Type>> tfvm
428  (
429  new fvMatrix<Type>
430  (
431  vf,
432  rho.dimensions()*vf.dimensions()*dimVol/dimTime
433  )
434  );
435  fvMatrix<Type>& fvm = tfvm.ref();
436 
437  scalar rDeltaT = 1.0/mesh().time().deltaTValue();
438 
439  fvm.diag() = rDeltaT*rho.primitiveField()*mesh().Vsc();
440 
441  if (mesh().moving())
442  {
443  fvm.source() = rDeltaT
444  *rho.oldTime().primitiveField()
445  *vf.oldTime().primitiveField()*mesh().Vsc0();
446  }
447  else
448  {
449  fvm.source() = rDeltaT
450  *rho.oldTime().primitiveField()
451  *vf.oldTime().primitiveField()*mesh().Vsc();
452  }
453 
454  return tfvm;
455 }
456 
457 
458 template<class Type>
459 tmp<fvMatrix<Type>>
460 EulerDdtScheme<Type>::fvmDdt
461 (
462  const volScalarField& alpha,
463  const volScalarField& rho,
464  const GeometricField<Type, fvPatchField, volMesh>& vf
465 )
466 {
467  tmp<fvMatrix<Type>> tfvm
468  (
469  new fvMatrix<Type>
470  (
471  vf,
472  alpha.dimensions()*rho.dimensions()*vf.dimensions()*dimVol/dimTime
473  )
474  );
475  fvMatrix<Type>& fvm = tfvm.ref();
476 
477  scalar rDeltaT = 1.0/mesh().time().deltaTValue();
478 
479  fvm.diag() =
480  rDeltaT*alpha.primitiveField()*rho.primitiveField()*mesh().Vsc();
481 
482  if (mesh().moving())
483  {
484  fvm.source() = rDeltaT
485  *alpha.oldTime().primitiveField()
486  *rho.oldTime().primitiveField()
487  *vf.oldTime().primitiveField()*mesh().Vsc0();
488  }
489  else
490  {
491  fvm.source() = rDeltaT
492  *alpha.oldTime().primitiveField()
493  *rho.oldTime().primitiveField()
494  *vf.oldTime().primitiveField()*mesh().Vsc();
495  }
496 
497  return tfvm;
498 }
499 
500 
501 template<class Type>
502 tmp<typename EulerDdtScheme<Type>::fluxFieldType>
503 EulerDdtScheme<Type>::fvcDdtUfCorr
504 (
505  const GeometricField<Type, fvPatchField, volMesh>& U,
506  const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf
507 )
508 {
509  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
510 
511  fluxFieldType phiUf0(mesh().Sf() & Uf.oldTime());
512  fluxFieldType phiCorr
513  (
514  phiUf0 - fvc::dotInterpolate(mesh().Sf(), U.oldTime())
515  );
516 
517  return tmp<fluxFieldType>
518  (
519  new fluxFieldType
520  (
521  IOobject
522  (
523  "ddtCorr(" + U.name() + ',' + Uf.name() + ')',
524  mesh().time().timeName(),
525  mesh()
526  ),
527  this->fvcDdtPhiCoeff(U.oldTime(), phiUf0, phiCorr)
528  *rDeltaT*phiCorr
529  )
530  );
531 }
532 
533 
534 template<class Type>
535 tmp<typename EulerDdtScheme<Type>::fluxFieldType>
536 EulerDdtScheme<Type>::fvcDdtPhiCorr
537 (
538  const GeometricField<Type, fvPatchField, volMesh>& U,
539  const fluxFieldType& phi
540 )
541 {
542  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
543 
544  fluxFieldType phiCorr
545  (
546  phi.oldTime() - fvc::dotInterpolate(mesh().Sf(), U.oldTime())
547  );
548 
549  return tmp<fluxFieldType>
550  (
551  new fluxFieldType
552  (
553  IOobject
554  (
555  "ddtCorr(" + U.name() + ',' + phi.name() + ')',
556  mesh().time().timeName(),
557  mesh()
558  ),
559  this->fvcDdtPhiCoeff(U.oldTime(), phi.oldTime(), phiCorr)
560  *rDeltaT*phiCorr
561  )
562  );
563 }
564 
565 
566 template<class Type>
567 tmp<typename EulerDdtScheme<Type>::fluxFieldType>
568 EulerDdtScheme<Type>::fvcDdtUfCorr
569 (
570  const volScalarField& rho,
571  const GeometricField<Type, fvPatchField, volMesh>& U,
572  const GeometricField<Type, fvsPatchField, surfaceMesh>& Uf
573 )
574 {
575  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
576 
577  if
578  (
579  U.dimensions() == dimVelocity
580  && Uf.dimensions() == rho.dimensions()*dimVelocity
581  )
582  {
583  GeometricField<Type, fvPatchField, volMesh> rhoU0
584  (
585  rho.oldTime()*U.oldTime()
586  );
587 
588  fluxFieldType phiUf0(mesh().Sf() & Uf.oldTime());
589  fluxFieldType phiCorr(phiUf0 - fvc::dotInterpolate(mesh().Sf(), rhoU0));
590 
591  return tmp<fluxFieldType>
592  (
593  new fluxFieldType
594  (
595  IOobject
596  (
597  "ddtCorr("
598  + rho.name() + ',' + U.name() + ',' + Uf.name() + ')',
599  mesh().time().timeName(),
600  mesh()
601  ),
602  this->fvcDdtPhiCoeff(rhoU0, phiUf0, phiCorr, rho.oldTime())
603  *rDeltaT*phiCorr
604  )
605  );
606  }
607  else if
608  (
609  U.dimensions() == rho.dimensions()*dimVelocity
610  && Uf.dimensions() == rho.dimensions()*dimVelocity
611  )
612  {
613  fluxFieldType phiUf0(mesh().Sf() & Uf.oldTime());
614  fluxFieldType phiCorr
615  (
616  phiUf0 - fvc::dotInterpolate(mesh().Sf(), U.oldTime())
617  );
618 
619  return tmp<fluxFieldType>
620  (
621  new fluxFieldType
622  (
623  IOobject
624  (
625  "ddtCorr("
626  + rho.name() + ',' + U.name() + ',' + Uf.name() + ')',
627  mesh().time().timeName(),
628  mesh()
629  ),
630  this->fvcDdtPhiCoeff
631  (
632  U.oldTime(),
633  phiUf0,
634  phiCorr,
635  rho.oldTime()
636  )*rDeltaT*phiCorr
637  )
638  );
639  }
640  else
641  {
642  FatalErrorInFunction
643  << "dimensions of Uf are not correct"
644  << abort(FatalError);
645 
646  return fluxFieldType::null();
647  }
648 }
649 
650 
651 template<class Type>
652 tmp<typename EulerDdtScheme<Type>::fluxFieldType>
653 EulerDdtScheme<Type>::fvcDdtPhiCorr
654 (
655  const volScalarField& rho,
656  const GeometricField<Type, fvPatchField, volMesh>& U,
657  const fluxFieldType& phi
658 )
659 {
660  dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
661 
662  if
663  (
664  U.dimensions() == dimVelocity
665  && phi.dimensions() == rho.dimensions()*dimVelocity*dimArea
666  )
667  {
668  GeometricField<Type, fvPatchField, volMesh> rhoU0
669  (
670  rho.oldTime()*U.oldTime()
671  );
672 
673  fluxFieldType phiCorr
674  (
675  phi.oldTime() - fvc::dotInterpolate(mesh().Sf(), rhoU0)
676  );
677 
678  return tmp<fluxFieldType>
679  (
680  new fluxFieldType
681  (
682  IOobject
683  (
684  "ddtCorr("
685  + rho.name() + ',' + U.name() + ',' + phi.name() + ')',
686  mesh().time().timeName(),
687  mesh()
688  ),
689  this->fvcDdtPhiCoeff
690  (
691  rhoU0,
692  phi.oldTime(),
693  phiCorr,
694  rho.oldTime()
695  )*rDeltaT*phiCorr
696  )
697  );
698  }
699  else if
700  (
701  U.dimensions() == rho.dimensions()*dimVelocity
702  && phi.dimensions() == rho.dimensions()*dimVelocity*dimArea
703  )
704  {
705  fluxFieldType phiCorr
706  (
707  phi.oldTime() - fvc::dotInterpolate(mesh().Sf(), U.oldTime())
708  );
709 
710  return tmp<fluxFieldType>
711  (
712  new fluxFieldType
713  (
714  IOobject
715  (
716  "ddtCorr("
717  + rho.name() + ',' + U.name() + ',' + phi.name() + ')',
718  mesh().time().timeName(),
719  mesh()
720  ),
721  this->fvcDdtPhiCoeff
722  (
723  U.oldTime(),
724  phi.oldTime(),
725  phiCorr,
726  rho.oldTime()
727  )*rDeltaT*phiCorr
728  )
729  );
730  }
731  else
732  {
733  FatalErrorInFunction
734  << "dimensions of phi are not correct"
735  << abort(FatalError);
736 
737  return fluxFieldType::null();
738  }
739 }
740 
741 
742 template<class Type>
743 tmp<surfaceScalarField> EulerDdtScheme<Type>::meshPhi
744 (
745  const GeometricField<Type, fvPatchField, volMesh>&
746 )
747 {
748  return mesh().phi();
749 }
750 
751 
752 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
753 
754 } // End namespace fv
755 
756 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
757 
758 } // End namespace Foam
759 
760 // ************************************************************************* //
Foam::GeometricField::oldTime
const GeometricField< Type, PatchField, GeoMesh > & oldTime() const
Return old time field.
Definition: GeometricField.C:1009
Foam::IOobject::name
const word & name() const
Return name.
Definition: IOobject.H:295
Foam::FatalError
error FatalError
FatalErrorInFunction
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:319
Foam::GeometricField::boundaryField
const Boundary & boundaryField() const
Return const-reference to the boundary field.
Definition: GeometricFieldI.H:60
Foam::tmp::ref
T & ref() const
Return non-const reference or generate a fatal error.
Definition: tmpI.H:174
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::dimVol
const dimensionSet dimVol(dimVolume)
Definition: dimensionSets.H:59
Foam::fv::EulerDdtScheme::fvcDdt
virtual tmp< GeometricField< Type, fvPatchField, volMesh > > fvcDdt(const dimensioned< Type > &)
Definition: EulerDdtScheme.C:46
Foam::GeometricField::primitiveField
const Internal::FieldType & primitiveField() const
Return a const-reference to the internal field.
Definition: GeometricFieldI.H:51
Foam::GeometricField
Generic GeometricField class.
Definition: surfaceFieldsFwd.H:52
Foam::dimensioned
Generic dimensioned Type class.
Definition: dimensionedScalarFwd.H:41
Foam::DimensionedField::dimensions
const dimensionSet & dimensions() const
Return dimensions.
Definition: DimensionedFieldI.H:46
mesh
dynamicFvMesh & mesh
Definition: createDynamicFvMesh.H:18
Foam::fv::EulerDdtScheme::fvcDdtPhiCorr
virtual tmp< fluxFieldType > fvcDdtPhiCorr(const GeometricField< Type, fvPatchField, volMesh > &U, const fluxFieldType &phi)
Definition: EulerDdtScheme.C:537
Foam::fv::EulerDdtScheme::meshPhi
virtual tmp< surfaceScalarField > meshPhi(const GeometricField< Type, fvPatchField, volMesh > &)
Definition: EulerDdtScheme.C:744
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:61
Foam::dimensioned::value
const Type & value() const
Return const reference to value.
Definition: dimensionedType.C:283
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:72
Foam::Zero
static const zero Zero
Definition: zero.H:97
Foam::abort
errorManip< error > abort(error &err)
Definition: errorManip.H:131
Foam::fv::EulerDdtScheme::fvcDdtUfCorr
virtual tmp< fluxFieldType > fvcDdtUfCorr(const GeometricField< Type, fvPatchField, volMesh > &U, const GeometricField< Type, fvsPatchField, surfaceMesh > &Uf)
Definition: EulerDdtScheme.C:504
fvcDiv.H
Calculate the divergence of the given field.
Foam::fvMatrix::source
Field< Type > & source()
Definition: fvMatrix.H:292
Foam::dimensioned::name
const word & name() const
Return const reference to name.
Definition: dimensionedType.C:257
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::dimensioned::dimensions
const dimensionSet & dimensions() const
Return const reference to dimensions.
Definition: dimensionedType.C:270
alpha
volScalarField alpha(IOobject("alpha", runTime.timeName(), mesh, IOobject::READ_IF_PRESENT, IOobject::AUTO_WRITE), lambda *max(Ua &U, zeroSensitivity))
Sf
mesh Sf()
Foam::tmp
A class for managing temporary objects.
Definition: PtrList.H:53
Foam::lduMatrix::diag
scalarField & diag()
Definition: lduMatrix.C:186
Foam::IOobject
IOobject defines the attributes of an object for which implicit objectRegistry management is supporte...
Definition: IOobject.H:92
Foam::fv::EulerDdtScheme::fvmDdt
virtual tmp< fvMatrix< Type > > fvmDdt(const GeometricField< Type, fvPatchField, volMesh > &)
Definition: EulerDdtScheme.C:350
Foam::dimArea
const dimensionSet dimArea(sqr(dimLength))
Definition: dimensionSets.H:57
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.H:213
Foam::dimVelocity
const dimensionSet dimVelocity