zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fluxRequired: Added setFluxRequired function to fvSchemes class

Browse Source 
Added calls to setFluxRequired for p, p_rgh etc. in all solvers which
avoids the need to add fluxRequired entries in fvSchemes dictionaries.
This commit is contained in:
Henry Weller
2015-07-15 21:57:16 +01:00
parent 15198a34bd
commit 0fb6a01280
208 changed files with 3643 additions and 4591 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
applications/solvers/DNS/dnsFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p\n" << endl;
volScalarField p
(
Info<< "Reading field p\n" << endl;
volScalarField p
(
IOobject
(
"p",
@ -10,11 +10,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -24,6 +24,8 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
mesh.setFluxRequired(p.name());

162
applications/solvers/combustion/PDRFoam/createFields.H
View File

@ -1,16 +1,16 @@
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<psiuReactionThermo> pThermo
(
autoPtr<psiuReactionThermo> pThermo
(
psiuReactionThermo::New(mesh)
);
psiuReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "ha", "ea");
);
psiuReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "ha", "ea");
basicMultiComponentMixture& composition = thermo.composition();
basicMultiComponentMixture& composition = thermo.composition();
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -20,17 +20,17 @@
IOobject::AUTO_WRITE
),
thermo.rho()
);
);
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField& b = composition.Y("b");
Info<< "min(b) = " << min(b).value() << endl;
volScalarField& b = composition.Y("b");
Info<< "min(b) = " << min(b).value() << endl;
Info<< "\nReading field U\n" << endl;
volVectorField U
(
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -40,13 +40,15 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
mesh.setFluxRequired(p.name());
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
compressible::RASModel::New
(
rho,
@ -54,12 +56,12 @@
phi,
thermo
)
);
);
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
@ -68,22 +70,22 @@
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating the unstrained laminar flame speed\n" << endl;
autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed
(
Info<< "Creating the unstrained laminar flame speed\n" << endl;
autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed
(
laminarFlameSpeed::New(thermo)
);
);
Info<< "Reading strained laminar flame speed field Su\n" << endl;
volScalarField Su
(
Info<< "Reading strained laminar flame speed field Su\n" << endl;
volScalarField Su
(
IOobject
(
"Su",
@ -93,11 +95,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field betav\n" << endl;
volScalarField betav
(
Info<< "Reading field betav\n" << endl;
volScalarField betav
(
IOobject
(
"betav",
@ -107,11 +109,11 @@
IOobject::NO_WRITE
),
mesh
);
);
Info<< "Reading field Lobs\n" << endl;
volScalarField Lobs
(
Info<< "Reading field Lobs\n" << endl;
volScalarField Lobs
(
IOobject
(
"Lobs",
@ -121,11 +123,11 @@
IOobject::NO_WRITE
),
mesh
);
);
Info<< "Reading field CT\n" << endl;
volSymmTensorField CT
(
Info<< "Reading field CT\n" << endl;
volSymmTensorField CT
(
IOobject
(
"CT",
@ -135,11 +137,11 @@
IOobject::NO_WRITE
),
mesh
);
);
Info<< "Reading field Nv\n" << endl;
volScalarField Nv
(
Info<< "Reading field Nv\n" << endl;
volScalarField Nv
(
IOobject
(
"Nv",
@ -149,11 +151,11 @@
IOobject::NO_WRITE
),
mesh
);
);
Info<< "Reading field nsv\n" << endl;
volSymmTensorField nsv
(
Info<< "Reading field nsv\n" << endl;
volSymmTensorField nsv
(
IOobject
(
"nsv",
@ -163,10 +165,10 @@
IOobject::NO_WRITE
),
mesh
);
);
IOdictionary PDRProperties
(
IOdictionary PDRProperties
(
IOobject
(
"PDRProperties",
@ -175,21 +177,21 @@
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
);
//- Create the drag model
autoPtr<PDRDragModel> drag = PDRDragModel::New
(
//- Create the drag model
autoPtr<PDRDragModel> drag = PDRDragModel::New
(
PDRProperties,
turbulence,
rho,
U,
phi
);
);
//- Create the flame-wrinkling model
autoPtr<XiModel> flameWrinkling = XiModel::New
(
//- Create the flame-wrinkling model
autoPtr<XiModel> flameWrinkling = XiModel::New
(
PDRProperties,
thermo,
turbulence,
@ -197,11 +199,11 @@
rho,
b,
phi
);
);
Info<< "Calculating turbulent flame speed field St\n" << endl;
volScalarField St
(
Info<< "Calculating turbulent flame speed field St\n" << endl;
volScalarField St
(
IOobject
(
"St",
@ -211,17 +213,17 @@
IOobject::AUTO_WRITE
),
flameWrinkling->Xi()*Su
);
);
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
if (composition.contains("ft"))
{
if (composition.contains("ft"))
{
fields.add(composition.Y("ft"));
}
}
fields.add(b);
fields.add(thermo.he());
fields.add(thermo.heu());
flameWrinkling->addXi(fields);
fields.add(b);
fields.add(thermo.he());
fields.add(thermo.heu());
flameWrinkling->addXi(fields);

109
applications/solvers/combustion/XiFoam/createFields.H
View File

@ -1,16 +1,16 @@
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<psiuReactionThermo> pThermo
(
autoPtr<psiuReactionThermo> pThermo
(
psiuReactionThermo::New(mesh)
);
psiuReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "ha", "ea");
);
psiuReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "ha", "ea");
basicMultiComponentMixture& composition = thermo.composition();
basicMultiComponentMixture& composition = thermo.composition();
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -20,18 +20,18 @@
IOobject::AUTO_WRITE
),
thermo.rho()
);
);
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField& b = composition.Y("b");
Info<< "min(b) = " << min(b).value() << endl;
volScalarField& b = composition.Y("b");
Info<< "min(b) = " << min(b).value() << endl;
Info<< "\nReading field U\n" << endl;
volVectorField U
(
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -41,14 +41,15 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
@ -56,11 +57,11 @@
phi,
thermo
)
);
);
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
@ -69,14 +70,14 @@
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field Xi\n" << endl;
volScalarField Xi
(
Info<< "Creating field Xi\n" << endl;
volScalarField Xi
(
IOobject
(
"Xi",
@ -86,19 +87,19 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Creating the unstrained laminar flame speed\n" << endl;
autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed
(
Info<< "Creating the unstrained laminar flame speed\n" << endl;
autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed
(
laminarFlameSpeed::New(thermo)
);
);
Info<< "Reading strained laminar flame speed field Su\n" << endl;
volScalarField Su
(
Info<< "Reading strained laminar flame speed field Su\n" << endl;
volScalarField Su
(
IOobject
(
"Su",
@ -108,14 +109,14 @@
IOobject::AUTO_WRITE
),
mesh
);
);
dimensionedScalar SuMin = 0.01*Su.average();
dimensionedScalar SuMax = 4*Su.average();
dimensionedScalar SuMin = 0.01*Su.average();
dimensionedScalar SuMax = 4*Su.average();
Info<< "Calculating turbulent flame speed field St\n" << endl;
volScalarField St
(
Info<< "Calculating turbulent flame speed field St\n" << endl;
volScalarField St
(
IOobject
(
"St",
@ -125,16 +126,16 @@
IOobject::AUTO_WRITE
),
Xi*Su
);
);
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
if (composition.contains("ft"))
{
if (composition.contains("ft"))
{
fields.add(composition.Y("ft"));
}
}
fields.add(b);
fields.add(thermo.he());
fields.add(thermo.heu());
fields.add(b);
fields.add(thermo.he());
fields.add(thermo.heu());

116
applications/solvers/combustion/fireFoam/createFields.H
View File

@ -1,28 +1,28 @@
Info<< "Creating combustion model\n" << endl;
Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::psiCombustionModel> combustion
(
autoPtr<combustionModels::psiCombustionModel> combustion
(
combustionModels::psiCombustionModel::New
(
mesh
)
);
);
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
psiReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
psiReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
SLGThermo slgThermo(mesh, thermo);
basicMultiComponentMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
basicMultiComponentMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("inertSpecie"));
const word inertSpecie(thermo.lookup("inertSpecie"));
Info<< "Creating field rho\n" << endl;
volScalarField rho
(
Info<< "Creating field rho\n" << endl;
volScalarField rho
(
IOobject
(
"rho",
@ -32,15 +32,15 @@
IOobject::AUTO_WRITE
),
thermo.rho()
);
);
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
Info<< "\nReading field U\n" << endl;
volVectorField U
(
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -50,13 +50,13 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
@ -64,13 +64,13 @@
phi,
thermo
)
);
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
volScalarField dQ
(
volScalarField dQ
(
IOobject
(
"dQ",
@ -81,12 +81,12 @@
),
mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);
);
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
@ -95,19 +95,19 @@
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p_rgh
(
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -117,21 +117,23 @@
IOobject::AUTO_WRITE
),
mesh
);
);
// Force p_rgh to be consistent with p
p_rgh = p - rho*gh;
// Force p_rgh to be consistent with p
p_rgh = p - rho*gh;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
mesh.setFluxRequired(p_rgh.name());
forAll(Y, i)
{
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
}
fields.add(thermo.he());
IOdictionary additionalControlsDict
(
IOdictionary additionalControlsDict
(
IOobject
(
"additionalControls",
@ -140,9 +142,9 @@
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
);
Switch solvePrimaryRegion
(
Switch solvePrimaryRegion
(
additionalControlsDict.lookup("solvePrimaryRegion")
);
);

2
applications/solvers/combustion/reactingFoam/createFields.H
View File

@ -45,6 +45,8 @@ const volScalarField& T = thermo.T();
#include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
Info << "Creating turbulence model.\n" << nl;
autoPtr<compressible::turbulenceModel> turbulence
(

1
applications/solvers/combustion/reactingFoam/rhoReactingBuoyantFoam/createFields.H
View File

@ -46,6 +46,7 @@ const volScalarField& T = thermo.T();
#include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
Info << "Creating turbulence model.\n" << nl;
autoPtr<compressible::turbulenceModel> turbulence

3
applications/solvers/combustion/reactingFoam/rhoReactingFoam/createFields.H
View File

@ -43,9 +43,10 @@ volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
const volScalarField& T = thermo.T();
#include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
Info << "Creating turbulence model.\n" << nl;
autoPtr<compressible::turbulenceModel> turbulence

66
applications/solvers/compressible/rhoPimpleFoam/createFields.H
View File

@ -1,17 +1,17 @@
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<psiThermo> pThermo
(
autoPtr<psiThermo> pThermo
(
psiThermo::New(mesh)
);
psiThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
);
psiThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -21,11 +21,11 @@
IOobject::AUTO_WRITE
),
thermo.rho()
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -35,12 +35,12 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
dimensionedScalar rhoMax
(
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
@ -48,10 +48,10 @@
GREAT,
dimDensity
)
);
);
dimensionedScalar rhoMin
(
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
@ -59,11 +59,11 @@
0,
dimDensity
)
);
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
@ -71,11 +71,13 @@
phi,
thermo
)
);
);
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
mesh.setFluxRequired(p.name());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
@ -84,7 +86,7 @@
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));

62
applications/solvers/compressible/rhoSimpleFoam/createFields.H
View File

@ -1,14 +1,14 @@
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<psiThermo> pThermo
(
autoPtr<psiThermo> pThermo
(
psiThermo::New(mesh)
);
psiThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
);
psiThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -18,14 +18,14 @@
IOobject::AUTO_WRITE
),
thermo.rho()
);
);
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -35,17 +35,19 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, simple.dict(), pRefCell, pRefValue);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, simple.dict(), pRefCell, pRefValue);
dimensionedScalar rhoMax
(
mesh.setFluxRequired(p.name());
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
@ -53,10 +55,10 @@
GREAT,
dimDensity
)
);
);
dimensionedScalar rhoMin
(
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
@ -64,11 +66,11 @@
0,
dimDensity
)
);
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
compressible::RASModel::New
(
rho,
@ -76,6 +78,6 @@
phi,
thermo
)
);
);
dimensionedScalar initialMass = fvc::domainIntegrate(rho);
dimensionedScalar initialMass = fvc::domainIntegrate(rho);

60
applications/solvers/compressible/rhoSimpleFoam/rhoPorousSimpleFoam/createFields.H
View File

@ -1,14 +1,14 @@
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<rhoThermo> pThermo
(
autoPtr<rhoThermo> pThermo
(
rhoThermo::New(mesh)
);
rhoThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
);
rhoThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -18,13 +18,13 @@
IOobject::AUTO_WRITE
),
thermo.rho()
);
);
volScalarField& p = thermo.p();
volScalarField& p = thermo.p();
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -34,17 +34,19 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, simple.dict(), pRefCell, pRefValue);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, simple.dict(), pRefCell, pRefValue);
dimensionedScalar rhoMax
(
mesh.setFluxRequired(p.name());
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
@ -52,10 +54,10 @@
GREAT,
dimDensity
)
);
);
dimensionedScalar rhoMin
(
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
@ -63,11 +65,11 @@
0,
dimDensity
)
);
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
compressible::RASModel::New
(
rho,
@ -75,6 +77,6 @@
phi,
thermo
)
);
);
dimensionedScalar initialMass = fvc::domainIntegrate(rho);
dimensionedScalar initialMass = fvc::domainIntegrate(rho);

47
applications/solvers/compressible/sonicFoam/createFields.H
View File

@ -1,18 +1,18 @@
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<psiThermo> pThermo
(
autoPtr<psiThermo> pThermo
(
psiThermo::New(mesh)
);
psiThermo& thermo = pThermo();
thermo.validate(args.executable(), "e");
);
psiThermo& thermo = pThermo();
thermo.validate(args.executable(), "e");
volScalarField& p = thermo.p();
volScalarField& e = thermo.he();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
volScalarField& e = thermo.he();
const volScalarField& psi = thermo.psi();
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -20,11 +20,11 @@
mesh
),
thermo.rho()
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -34,14 +34,15 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
@ -49,7 +50,7 @@
phi,
thermo
)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));

26
applications/solvers/compressible/sonicFoam/sonicLiquidFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p\n" << endl;
volScalarField p
(
Info<< "Reading field p\n" << endl;
volScalarField p
(
IOobject
(
"p",
@ -10,12 +10,12 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -25,10 +25,10 @@
IOobject::AUTO_WRITE
),
mesh
);
);
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -38,7 +38,9 @@
IOobject::AUTO_WRITE
),
rhoO + psi*p
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());

85
applications/solvers/electromagnetics/mhdFoam/createFields.H
View File

@ -1,7 +1,7 @@
Info<< "Reading transportProperties\n" << endl;
Info<< "Reading transportProperties\n" << endl;
IOdictionary transportProperties
(
IOdictionary transportProperties
(
IOobject
(
"transportProperties",
@ -10,31 +10,31 @@
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
);
dimensionedScalar rho
(
dimensionedScalar rho
(
transportProperties.lookup("rho")
);
);
dimensionedScalar nu
(
dimensionedScalar nu
(
transportProperties.lookup("nu")
);
);
dimensionedScalar mu
(
dimensionedScalar mu
(
transportProperties.lookup("mu")
);
);
dimensionedScalar sigma
(
dimensionedScalar sigma
(
transportProperties.lookup("sigma")
);
);
Info<< "Reading field p\n" << endl;
volScalarField p
(
Info<< "Reading field p\n" << endl;
volScalarField p
(
IOobject
(
"p",
@ -44,12 +44,12 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -59,13 +59,13 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
Info<< "Reading field pB\n" << endl;
volScalarField pB
(
Info<< "Reading field pB\n" << endl;
volScalarField pB
(
IOobject
(
"pB",
@ -75,12 +75,12 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field B\n" << endl;
volVectorField B
(
Info<< "Reading field B\n" << endl;
volVectorField B
(
IOobject
(
"B",
@ -90,18 +90,21 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhiB.H"
#include "createPhiB.H"
dimensionedScalar DB = 1.0/(mu*sigma);
DB.name() = "DB";
dimensionedScalar DB = 1.0/(mu*sigma);
DB.name() = "DB";
dimensionedScalar DBU = 1.0/(2.0*mu*rho);
DBU.name() = "DBU";
dimensionedScalar DBU = 1.0/(2.0*mu*rho);
DBU.name() = "DBU";
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, piso.dict(), pRefCell, pRefValue);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, piso.dict(), pRefCell, pRefValue);
mesh.setFluxRequired(p.name());
mesh.setFluxRequired(pB.name());

86
applications/solvers/heatTransfer/buoyantBoussinesqPimpleFoam/createFields.H
View File

@ -1,8 +1,8 @@
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading field T\n" << endl;
volScalarField T
(
Info<< "Reading field T\n" << endl;
volScalarField T
(
IOobject
(
"T",
@ -12,11 +12,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -26,11 +26,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -40,21 +40,21 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
#include "readTransportProperties.H"
#include "readTransportProperties.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<incompressible::RASModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<incompressible::RASModel> turbulence
(
incompressible::RASModel::New(U, phi, laminarTransport)
);
);
// Kinematic density for buoyancy force
volScalarField rhok
(
// Kinematic density for buoyancy force
volScalarField rhok
(
IOobject
(
"rhok",
@ -62,12 +62,12 @@
mesh
),
1.0 - beta*(T - TRef)
);
);
// kinematic turbulent thermal thermal conductivity m2/s
Info<< "Reading field alphat\n" << endl;
volScalarField alphat
(
// kinematic turbulent thermal thermal conductivity m2/s
Info<< "Reading field alphat\n" << endl;
volScalarField alphat
(
IOobject
(
"alphat",
@ -77,16 +77,16 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p
(
volScalarField p
(
IOobject
(
"p",
@ -96,25 +96,27 @@
IOobject::AUTO_WRITE
),
p_rgh + rhok*gh
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
);
if (p_rgh.needReference())
{
if (p_rgh.needReference())
{
p += dimensionedScalar
(
"p",
p.dimensions(),
pRefValue - getRefCellValue(p, pRefCell)
);
}
}
mesh.setFluxRequired(p_rgh.name());

86
applications/solvers/heatTransfer/buoyantBoussinesqSimpleFoam/createFields.H
View File

@ -1,8 +1,8 @@
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading field T\n" << endl;
volScalarField T
(
Info<< "Reading field T\n" << endl;
volScalarField T
(
IOobject
(
"T",
@ -12,11 +12,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -26,11 +26,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -40,21 +40,21 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
#include "readTransportProperties.H"
#include "readTransportProperties.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<incompressible::RASModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<incompressible::RASModel> turbulence
(
incompressible::RASModel::New(U, phi, laminarTransport)
);
);
// Kinematic density for buoyancy force
volScalarField rhok
(
// Kinematic density for buoyancy force
volScalarField rhok
(
IOobject
(
"rhok",
@ -62,12 +62,12 @@
mesh
),
1.0 - beta*(T - TRef)
);
);
// kinematic turbulent thermal thermal conductivity m2/s
Info<< "Reading field alphat\n" << endl;
volScalarField alphat
(
// kinematic turbulent thermal thermal conductivity m2/s
Info<< "Reading field alphat\n" << endl;
volScalarField alphat
(
IOobject
(
"alphat",
@ -77,16 +77,16 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p
(
volScalarField p
(
IOobject
(
"p",
@ -96,25 +96,27 @@
IOobject::AUTO_WRITE
),
p_rgh + rhok*gh
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
simple.dict(),
pRefCell,
pRefValue
);
);
if (p_rgh.needReference())
{
if (p_rgh.needReference())
{
p += dimensionedScalar
(
"p",
p.dimensions(),
pRefValue - getRefCellValue(p, pRefCell)
);
}
}
mesh.setFluxRequired(p_rgh.name());

68
applications/solvers/heatTransfer/buoyantPimpleFoam/createFields.H
View File

@ -1,11 +1,11 @@
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<rhoThermo> pThermo(rhoThermo::New(mesh));
rhoThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
autoPtr<rhoThermo> pThermo(rhoThermo::New(mesh));
rhoThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -15,15 +15,15 @@
IOobject::NO_WRITE
),
thermo.rho()
);
);
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -33,14 +33,14 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
@ -48,15 +48,15 @@
phi,
thermo
)
);
);
Info<< "Calculating field g.h\n" << endl;
volScalarField gh("gh", g & mesh.C());
surfaceScalarField ghf("ghf", g & mesh.Cf());
Info<< "Calculating field g.h\n" << endl;
volScalarField gh("gh", g & mesh.C());
surfaceScalarField ghf("ghf", g & mesh.Cf());
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -66,14 +66,16 @@
IOobject::AUTO_WRITE
),
mesh
);
);
// Force p_rgh to be consistent with p
p_rgh = p - rho*gh;
// Force p_rgh to be consistent with p
p_rgh = p - rho*gh;
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
mesh.setFluxRequired(p_rgh.name());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
@ -82,7 +84,7 @@
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));

71
applications/solvers/heatTransfer/buoyantSimpleFoam/createFields.H
View File

@ -1,11 +1,11 @@
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<rhoThermo> pThermo(rhoThermo::New(mesh));
rhoThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
autoPtr<rhoThermo> pThermo(rhoThermo::New(mesh));
rhoThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -15,14 +15,14 @@
IOobject::NO_WRITE
),
thermo.rho()
);
);
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -32,13 +32,13 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
compressible::RASModel::New
(
rho,
@ -46,16 +46,16 @@
phi,
thermo
)
);
);
Info<< "Calculating field g.h\n" << endl;
volScalarField gh("gh", g & mesh.C());
surfaceScalarField ghf("ghf", g & mesh.Cf());
Info<< "Calculating field g.h\n" << endl;
volScalarField gh("gh", g & mesh.C());
surfaceScalarField ghf("ghf", g & mesh.Cf());
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -65,22 +65,23 @@
IOobject::AUTO_WRITE
),
mesh
);
);
// Force p_rgh to be consistent with p
p_rgh = p - rho*gh;
// Force p_rgh to be consistent with p
p_rgh = p - rho*gh;
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
simple.dict(),
pRefCell,
pRefValue
);
);
dimensionedScalar initialMass = fvc::domainIntegrate(rho);
dimensionedScalar totalVolume = sum(mesh.V());
mesh.setFluxRequired(p_rgh.name());
dimensionedScalar initialMass = fvc::domainIntegrate(rho);
dimensionedScalar totalVolume = sum(mesh.V());

48
applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionSimpleFoam/fluid/createFluidFields.H
View File

@ -1,29 +1,29 @@
// Initialise fluid field pointer lists
PtrList<rhoThermo> thermoFluid(fluidRegions.size());
PtrList<volScalarField> rhoFluid(fluidRegions.size());
PtrList<volVectorField> UFluid(fluidRegions.size());
PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size());
PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
PtrList<volScalarField> p_rghFluid(fluidRegions.size());
PtrList<volScalarField> ghFluid(fluidRegions.size());
PtrList<surfaceScalarField> ghfFluid(fluidRegions.size());
PtrList<radiation::radiationModel> radiation(fluidRegions.size());
// Initialise fluid field pointer lists
PtrList<rhoThermo> thermoFluid(fluidRegions.size());
PtrList<volScalarField> rhoFluid(fluidRegions.size());
PtrList<volVectorField> UFluid(fluidRegions.size());
PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size());
PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
PtrList<volScalarField> p_rghFluid(fluidRegions.size());
PtrList<volScalarField> ghFluid(fluidRegions.size());
PtrList<surfaceScalarField> ghfFluid(fluidRegions.size());
PtrList<radiation::radiationModel> radiation(fluidRegions.size());
List<scalar> initialMassFluid(fluidRegions.size());
List<label> pRefCellFluid(fluidRegions.size(), 0);
List<scalar> pRefValueFluid(fluidRegions.size(), 0.0);
List<bool> frozenFlowFluid(fluidRegions.size(), false);
List<scalar> initialMassFluid(fluidRegions.size());
List<label> pRefCellFluid(fluidRegions.size(), 0);
List<scalar> pRefValueFluid(fluidRegions.size(), 0.0);
List<bool> frozenFlowFluid(fluidRegions.size(), false);
PtrList<dimensionedScalar> rhoMax(fluidRegions.size());
PtrList<dimensionedScalar> rhoMin(fluidRegions.size());
PtrList<dimensionedScalar> rhoMax(fluidRegions.size());
PtrList<dimensionedScalar> rhoMin(fluidRegions.size());
PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size());
PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size());
PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size());
PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size());
// Populate fluid field pointer lists
forAll(fluidRegions, i)
{
// Populate fluid field pointer lists
forAll(fluidRegions, i)
{
Info<< "*** Reading fluid mesh thermophysical properties for region "
<< fluidRegions[i].name() << nl << endl;
@ -154,6 +154,8 @@
// Force p_rgh to be consistent with p
p_rghFluid[i] = thermoFluid[i].p() - rhoFluid[i]*ghFluid[i];
fluidRegions[i].setFluxRequired(p_rghFluid[i].name());
radiation.set
(
i,
@ -219,4 +221,4 @@
i,
new fv::IOoptionList(fluidRegions[i])
);
}
}

44
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H
View File

@ -1,26 +1,26 @@
// Initialise fluid field pointer lists
PtrList<rhoThermo> thermoFluid(fluidRegions.size());
PtrList<volScalarField> rhoFluid(fluidRegions.size());
PtrList<volVectorField> UFluid(fluidRegions.size());
PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size());
PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
PtrList<volScalarField> p_rghFluid(fluidRegions.size());
PtrList<volScalarField> ghFluid(fluidRegions.size());
PtrList<surfaceScalarField> ghfFluid(fluidRegions.size());
PtrList<radiation::radiationModel> radiation(fluidRegions.size());
PtrList<volScalarField> KFluid(fluidRegions.size());
PtrList<volScalarField> dpdtFluid(fluidRegions.size());
// Initialise fluid field pointer lists
PtrList<rhoThermo> thermoFluid(fluidRegions.size());
PtrList<volScalarField> rhoFluid(fluidRegions.size());
PtrList<volVectorField> UFluid(fluidRegions.size());
PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size());
PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
PtrList<volScalarField> p_rghFluid(fluidRegions.size());
PtrList<volScalarField> ghFluid(fluidRegions.size());
PtrList<surfaceScalarField> ghfFluid(fluidRegions.size());
PtrList<radiation::radiationModel> radiation(fluidRegions.size());
PtrList<volScalarField> KFluid(fluidRegions.size());
PtrList<volScalarField> dpdtFluid(fluidRegions.size());
List<scalar> initialMassFluid(fluidRegions.size());
List<bool> frozenFlowFluid(fluidRegions.size(), false);
List<scalar> initialMassFluid(fluidRegions.size());
List<bool> frozenFlowFluid(fluidRegions.size(), false);
PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size());
PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size());
PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size());
PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size());
// Populate fluid field pointer lists
forAll(fluidRegions, i)
{
// Populate fluid field pointer lists
forAll(fluidRegions, i)
{
Info<< "*** Reading fluid mesh thermophysical properties for region "
<< fluidRegions[i].name() << nl << endl;
@ -151,6 +151,8 @@
// Force p_rgh to be consistent with p
p_rghFluid[i] = thermoFluid[i].p() - rhoFluid[i]*ghFluid[i];
fluidRegions[i].setFluxRequired(p_rghFluid[i].name());
radiation.set
(
i,
@ -209,4 +211,4 @@
i,
new fv::IOoptionList(fluidRegions[i])
);
}
}

2
applications/solvers/incompressible/pimpleFoam/pimpleDyMFoam/createFields.H
View File

@ -1,2 +0,0 @@
#include "../createFields.H"
mesh.setFluxRequired("pcorr");

109
applications/solvers/lagrangian/DPMFoam/createFields.H
View File

@ -1,5 +1,5 @@
word continuousPhaseName
(
word continuousPhaseName
(
IOdictionary
(
IOobject
@ -10,11 +10,11 @@
IOobject::MUST_READ
)
).lookup("continuousPhaseName")
);
);
Info<< "Reading field U\n" << endl;
volVectorField Uc
(
Info<< "Reading field U\n" << endl;
volVectorField Uc
(
IOobject
(
IOobject::groupName("U", continuousPhaseName),
@ -24,11 +24,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field p\n" << endl;
volScalarField p
(
Info<< "Reading field p\n" << endl;
volScalarField p
(
IOobject
(
"p",
@ -38,14 +38,14 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading/calculating continuous-phase face flux field phic\n"
Info<< "Reading/calculating continuous-phase face flux field phic\n"
<< endl;
surfaceScalarField phic
(
surfaceScalarField phic
(
IOobject
(
IOobject::groupName("phi", continuousPhaseName),
@ -55,28 +55,29 @@
IOobject::AUTO_WRITE
),
linearInterpolate(Uc) & mesh.Sf()
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, pimple.dict(), pRefCell, pRefValue);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, pimple.dict(), pRefCell, pRefValue);
mesh.setFluxRequired(p.name());
Info<< "Creating turbulence model\n" << endl;
Info<< "Creating turbulence model\n" << endl;
singlePhaseTransportModel continuousPhaseTransport(Uc, phic);
singlePhaseTransportModel continuousPhaseTransport(Uc, phic);
dimensionedScalar rhocValue
(
dimensionedScalar rhocValue
(
IOobject::groupName("rho", continuousPhaseName),
dimDensity,
continuousPhaseTransport.lookup
(
IOobject::groupName("rho", continuousPhaseName)
)
);
);
volScalarField rhoc
(
volScalarField rhoc
(
IOobject
(
rhocValue.name(),
@ -87,10 +88,10 @@
),
mesh,
rhocValue
);
);
volScalarField muc
(
volScalarField muc
(
IOobject
(
IOobject::groupName("mu", continuousPhaseName),
@ -100,13 +101,13 @@
IOobject::AUTO_WRITE
),
rhoc*continuousPhaseTransport.nu()
);
);
Info << "Creating field alphac\n" << endl;
// alphac must be constructed before the cloud
// so that the drag-models can find it
volScalarField alphac
(
Info << "Creating field alphac\n" << endl;
// alphac must be constructed before the cloud
// so that the drag-models can find it
volScalarField alphac
(
IOobject
(
IOobject::groupName("alpha", continuousPhaseName),
@ -117,42 +118,42 @@
),
mesh,
dimensionedScalar("0", dimless, 0)
);
);
word kinematicCloudName("kinematicCloud");
args.optionReadIfPresent("cloudName", kinematicCloudName);
word kinematicCloudName("kinematicCloud");
args.optionReadIfPresent("cloudName", kinematicCloudName);
Info<< "Constructing kinematicCloud " << kinematicCloudName << endl;
basicKinematicTypeCloud kinematicCloud
(
Info<< "Constructing kinematicCloud " << kinematicCloudName << endl;
basicKinematicTypeCloud kinematicCloud
(
kinematicCloudName,
rhoc,
Uc,
muc,
g
);
);
// Particle fraction upper limit
scalar alphacMin
(
// Particle fraction upper limit
scalar alphacMin
(
1.0
- readScalar
(
kinematicCloud.particleProperties().subDict("constantProperties")
.lookup("alphaMax")
)
);
);
// Update alphac from the particle locations
alphac = max(1.0 - kinematicCloud.theta(), alphacMin);
alphac.correctBoundaryConditions();
// Update alphac from the particle locations
alphac = max(1.0 - kinematicCloud.theta(), alphacMin);
alphac.correctBoundaryConditions();
surfaceScalarField alphacf("alphacf", fvc::interpolate(alphac));
surfaceScalarField alphaPhic("alphaPhic", alphacf*phic);
surfaceScalarField alphacf("alphacf", fvc::interpolate(alphac));
surfaceScalarField alphaPhic("alphaPhic", alphacf*phic);
autoPtr<PhaseIncompressibleTurbulenceModel<singlePhaseTransportModel> >
continuousPhaseTurbulence
(
autoPtr<PhaseIncompressibleTurbulenceModel<singlePhaseTransportModel> >
continuousPhaseTurbulence
(
PhaseIncompressibleTurbulenceModel<singlePhaseTransportModel>::New
(
alphac,
@ -161,4 +162,4 @@
phic,
continuousPhaseTransport
)
);
);

106
applications/solvers/lagrangian/coalChemistryFoam/createFields.H
View File

@ -1,42 +1,42 @@
Info<< "Creating combustion model\n" << endl;
Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::psiCombustionModel> combustion
(
autoPtr<combustionModels::psiCombustionModel> combustion
(
combustionModels::psiCombustionModel::New(mesh)
);
);
psiReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
psiReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
SLGThermo slgThermo(mesh, thermo);
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("inertSpecie"));
const word inertSpecie(thermo.lookup("inertSpecie"));
if (!composition.contains(inertSpecie))
{
if (!composition.contains(inertSpecie))
{
FatalErrorIn(args.executable())
<< "Specified inert specie '" << inertSpecie << "' not found in "
<< "species list. Available species:" << composition.species()
<< exit(FatalError);
}
}
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
}
fields.add(thermo.he());
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -46,11 +46,11 @@
IOobject::AUTO_WRITE
),
thermo.rho()
);
);
// lagrangian effective density field - used externally (optional)
volScalarField rhoEffLagrangian
(
// lagrangian effective density field - used externally (optional)
volScalarField rhoEffLagrangian
(
IOobject
(
"rhoEffLagrangian",
@ -61,11 +61,11 @@
),
mesh,
dimensionedScalar("zero", dimDensity, 0.0)
);
);
// dynamic pressure field - used externally (optional)
volScalarField pDyn
(
// dynamic pressure field - used externally (optional)
volScalarField pDyn
(
IOobject
(
"pDyn",
@ -76,12 +76,12 @@
),
mesh,
dimensionedScalar("zero", dimPressure, 0.0)
);
);
Info<< "\nReading field U\n" << endl;
volVectorField U
(
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -91,13 +91,15 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
mesh.setFluxRequired(p.name());
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
@ -105,14 +107,14 @@
phi,
thermo
)
);
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
@ -121,13 +123,13 @@
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
volScalarField dQ
(
volScalarField dQ
(
IOobject
(
"dQ",
@ -138,4 +140,4 @@
),
mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);
);

114
applications/solvers/lagrangian/reactingParcelFilmFoam/createFields.H
View File

@ -1,23 +1,23 @@
Info<< "Creating combustion model\n" << endl;
Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::psiCombustionModel> combustion
(
autoPtr<combustionModels::psiCombustionModel> combustion
(
combustionModels::psiCombustionModel::New(mesh)
);
);
psiReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
psiReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
SLGThermo slgThermo(mesh, thermo);
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("inertSpecie"));
const word inertSpecie(thermo.lookup("inertSpecie"));
Info<< "Creating field rho\n" << endl;
volScalarField rho
(
Info<< "Creating field rho\n" << endl;
volScalarField rho
(
IOobject
(
"rho",
@ -27,15 +27,15 @@
IOobject::AUTO_WRITE
),
thermo.rho()
);
);
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
Info<< "\nReading field U\n" << endl;
volVectorField U
(
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -45,13 +45,13 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
@ -59,14 +59,14 @@
phi,
thermo
)
);
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
@ -75,19 +75,19 @@
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p_rgh
(
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -97,21 +97,23 @@
IOobject::AUTO_WRITE
),
mesh
);
);
// Force p_rgh to be consistent with p
p_rgh = p - rho*gh;
// Force p_rgh to be consistent with p
p_rgh = p - rho*gh;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
mesh.setFluxRequired(p_rgh.name());
forAll(Y, i)
{
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
}
fields.add(thermo.he());
IOdictionary additionalControlsDict
(
IOdictionary additionalControlsDict
(
IOobject
(
"additionalControls",
@ -120,15 +122,15 @@
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
);
Switch solvePrimaryRegion
(
Switch solvePrimaryRegion
(
additionalControlsDict.lookup("solvePrimaryRegion")
);
);
volScalarField dQ
(
volScalarField dQ
(
IOobject
(
"dQ",
@ -139,4 +141,4 @@
),
mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);
);

104
applications/solvers/lagrangian/reactingParcelFoam/createFields.H
View File

@ -1,34 +1,34 @@
Info<< "Creating combustion model\n" << endl;
Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::rhoCombustionModel> combustion
(
autoPtr<combustionModels::rhoCombustionModel> combustion
(
combustionModels::rhoCombustionModel::New(mesh)
);
);
rhoReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
rhoReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
SLGThermo slgThermo(mesh, thermo);
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("inertSpecie"));
const word inertSpecie(thermo.lookup("inertSpecie"));
if (!composition.contains(inertSpecie))
{
if (!composition.contains(inertSpecie))
{
FatalErrorIn(args.executable())
<< "Specified inert specie '" << inertSpecie << "' not found in "
<< "species list. Available species:" << composition.species()
<< exit(FatalError);
}
}
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -38,11 +38,11 @@
IOobject::AUTO_WRITE
),
thermo.rho()
);
);
Info<< "\nReading field U\n" << endl;
volVectorField U
(
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -52,12 +52,14 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
dimensionedScalar rhoMax
(
mesh.setFluxRequired(p.name());
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
@ -65,10 +67,10 @@
GREAT,
dimDensity
)
);
);
dimensionedScalar rhoMin
(
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
@ -76,11 +78,11 @@
0,
dimDensity
)
);
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
@ -88,14 +90,14 @@
phi,
thermo
)
);
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
@ -104,22 +106,22 @@
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating multi-variate interpolation scheme\n" << endl;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
Info<< "Creating multi-variate interpolation scheme\n" << endl;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
}
fields.add(thermo.he());
volScalarField dQ
(
volScalarField dQ
(
IOobject
(
"dQ",
@ -130,4 +132,4 @@
),
mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);
);

91
applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/createFields.H
View File

@ -1,34 +1,34 @@
Info<< "Creating combustion model\n" << endl;
Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::rhoCombustionModel> combustion
(
autoPtr<combustionModels::rhoCombustionModel> combustion
(
combustionModels::rhoCombustionModel::New(mesh)
);
);
rhoReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
rhoReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
SLGThermo slgThermo(mesh, thermo);
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("inertSpecie"));
const word inertSpecie(thermo.lookup("inertSpecie"));
if (!composition.contains(inertSpecie))
{
if (!composition.contains(inertSpecie))
{
FatalErrorIn(args.executable())
<< "Specified inert specie '" << inertSpecie << "' not found in "
<< "species list. Available species:" << composition.species()
<< exit(FatalError);
}
}
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -38,11 +38,11 @@
IOobject::AUTO_WRITE
),
thermo.rho()
);
);
Info<< "\nReading field U\n" << endl;
volVectorField U
(
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -52,13 +52,14 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
dimensionedScalar rhoMax
(
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
@ -66,10 +67,10 @@
GREAT,
dimDensity
)
);
);
dimensionedScalar rhoMin
(
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
@ -77,11 +78,11 @@
0,
dimDensity
)
);
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
@ -89,22 +90,22 @@
phi,
thermo
)
);
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating multi-variate interpolation scheme\n" << endl;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
Info<< "Creating multi-variate interpolation scheme\n" << endl;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
}
fields.add(thermo.he());
volScalarField dQ
(
volScalarField dQ
(
IOobject
(
"dQ",
@ -115,4 +116,4 @@
),
mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);
);

102
applications/solvers/lagrangian/sprayFoam/createFields.H
View File

@ -1,34 +1,34 @@
Info<< "Creating combustion model\n" << endl;
Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::psiCombustionModel> combustion
(
autoPtr<combustionModels::psiCombustionModel> combustion
(
combustionModels::psiCombustionModel::New(mesh)
);
);
psiReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
psiReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
SLGThermo slgThermo(mesh, thermo);
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("inertSpecie"));
const word inertSpecie(thermo.lookup("inertSpecie"));
if (!composition.contains(inertSpecie))
{
if (!composition.contains(inertSpecie))
{
FatalErrorIn(args.executable())
<< "Specified inert specie '" << inertSpecie << "' not found in "
<< "species list. Available species:" << composition.species()
<< exit(FatalError);
}
}
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -38,11 +38,11 @@
IOobject::AUTO_WRITE
),
thermo.rho()
);
);
Info<< "\nReading field U\n" << endl;
volVectorField U
(
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -52,12 +52,14 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "compressibleCreatePhi.H"
#include "compressibleCreatePhi.H"
dimensionedScalar rhoMax
(
mesh.setFluxRequired(p.name());
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
@ -65,10 +67,10 @@
GREAT,
dimDensity
)
);
);
dimensionedScalar rhoMin
(
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
@ -76,11 +78,11 @@
0,
dimDensity
)
);
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
@ -88,14 +90,14 @@
phi,
thermo
)
);
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
@ -104,20 +106,20 @@
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
}
fields.add(thermo.he());
volScalarField dQ
(
volScalarField dQ
(
IOobject
(
"dQ",
@ -128,4 +130,4 @@
),
mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);
);

2
applications/solvers/multiphase/cavitatingFoam/cavitatingDyMFoam/correctPhi.H
View File

@ -19,6 +19,8 @@ correctUphiBCs(U, phi);
surfaceScalarField rhof(fvc::interpolate(rho, "div(phi,rho)"));
dimensionedScalar rAUf("rAUf", dimTime, 1.0);
mesh.setFluxRequired(pcorr.name());
while (pimple.correctNonOrthogonal())
{
fvScalarMatrix pcorrEqn

67
applications/solvers/multiphase/cavitatingFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p\n" << endl;
volScalarField p
(
Info<< "Reading field p\n" << endl;
volScalarField p
(
IOobject
(
"p",
@ -10,10 +10,10 @@
IOobject::AUTO_WRITE
),
mesh
);
);
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -23,11 +23,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -37,13 +37,15 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
// Mass flux (corrected by rhoEqn.H)
surfaceScalarField rhoPhi
(
mesh.setFluxRequired(p.name());
// Mass flux (corrected by rhoEqn.H)
surfaceScalarField rhoPhi
(
IOobject
(
"rhoPhi",
@ -53,37 +55,40 @@
IOobject::NO_WRITE
),
fvc::interpolate(rho)*phi
);
);
Info<< "Reading transportProperties\n" << endl;
Info<< "Reading transportProperties\n" << endl;
incompressibleTwoPhaseMixture mixture(U, phi);
incompressibleTwoPhaseMixture mixture(U, phi);
volScalarField& alphav(mixture.alpha1());
alphav.oldTime();
volScalarField& alphav(mixture.alpha1());
alphav.oldTime();
volScalarField& alphal(mixture.alpha2());
volScalarField& alphal(mixture.alpha2());
Info<< "Creating compressibilityModel\n" << endl;
autoPtr<barotropicCompressibilityModel> psiModel =
Info<< "Creating compressibilityModel\n" << endl;
autoPtr<barotropicCompressibilityModel> psiModel =
barotropicCompressibilityModel::New
(
thermodynamicProperties,
alphav
);
const volScalarField& psi = psiModel->psi();
const volScalarField& psi = psiModel->psi();
rho == max
(
rho == max
(
psi*p
+ alphal*rhol0
+ ((alphav*psiv + alphal*psil) - psi)*pSat,
rhoMin
);
);
// Create incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
mesh.setFluxRequired(p.name());
mesh.setFluxRequired(rho.name());
// Create incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, mixture)
);
);

94
applications/solvers/multiphase/compressibleInterFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -10,11 +10,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -24,27 +24,27 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
Info<< "Constructing twoPhaseMixtureThermo\n" << endl;
twoPhaseMixtureThermo mixture(mesh);
Info<< "Constructing twoPhaseMixtureThermo\n" << endl;
twoPhaseMixtureThermo mixture(mesh);
volScalarField& alpha1(mixture.alpha1());
volScalarField& alpha2(mixture.alpha2());
volScalarField& alpha1(mixture.alpha1());
volScalarField& alpha2(mixture.alpha2());
Info<< "Reading thermophysical properties\n" << endl;
Info<< "Reading thermophysical properties\n" << endl;
volScalarField& p = mixture.p();
volScalarField& T = mixture.T();
volScalarField& rho1 = mixture.thermo1().rho();
const volScalarField& psi1 = mixture.thermo1().psi();
volScalarField& rho2 = mixture.thermo2().rho();
const volScalarField& psi2 = mixture.thermo2().psi();
volScalarField& p = mixture.p();
volScalarField& T = mixture.T();
volScalarField& rho1 = mixture.thermo1().rho();
const volScalarField& psi1 = mixture.thermo1().psi();
volScalarField& rho2 = mixture.thermo2().rho();
const volScalarField& psi2 = mixture.thermo2().psi();
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -54,27 +54,29 @@
IOobject::AUTO_WRITE
),
alpha1*rho1 + alpha2*rho2
);
);
dimensionedScalar pMin
(
dimensionedScalar pMin
(
"pMin",
dimPressure,
mixture.lookup("pMin")
);
);
mesh.setFluxRequired(p_rgh.name());
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
// Mass flux
// Initialisation does not matter because rhoPhi is reset after the
// alpha1 solution before it is used in the U equation.
surfaceScalarField rhoPhi
(
// Mass flux
// Initialisation does not matter because rhoPhi is reset after the
// alpha1 solution before it is used in the U equation.
surfaceScalarField rhoPhi
(
IOobject
(
"rhoPhi",
@ -84,21 +86,21 @@
IOobject::NO_WRITE
),
fvc::interpolate(rho)*phi
);
);
volScalarField dgdt
(
volScalarField dgdt
(
pos(alpha2)*fvc::div(phi)/max(alpha2, scalar(0.0001))
);
);
// Construct interface from alpha1 distribution
interfaceProperties interface(alpha1, U, mixture);
// Construct interface from alpha1 distribution
interfaceProperties interface(alpha1, U, mixture);
// Construct compressible turbulence model
autoPtr<compressible::turbulenceModel> turbulence
(
// Construct compressible turbulence model
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New(rho, U, rhoPhi, mixture)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));

54
applications/solvers/multiphase/compressibleMultiphaseInterFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -10,11 +10,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -24,18 +24,18 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
Info<< "Constructing multiphaseMixtureThermo\n" << endl;
multiphaseMixtureThermo mixture(U, phi);
Info<< "Constructing multiphaseMixtureThermo\n" << endl;
multiphaseMixtureThermo mixture(U, phi);
volScalarField& p = mixture.p();
volScalarField& T = mixture.T();
volScalarField& p = mixture.p();
volScalarField& T = mixture.T();
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -44,19 +44,21 @@
IOobject::READ_IF_PRESENT
),
mixture.rho()
);
);
dimensionedScalar pMin(mixture.lookup("pMin"));
dimensionedScalar pMin(mixture.lookup("pMin"));
mesh.setFluxRequired(p_rgh.name());
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
// Construct compressible turbulence model
autoPtr<compressible::turbulenceModel> turbulence
(
// Construct compressible turbulence model
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
@ -64,7 +66,7 @@
mixture.rhoPhi(),
mixture
)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));

102
applications/solvers/multiphase/driftFluxFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -10,11 +10,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -24,23 +24,23 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
Info<< "Reading incompressibleTwoPhaseInteractingMixture\n" << endl;
incompressibleTwoPhaseInteractingMixture mixture(U, phi);
Info<< "Reading incompressibleTwoPhaseInteractingMixture\n" << endl;
incompressibleTwoPhaseInteractingMixture mixture(U, phi);
volScalarField& alpha1(mixture.alpha1());
volScalarField& alpha2(mixture.alpha2());
volScalarField& alpha1(mixture.alpha1());
volScalarField& alpha2(mixture.alpha2());
const dimensionedScalar& rho1 = mixture.rhod();
const dimensionedScalar& rho2 = mixture.rhoc();
const dimensionedScalar& rho1 = mixture.rhod();
const dimensionedScalar& rho2 = mixture.rhoc();
// Mixture density
volScalarField rho
(
// Mixture density
volScalarField rho
(
IOobject
(
"rho",
@ -50,11 +50,11 @@
IOobject::NO_WRITE
),
mixture.rho()
);
);
// Mass flux
surfaceScalarField rhoPhi
(
// Mass flux
surfaceScalarField rhoPhi
(
IOobject
(
"rhoPhi",
@ -64,40 +64,40 @@
IOobject::NO_WRITE
),
fvc::interpolate(rho)*phi
);
);
// Relative Velocity
autoPtr<relativeVelocityModel> UdmModelPtr
(
// Relative Velocity
autoPtr<relativeVelocityModel> UdmModelPtr
(
relativeVelocityModel::New
(
mixture,
mixture
)
);
);
relativeVelocityModel& UdmModel(UdmModelPtr());
relativeVelocityModel& UdmModel(UdmModelPtr());
// Construct compressible turbulence model
autoPtr
<
// Construct compressible turbulence model
autoPtr
<
CompressibleTurbulenceModel<incompressibleTwoPhaseInteractingMixture>
> turbulence
(
> turbulence
(
CompressibleTurbulenceModel<incompressibleTwoPhaseInteractingMixture>
::New(rho, U, rhoPhi, mixture)
);
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p
(
volScalarField p
(
IOobject
(
"p",
@ -107,21 +107,21 @@
IOobject::AUTO_WRITE
),
p_rgh + rho*gh
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
);
if (p_rgh.needReference())
{
if (p_rgh.needReference())
{
p += dimensionedScalar
(
"p",
@ -129,8 +129,10 @@
pRefValue - getRefCellValue(p, pRefCell)
);
p_rgh = p - rho*gh;
}
}
mesh.setFluxRequired(p_rgh.name());
mesh.setFluxRequired(alpha1.name());
// MULES Correction
tmp<surfaceScalarField> tphiAlphaCorr0;
// MULES Correction
tmp<surfaceScalarField> tphiAlphaCorr0;

99
applications/solvers/multiphase/interFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -10,11 +10,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -24,24 +24,24 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
Info<< "Reading transportProperties\n" << endl;
immiscibleIncompressibleTwoPhaseMixture mixture(U, phi);
Info<< "Reading transportProperties\n" << endl;
immiscibleIncompressibleTwoPhaseMixture mixture(U, phi);
volScalarField& alpha1(mixture.alpha1());
volScalarField& alpha2(mixture.alpha2());
volScalarField& alpha1(mixture.alpha1());
volScalarField& alpha2(mixture.alpha2());
const dimensionedScalar& rho1 = mixture.rho1();
const dimensionedScalar& rho2 = mixture.rho2();
const dimensionedScalar& rho1 = mixture.rho1();
const dimensionedScalar& rho2 = mixture.rho2();
// Need to store rho for ddt(rho, U)
volScalarField rho
(
// Need to store rho for ddt(rho, U)
volScalarField rho
(
IOobject
(
"rho",
@ -51,13 +51,13 @@
),
alpha1*rho1 + alpha2*rho2,
alpha1.boundaryField().types()
);
rho.oldTime();
);
rho.oldTime();
// Mass flux
surfaceScalarField rhoPhi
(
// Mass flux
surfaceScalarField rhoPhi
(
IOobject
(
"rhoPhi",
@ -67,23 +67,23 @@
IOobject::NO_WRITE
),
fvc::interpolate(rho)*phi
);
);
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, mixture)
);
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p
(
volScalarField p
(
IOobject
(
"p",
@ -93,21 +93,21 @@
IOobject::AUTO_WRITE
),
p_rgh + rho*gh
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
);
if (p_rgh.needReference())
{
if (p_rgh.needReference())
{
p += dimensionedScalar
(
"p",
@ -115,11 +115,14 @@
pRefValue - getRefCellValue(p, pRefCell)
);
p_rgh = p - rho*gh;
}
}
// MULES flux from previous time-step
surfaceScalarField phiAlpha
(
mesh.setFluxRequired(p_rgh.name());
mesh.setFluxRequired(alpha1.name());
// MULES flux from previous time-step
surfaceScalarField phiAlpha
(
IOobject
(
"phiAlpha",
@ -129,7 +132,7 @@
IOobject::AUTO_WRITE
),
phi*fvc::interpolate(alpha1)
);
);
// MULES Correction
tmp<surfaceScalarField> tphiAlphaCorr0;
// MULES Correction
tmp<surfaceScalarField> tphiAlphaCorr0;

95
applications/solvers/multiphase/interFoam/interMixingFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -10,11 +10,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -24,25 +24,25 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
immiscibleIncompressibleThreePhaseMixture mixture(U, phi);
immiscibleIncompressibleThreePhaseMixture mixture(U, phi);
volScalarField& alpha1(mixture.alpha1());
volScalarField& alpha2(mixture.alpha2());
volScalarField& alpha3(mixture.alpha3());
volScalarField& alpha1(mixture.alpha1());
volScalarField& alpha2(mixture.alpha2());
volScalarField& alpha3(mixture.alpha3());
const dimensionedScalar& rho1 = mixture.rho1();
const dimensionedScalar& rho2 = mixture.rho2();
const dimensionedScalar& rho3 = mixture.rho3();
const dimensionedScalar& rho1 = mixture.rho1();
const dimensionedScalar& rho2 = mixture.rho2();
const dimensionedScalar& rho3 = mixture.rho3();
dimensionedScalar D23(mixture.lookup("D23"));
dimensionedScalar D23(mixture.lookup("D23"));
// Need to store rho for ddt(rho, U)
volScalarField rho
(
// Need to store rho for ddt(rho, U)
volScalarField rho
(
IOobject
(
"rho",
@ -52,15 +52,15 @@
),
alpha1*rho1 + alpha2*rho2 + alpha3*rho3,
alpha1.boundaryField().types()
);
rho.oldTime();
);
rho.oldTime();
// Mass flux
// Initialisation does not matter because rhoPhi is reset after the
// alpha solution before it is used in the U equation.
surfaceScalarField rhoPhi
(
// Mass flux
// Initialisation does not matter because rhoPhi is reset after the
// alpha solution before it is used in the U equation.
surfaceScalarField rhoPhi
(
IOobject
(
"rhoPhi",
@ -70,21 +70,21 @@
IOobject::NO_WRITE
),
rho1*phi
);
);
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, mixture)
);
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p
(
volScalarField p
(
IOobject
(
"p",
@ -94,21 +94,21 @@
IOobject::AUTO_WRITE
),
p_rgh + rho*gh
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
);
if (p_rgh.needReference())
{
if (p_rgh.needReference())
{
p += dimensionedScalar
(
"p",
@ -116,4 +116,7 @@
pRefValue - getRefCellValue(p, pRefCell)
);
p_rgh = p - rho*gh;
}
}
mesh.setFluxRequired(p_rgh.name());
mesh.setFluxRequired(alpha2.name());

85
applications/solvers/multiphase/interPhaseChangeFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -10,11 +10,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -24,26 +24,26 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
Info<< "Creating phaseChangeTwoPhaseMixture\n" << endl;
autoPtr<phaseChangeTwoPhaseMixture> mixture =
Info<< "Creating phaseChangeTwoPhaseMixture\n" << endl;
autoPtr<phaseChangeTwoPhaseMixture> mixture =
phaseChangeTwoPhaseMixture::New(U, phi);
volScalarField& alpha1(mixture->alpha1());
volScalarField& alpha2(mixture->alpha2());
volScalarField& alpha1(mixture->alpha1());
volScalarField& alpha2(mixture->alpha2());
const dimensionedScalar& rho1 = mixture->rho1();
const dimensionedScalar& rho2 = mixture->rho2();
const dimensionedScalar& pSat = mixture->pSat();
const dimensionedScalar& rho1 = mixture->rho1();
const dimensionedScalar& rho2 = mixture->rho2();
const dimensionedScalar& pSat = mixture->pSat();
// Need to store rho for ddt(rho, U)
volScalarField rho
(
// Need to store rho for ddt(rho, U)
volScalarField rho
(
IOobject
(
"rho",
@ -53,27 +53,27 @@
),
alpha1*rho1 + alpha2*rho2,
alpha1.boundaryField().types()
);
rho.oldTime();
);
rho.oldTime();
// Construct interface from alpha1 distribution
interfaceProperties interface(alpha1, U, mixture());
// Construct interface from alpha1 distribution
interfaceProperties interface(alpha1, U, mixture());
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, mixture())
);
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p
(
volScalarField p
(
IOobject
(
"p",
@ -83,21 +83,21 @@
IOobject::AUTO_WRITE
),
p_rgh + rho*gh
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
);
if (p_rgh.needReference())
{
if (p_rgh.needReference())
{
p += dimensionedScalar
(
"p",
@ -105,4 +105,7 @@
pRefValue - getRefCellValue(p, pRefCell)
);
p_rgh = p - rho*gh;
}
}
mesh.setFluxRequired(p_rgh.name());
mesh.setFluxRequired(alpha1.name());

77
applications/solvers/multiphase/multiphaseEulerFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -10,10 +10,10 @@
IOobject::AUTO_WRITE
),
mesh
);
);
volVectorField U
(
volVectorField U
(
IOobject
(
"U",
@ -24,10 +24,10 @@
),
mesh,
dimensionedVector("U", dimVelocity, vector::zero)
);
);
surfaceScalarField phi
(
surfaceScalarField phi
(
IOobject
(
"phi",
@ -38,34 +38,34 @@
),
mesh,
dimensionedScalar("phi", dimArea*dimVelocity, 0)
);
);
multiphaseSystem fluid(U, phi);
multiphaseSystem fluid(U, phi);
forAllIter(PtrDictionary<phaseModel>, fluid.phases(), iter)
{
forAllIter(PtrDictionary<phaseModel>, fluid.phases(), iter)
{
phaseModel& phase = iter();
const volScalarField& alpha = phase;
U += alpha*phase.U();
phi += fvc::interpolate(alpha)*phase.phi();
}
}
scalar slamDampCoeff
(
scalar slamDampCoeff
(
fluid.lookupOrDefault<scalar>("slamDampCoeff", 1)
);
);
dimensionedScalar maxSlamVelocity
(
dimensionedScalar maxSlamVelocity
(
"maxSlamVelocity",
dimVelocity,
fluid.lookupOrDefault<scalar>("maxSlamVelocity", GREAT)
);
);
volScalarField rho
(
volScalarField rho
(
IOobject
(
"rho",
@ -75,23 +75,23 @@
IOobject::AUTO_WRITE
),
fluid.rho()
);
);
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, fluid)
);
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p
(
volScalarField p
(
IOobject
(
"p",
@ -101,15 +101,16 @@
IOobject::AUTO_WRITE
),
p_rgh + rho*gh
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
);
mesh.setFluxRequired(p_rgh.name());

70
applications/solvers/multiphase/multiphaseInterFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -10,11 +10,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -24,15 +24,15 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
multiphaseMixture mixture(U, phi);
multiphaseMixture mixture(U, phi);
// Need to store rho for ddt(rho, U)
volScalarField rho
(
// Need to store rho for ddt(rho, U)
volScalarField rho
(
IOobject
(
"rho",
@ -41,25 +41,25 @@
IOobject::READ_IF_PRESENT
),
mixture.rho()
);
rho.oldTime();
);
rho.oldTime();
const surfaceScalarField& rhoPhi(mixture.rhoPhi());
const surfaceScalarField& rhoPhi(mixture.rhoPhi());
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, mixture)
);
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p
(
volScalarField p
(
IOobject
(
"p",
@ -69,25 +69,27 @@
IOobject::AUTO_WRITE
),
p_rgh + rho*gh
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
);
if (p_rgh.needReference())
{
if (p_rgh.needReference())
{
p += dimensionedScalar
(
"p",
p.dimensions(),
pRefValue - getRefCellValue(p, pRefCell)
);
}
}
mesh.setFluxRequired(p_rgh.name());

57
applications/solvers/multiphase/potentialFreeSurfaceFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p (kinematic)\n" << endl;
volScalarField p
(
Info<< "Reading field p (kinematic)\n" << endl;
volScalarField p
(
IOobject
(
"p",
@ -10,11 +10,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -24,22 +24,22 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
singlePhaseTransportModel laminarTransport(U, phi);
singlePhaseTransportModel laminarTransport(U, phi);
autoPtr<incompressible::turbulenceModel> turbulence
(
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, laminarTransport)
);
);
#include "readGravitationalAcceleration.H"
#include "readGravitationalAcceleration.H"
Info<< "Creating field zeta\n" << endl;
volVectorField zeta
(
Info<< "Creating field zeta\n" << endl;
volVectorField zeta
(
IOobject
(
"zeta",
@ -50,11 +50,11 @@
),
mesh,
dimensionedVector("zero", dimLength, vector::zero)
);
);
Info<< "Creating field p_gh\n" << endl;
volScalarField p_gh
(
Info<< "Creating field p_gh\n" << endl;
volScalarField p_gh
(
IOobject
(
"p_gh",
@ -64,13 +64,14 @@
IOobject::AUTO_WRITE
),
mesh
);
);
// Force p_gh to be consistent with p
// Height is made relative to field 'refLevel'
p_gh = p - (g & mesh.C());
// Force p_gh to be consistent with p
// Height is made relative to field 'refLevel'
p_gh = p - (g & mesh.C());
label p_ghRefCell = 0;
scalar p_ghRefValue = 0.0;
setRefCell(p_gh, pimple.dict(), p_ghRefCell, p_ghRefValue);
label p_ghRefCell = 0;
scalar p_ghRefValue = 0.0;
setRefCell(p_gh, pimple.dict(), p_ghRefCell, p_ghRefValue);
mesh.setFluxRequired(p_gh.name());

86
applications/solvers/multiphase/reactingTwoPhaseEulerFoam/createFields.H
View File

@ -1,55 +1,55 @@
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
Info<< "Creating phaseSystem\n" << endl;
Info<< "Creating phaseSystem\n" << endl;
autoPtr<twoPhaseSystem> fluidPtr
(
autoPtr<twoPhaseSystem> fluidPtr
(
twoPhaseSystem::New(mesh)
);
twoPhaseSystem& fluid = fluidPtr();
);
twoPhaseSystem& fluid = fluidPtr();
phaseModel& phase1 = fluid.phase1();
phaseModel& phase2 = fluid.phase2();
phaseModel& phase1 = fluid.phase1();
phaseModel& phase2 = fluid.phase2();
volScalarField& alpha1 = phase1;
volScalarField& alpha2 = phase2;
volScalarField& alpha1 = phase1;
volScalarField& alpha2 = phase2;
volVectorField& U1 = phase1.U();
surfaceScalarField& phi1 = phase1.phi();
surfaceScalarField& alphaPhi1 = phase1.alphaPhi();
surfaceScalarField& alphaRhoPhi1 = phase1.alphaRhoPhi();
volVectorField& U1 = phase1.U();
surfaceScalarField& phi1 = phase1.phi();
surfaceScalarField& alphaPhi1 = phase1.alphaPhi();
surfaceScalarField& alphaRhoPhi1 = phase1.alphaRhoPhi();
volVectorField& U2 = phase2.U();
surfaceScalarField& phi2 = phase2.phi();
surfaceScalarField& alphaPhi2 = phase2.alphaPhi();
surfaceScalarField& alphaRhoPhi2 = phase2.alphaRhoPhi();
volVectorField& U2 = phase2.U();
surfaceScalarField& phi2 = phase2.phi();
surfaceScalarField& alphaPhi2 = phase2.alphaPhi();
surfaceScalarField& alphaRhoPhi2 = phase2.alphaRhoPhi();
surfaceScalarField& phi = fluid.phi();
surfaceScalarField& phi = fluid.phi();
dimensionedScalar pMin
(
dimensionedScalar pMin
(
"pMin",
dimPressure,
fluid.lookup("pMin")
);
);
#include "gh.H"
#include "gh.H"
rhoThermo& thermo1 = phase1.thermo();
rhoThermo& thermo2 = phase2.thermo();
rhoThermo& thermo1 = phase1.thermo();
rhoThermo& thermo2 = phase2.thermo();
volScalarField& p = thermo1.p();
volScalarField& p = thermo1.p();
volScalarField& rho1 = thermo1.rho();
const volScalarField& psi1 = thermo1.psi();
volScalarField& rho1 = thermo1.rho();
const volScalarField& psi1 = thermo1.psi();
volScalarField& rho2 = thermo2.rho();
const volScalarField& psi2 = thermo2.psi();
volScalarField& rho2 = thermo2.rho();
const volScalarField& psi2 = thermo2.psi();
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -59,18 +59,20 @@
IOobject::AUTO_WRITE
),
mesh
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
);
mesh.setFluxRequired(p_rgh.name());
mesh.setFluxRequired(alpha1.name());
const IOMRFZoneList& MRF = fluid.MRF();
fv::IOoptionList& fvOptions = fluid.fvOptions();
const IOMRFZoneList& MRF = fluid.MRF();
fv::IOoptionList& fvOptions = fluid.fvOptions();

93
applications/solvers/multiphase/twoLiquidMixingFoam/createFields.H
View File

@ -1,6 +1,6 @@
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -10,11 +10,11 @@
IOobject::AUTO_WRITE
),
mesh
);
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
@ -24,34 +24,34 @@
IOobject::AUTO_WRITE
),
mesh
);
);
#include "createPhi.H"
#include "createPhi.H"
Info<< "Reading transportProperties\n" << endl;
incompressibleTwoPhaseMixture mixture(U, phi);
Info<< "Reading transportProperties\n" << endl;
incompressibleTwoPhaseMixture mixture(U, phi);
volScalarField& alpha1(mixture.alpha1());
volScalarField& alpha2(mixture.alpha2());
volScalarField& alpha1(mixture.alpha1());
volScalarField& alpha2(mixture.alpha2());
const dimensionedScalar& rho1 = mixture.rho1();
const dimensionedScalar& rho2 = mixture.rho2();
const dimensionedScalar& rho1 = mixture.rho1();
const dimensionedScalar& rho2 = mixture.rho2();
dimensionedScalar Dab(mixture.lookup("Dab"));
dimensionedScalar Dab(mixture.lookup("Dab"));
// Read the reciprocal of the turbulent Schmidt number
dimensionedScalar alphatab(mixture.lookup("alphatab"));
// Read the reciprocal of the turbulent Schmidt number
dimensionedScalar alphatab(mixture.lookup("alphatab"));
// Need to store rho for ddt(rho, U)
volScalarField rho("rho", alpha1*rho1 + alpha2*rho2);
rho.oldTime();
// Need to store rho for ddt(rho, U)
volScalarField rho("rho", alpha1*rho1 + alpha2*rho2);
rho.oldTime();
// Mass flux
// Initialisation does not matter because rhoPhi is reset after the
// alpha1 solution before it is used in the U equation.
surfaceScalarField rhoPhi
(
// Mass flux
// Initialisation does not matter because rhoPhi is reset after the
// alpha1 solution before it is used in the U equation.
surfaceScalarField rhoPhi
(
IOobject
(
"rhoPhi",
@ -61,22 +61,22 @@
IOobject::NO_WRITE
),
rho1*phi
);
);
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
// Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, mixture)
);
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p
(
volScalarField p
(
IOobject
(
"p",
@ -86,21 +86,21 @@
IOobject::AUTO_WRITE
),
p_rgh + rho*gh
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
);
if (p_rgh.needReference())
{
if (p_rgh.needReference())
{
p += dimensionedScalar
(
"p",
@ -108,4 +108,7 @@
pRefValue - getRefCellValue(p, pRefCell)
);
p_rgh = p - rho*gh;
}
}
mesh.setFluxRequired(p_rgh.name());
mesh.setFluxRequired(alpha1.name());

96
applications/solvers/multiphase/twoPhaseEulerFoam/createFields.H
View File

@ -1,51 +1,51 @@
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
Info<< "Creating twoPhaseSystem\n" << endl;
Info<< "Creating twoPhaseSystem\n" << endl;
twoPhaseSystem fluid(mesh, g);
twoPhaseSystem fluid(mesh, g);
phaseModel& phase1 = fluid.phase1();
phaseModel& phase2 = fluid.phase2();
phaseModel& phase1 = fluid.phase1();
phaseModel& phase2 = fluid.phase2();
volScalarField& alpha1 = phase1;
volScalarField& alpha2 = phase2;
volScalarField& alpha1 = phase1;
volScalarField& alpha2 = phase2;
volVectorField& U1 = phase1.U();
surfaceScalarField& phi1 = phase1.phi();
surfaceScalarField& alphaPhi1 = phase1.alphaPhi();
surfaceScalarField& alphaRhoPhi1 = phase1.alphaRhoPhi();
volVectorField& U1 = phase1.U();
surfaceScalarField& phi1 = phase1.phi();
surfaceScalarField& alphaPhi1 = phase1.alphaPhi();
surfaceScalarField& alphaRhoPhi1 = phase1.alphaRhoPhi();
volVectorField& U2 = phase2.U();
surfaceScalarField& phi2 = phase2.phi();
surfaceScalarField& alphaPhi2 = phase2.alphaPhi();
surfaceScalarField& alphaRhoPhi2 = phase2.alphaRhoPhi();
volVectorField& U2 = phase2.U();
surfaceScalarField& phi2 = phase2.phi();
surfaceScalarField& alphaPhi2 = phase2.alphaPhi();
surfaceScalarField& alphaRhoPhi2 = phase2.alphaRhoPhi();
surfaceScalarField& phi = fluid.phi();
surfaceScalarField& phi = fluid.phi();
dimensionedScalar pMin
(
dimensionedScalar pMin
(
"pMin",
dimPressure,
fluid.lookup("pMin")
);
);
#include "gh.H"
#include "gh.H"
rhoThermo& thermo1 = phase1.thermo();
rhoThermo& thermo2 = phase2.thermo();
rhoThermo& thermo1 = phase1.thermo();
rhoThermo& thermo2 = phase2.thermo();
volScalarField& p = thermo1.p();
volScalarField& p = thermo1.p();
volScalarField& rho1 = thermo1.rho();
const volScalarField& psi1 = thermo1.psi();
volScalarField& rho1 = thermo1.rho();
const volScalarField& psi1 = thermo1.psi();
volScalarField& rho2 = thermo2.rho();
const volScalarField& psi2 = thermo2.psi();
volScalarField& rho2 = thermo2.rho();
const volScalarField& psi2 = thermo2.psi();
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
@ -55,10 +55,10 @@
IOobject::AUTO_WRITE
),
mesh
);
);
volVectorField U
(
volVectorField U
(
IOobject
(
"U",
@ -68,22 +68,24 @@
IOobject::AUTO_WRITE
),
fluid.U()
);
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
);
mesh.setFluxRequired(p_rgh.name());
mesh.setFluxRequired(alpha1.name());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
@ -92,9 +94,9 @@
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K1(IOobject::groupName("K", phase1.name()), 0.5*magSqr(U1));
volScalarField K2(IOobject::groupName("K", phase2.name()), 0.5*magSqr(U2));
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K1(IOobject::groupName("K", phase1.name()), 0.5*magSqr(U1));
volScalarField K2(IOobject::groupName("K", phase2.name()), 0.5*magSqr(U2));

2
applications/solvers/stressAnalysis/solidDisplacementFoam/createFields.H
View File

@ -72,3 +72,5 @@ else
{
divSigmaExp -= fvc::div((2*mu + lambda)*fvc::grad(D), "div(sigmaD)");
}
mesh.setFluxRequired(D.name());

4
src/finiteVolume/cfdTools/general/CorrectPhi/CorrectPhi.C
View File

@ -89,6 +89,8 @@ void Foam::CorrectPhi
fvc::makeAbsolute(phi, U);
}
mesh.setFluxRequired(pcorr.name());
while (pimple.correctNonOrthogonal())
{
// Solve for pcorr such that the divergence of the corrected flux
@ -156,6 +158,8 @@ void Foam::CorrectPhi
pcorrTypes
);
mesh.setFluxRequired(pcorr.name());
while (pimple.correctNonOrthogonal())
{
// Solve for pcorr such that the divergence of the corrected flux

2
src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.C
View File

@ -558,7 +558,7 @@ Foam::ITstream& Foam::fvSchemes::laplacianScheme(const word& name) const
}
void Foam::fvSchemes::setFluxRequired(const word& name)
void Foam::fvSchemes::setFluxRequired(const word& name) const
{
if (debug)
{

4
src/finiteVolume/finiteVolume/fvSchemes/fvSchemes.H
View File

@ -75,7 +75,7 @@ class fvSchemes
dictionary laplacianSchemes_;
ITstream defaultLaplacianScheme_;
dictionary fluxRequired_;
mutable dictionary fluxRequired_;
bool defaultFluxRequired_;
//- Steady-state run indicator
@ -130,7 +130,7 @@ public:
ITstream& laplacianScheme(const word& name) const;
void setFluxRequired(const word& name);
void setFluxRequired(const word& name) const;
bool fluxRequired(const word& name) const;

1
src/lagrangian/intermediate/submodels/MPPIC/PackingModels/Implicit/Implicit.C
View File

@ -108,6 +108,7 @@ void Foam::PackingModels::Implicit<CloudType>::cacheFields(const bool store)
cloudName + ":uSqrAverage"
);
mesh.setFluxRequired(alpha_.name());
// Property fields
// ~~~~~~~~~~~~~~~

3
src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
View File

@ -383,7 +383,8 @@ void kinematicSingleLayer::solveThickness
"deltaCoeff",
fvc::interpolate(delta_)*deltarUAf*rhof*fvc::interpolate(pp)
);
// constrainFilmField(ddrhorUAppf, 0.0);
regionMesh().setFluxRequired(delta_.name());
for (int nonOrth=0; nonOrth<=nNonOrthCorr_; nonOrth++)
{

2
tutorials/Alltest
View File

@ -106,7 +106,6 @@ divSchemes
laplacianSchemes { default Gauss linear corrected; }
interpolationSchemes { default linear; }
snGradSchemes { default corrected; }
fluxRequired { default yes; }
EOF
}
@ -140,7 +139,6 @@ FV_SCHEMES=\
laplacianScheme \
interpolationScheme \
snGradScheme \
fluxRequired \
"
SCHEMES_FILE="FvSchemes"
SCHEMES_TEMP="FvSchemes.temp"

6
tutorials/DNS/dnsFoam/boxTurb16/system/fvSchemes
View File

@ -46,11 +46,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/basic/laplacianFoam/flange/system/fvSchemes
View File

@ -47,11 +47,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
T ;
}
// ************************************************************************* //

6
tutorials/basic/scalarTransportFoam/pitzDaily/system/fvSchemes
View File

@ -47,11 +47,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
T ;
}
// ************************************************************************* //

6
tutorials/combustion/PDRFoam/flamePropagationWithObstacles/system/fvSchemes
View File

@ -69,10 +69,4 @@ snGradSchemes
default limited corrected 0.333;
}
fluxRequired
{
default no;
p;
}
// ************************************************************************* //

6
tutorials/combustion/XiFoam/ras/moriyoshiHomogeneous/system/fvSchemes
View File

@ -67,11 +67,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

4
tutorials/combustion/chemFoam/gri/system/fvSchemes
View File

@ -29,8 +29,4 @@ divSchemes
laplacianSchemes
{}
fluxRequired
{}
// ************************************************************************* //

4
tutorials/combustion/chemFoam/h2/system/fvSchemes
View File

@ -32,9 +32,5 @@ laplacianSchemes
{
}
fluxRequired
{
}
// ************************************************************************* //

4
tutorials/combustion/chemFoam/ic8h18/system/fvSchemes
View File

@ -29,8 +29,4 @@ divSchemes
laplacianSchemes
{}
fluxRequired
{}
// ************************************************************************* //

6
tutorials/combustion/engineFoam/kivaTest/system/fvSchemes
View File

@ -71,11 +71,5 @@ snGradSchemes
default limited corrected 0.5;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/filmRegion/fvSchemes
View File

@ -43,11 +43,5 @@ snGradSchemes
default uncorrected;
}
fluxRequired
{
default no;
deltaf;
}
// ************************************************************************* //

6
tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/fvSchemes
View File

@ -64,11 +64,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p_rgh;
}
// ************************************************************************* //

4
tutorials/combustion/fireFoam/les/flameSpreadWaterSuppressionPanel/system/pyrolysisRegion/fvSchemes
View File

@ -46,9 +46,5 @@ snGradSchemes
default uncorrected;
}
fluxRequired
{
default no;
}
// ************************************************************************* //

8
tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/fvSchemes
View File

@ -59,12 +59,4 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p_rgh;
phiMesh;
}
// ************************************************************************* //

4
tutorials/combustion/fireFoam/les/oppositeBurningPanels/system/panelRegion/fvSchemes
View File

@ -46,9 +46,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
}
// ************************************************************************* //

6
tutorials/combustion/fireFoam/les/smallPoolFire2D/system/fvSchemes
View File

@ -61,11 +61,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p_rgh;
}
// ************************************************************************* //

6
tutorials/combustion/fireFoam/les/smallPoolFire3D/system/fvSchemes
View File

@ -59,11 +59,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p_rgh;
}
// ************************************************************************* //

6
tutorials/combustion/reactingFoam/ras/counterFlowFlame2D/system/fvSchemes
View File

@ -53,11 +53,5 @@ snGradSchemes
default orthogonal;
}
fluxRequired
{
default no;
p;
}
// ************************************************************************* //

6
tutorials/combustion/reactingFoam/ras/counterFlowFlame2DLTS/system/fvSchemes
View File

@ -53,11 +53,5 @@ snGradSchemes
default orthogonal;
}
fluxRequired
{
default no;
p;
}
// ************************************************************************* //

8
tutorials/compressible/rhoPimpleDyMFoam/annularThermalMixer/system/fvSchemes
View File

@ -53,12 +53,4 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
pcorr ;
}
// ************************************************************************* //

6
tutorials/compressible/rhoPimpleFoam/les/pitzDaily/system/fvSchemes
View File

@ -54,11 +54,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/compressible/rhoPimpleFoam/ras/angledDuct/system/fvSchemes
View File

@ -57,11 +57,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/compressible/rhoPimpleFoam/ras/angledDuctLTS/system/fvSchemes
View File

@ -57,11 +57,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/compressible/rhoPimpleFoam/ras/cavity/system/fvSchemes
View File

@ -57,12 +57,6 @@ snGradSchemes
default orthogonal;
}
fluxRequired
{
default no;
p ;
}
wallDist
{
method meshWave;

6
tutorials/compressible/rhoPimpleFoam/ras/mixerVessel2D/system/fvSchemes
View File

@ -51,11 +51,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/compressible/rhoPorousSimpleFoam/angledDuctExplicit/system/fvSchemes
View File

@ -50,11 +50,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/compressible/rhoPorousSimpleFoam/angledDuctImplicit/system/fvSchemes
View File

@ -50,11 +50,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/compressible/rhoSimpleFoam/angledDuctExplicitFixedCoeff/system/fvSchemes
View File

@ -52,11 +52,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/compressible/rhoSimpleFoam/squareBend/system/fvSchemes
View File

@ -55,11 +55,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p;
pCorr;
}
// ************************************************************************* //

8
tutorials/compressible/sonicDyMFoam/movingCone/system/fvSchemes
View File

@ -55,12 +55,4 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
pcorr ;
}
// ************************************************************************* //

6
tutorials/compressible/sonicFoam/laminar/forwardStep/system/fvSchemes
View File

@ -52,11 +52,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/compressible/sonicFoam/laminar/shockTube/system/fvSchemes
View File

@ -51,11 +51,5 @@ snGradSchemes
default orthogonal;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/compressible/sonicFoam/ras/nacaAirfoil/system/fvSchemes
View File

@ -53,11 +53,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p;
}
// ************************************************************************* //

6
tutorials/compressible/sonicFoam/ras/prism/system/fvSchemes
View File

@ -53,11 +53,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p;
}
// ************************************************************************* //

6
tutorials/compressible/sonicLiquidFoam/decompressionTank/system/fvSchemes
View File

@ -47,11 +47,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
}
// ************************************************************************* //

6
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/system/fvSchemes
View File

@ -45,10 +45,4 @@ snGradSchemes
default none;
}
fluxRequired
{
default no;
}
// ************************************************************************* //

6
tutorials/discreteMethods/dsmcFoam/freeSpaceStream/system/fvSchemes
View File

@ -45,10 +45,4 @@ snGradSchemes
default none;
}
fluxRequired
{
default no;
}
// ************************************************************************* //

6
tutorials/discreteMethods/dsmcFoam/supersonicCorner/system/fvSchemes
View File

@ -45,10 +45,4 @@ snGradSchemes
default none;
}
fluxRequired
{
default no;
}
// ************************************************************************* //

6
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/system/fvSchemes
View File

@ -45,10 +45,4 @@ snGradSchemes
default none;
}
fluxRequired
{
default no;
}
// ************************************************************************* //

6
tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeArgon/system/fvSchemes
View File

@ -45,10 +45,4 @@ snGradSchemes
default none;
}
fluxRequired
{
default no;
}
// ************************************************************************* //

6
tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeWater/system/fvSchemes
View File

@ -45,10 +45,4 @@ snGradSchemes
default none;
}
fluxRequired
{
default no;
}
// ************************************************************************* //

6
tutorials/discreteMethods/molecularDynamics/mdFoam/nanoNozzle/system/fvSchemes
View File

@ -45,10 +45,4 @@ snGradSchemes
default none;
}
fluxRequired
{
default no;
}
// ************************************************************************* //

6
tutorials/electromagnetics/electrostaticFoam/chargedWire/system/fvSchemes
View File

@ -47,11 +47,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
phi ;
}
// ************************************************************************* //

8
tutorials/electromagnetics/mhdFoam/hartmann/system/fvSchemes
View File

@ -49,12 +49,4 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p ;
pB ;
}
// ************************************************************************* //

6
tutorials/heatTransfer/buoyantBoussinesqPimpleFoam/hotRoom/system/fvSchemes
View File

@ -53,11 +53,5 @@ snGradSchemes
default uncorrected;
}
fluxRequired
{
default no;
p_rgh;
}
// ************************************************************************* //

6
tutorials/heatTransfer/buoyantBoussinesqSimpleFoam/hotRoom/system/fvSchemes
View File

@ -51,11 +51,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p_rgh ;
}
// ************************************************************************* //

6
tutorials/heatTransfer/buoyantBoussinesqSimpleFoam/iglooWithFridges/system/fvSchemes
View File

@ -53,11 +53,5 @@ snGradSchemes
default limited corrected 0.333;
}
fluxRequired
{
default no;
p_rgh ;
}
// ************************************************************************* //

6
tutorials/heatTransfer/buoyantPimpleFoam/hotRoom/system/fvSchemes
View File

@ -55,11 +55,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p_rgh;
}
// ************************************************************************* //

6
tutorials/heatTransfer/buoyantSimpleFoam/buoyantCavity/system/fvSchemes
View File

@ -52,12 +52,6 @@ snGradSchemes
default orthogonal;
}
fluxRequired
{
default no;
p_rgh;
}
wallDist
{
method meshWave;

6
tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/fvSchemes
View File

@ -57,11 +57,5 @@ snGradSchemes
default uncorrected;
}
fluxRequired
{
default no;
p_rgh;
}
// ************************************************************************* //

6
tutorials/heatTransfer/buoyantSimpleFoam/externalCoupledCavity/system/fvSchemes
View File

@ -52,12 +52,6 @@ snGradSchemes
default orthogonal;
}
fluxRequired
{
default no;
p_rgh;
}
wallDist
{
method meshWave;

6
tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoom/system/fvSchemes
View File

@ -51,11 +51,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p_rgh;
}
// ************************************************************************* //

6
tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoomFvDOM/system/fvSchemes
View File

@ -52,11 +52,5 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p_rgh;
}
// ************************************************************************* //

6
tutorials/heatTransfer/chtMultiRegionFoam/multiRegionHeater/system/bottomWater/fvSchemes
View File

@ -53,10 +53,4 @@ snGradSchemes
default corrected;
}
fluxRequired
{
default no;
p_rgh;
}
// ************************************************************************* //

Some files were not shown because too many files have changed in this diff Show More