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

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

@ -1,29 +1,31 @@
Info<< "Reading field p\n" << endl; Info<< "Reading field p\n" << endl;
volScalarField p volScalarField p
(
IOobject
( (
IOobject "p",
( runTime.timeName(),
"p", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::MUST_READ, ),
IOobject::AUTO_WRITE mesh
), );
mesh
);
Info<< "Reading field U\n" << endl; Info<< "Reading field U\n" << endl;
volVectorField U volVectorField U
(
IOobject
( (
IOobject "U",
( runTime.timeName(),
"U", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::MUST_READ, ),
IOobject::AUTO_WRITE mesh
), );
mesh
);
#include "createPhi.H" #include "createPhi.H"
mesh.setFluxRequired(p.name());

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

@ -1,227 +1,229 @@
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");
basicMultiComponentMixture& composition = thermo.composition();
volScalarField rho
(
IOobject
( (
psiuReactionThermo::New(mesh) "rho",
); runTime.timeName(),
psiuReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "ha", "ea");
basicMultiComponentMixture& composition = thermo.composition();
volScalarField rho
(
IOobject
(
"rho",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
thermo.rho()
);
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField& b = composition.Y("b");
Info<< "min(b) = " << min(b).value() << endl;
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
compressible::RASModel::New
(
rho,
U,
phi,
thermo
)
);
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh, mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0) IOobject::NO_READ,
); IOobject::AUTO_WRITE
),
thermo.rho()
);
Info<< "Creating field kinetic energy K\n" << endl; volScalarField& p = thermo.p();
volScalarField K("K", 0.5*magSqr(U)); const volScalarField& psi = thermo.psi();
volScalarField& b = composition.Y("b");
Info<< "min(b) = " << min(b).value() << endl;
Info<< "Creating the unstrained laminar flame speed\n" << endl; Info<< "\nReading field U\n" << endl;
autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed volVectorField U
(
IOobject
( (
laminarFlameSpeed::New(thermo) "U",
); runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H"
Info<< "Reading strained laminar flame speed field Su\n" << endl; mesh.setFluxRequired(p.name());
volScalarField Su
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
compressible::RASModel::New
( (
IOobject
(
"Su",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
Info<< "Reading field betav\n" << endl;
volScalarField betav
(
IOobject
(
"betav",
mesh.facesInstance(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
Info<< "Reading field Lobs\n" << endl;
volScalarField Lobs
(
IOobject
(
"Lobs",
mesh.facesInstance(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
Info<< "Reading field CT\n" << endl;
volSymmTensorField CT
(
IOobject
(
"CT",
mesh.facesInstance(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
Info<< "Reading field Nv\n" << endl;
volScalarField Nv
(
IOobject
(
"Nv",
mesh.facesInstance(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
Info<< "Reading field nsv\n" << endl;
volSymmTensorField nsv
(
IOobject
(
"nsv",
mesh.facesInstance(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
IOdictionary PDRProperties
(
IOobject
(
"PDRProperties",
runTime.constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
//- Create the drag model
autoPtr<PDRDragModel> drag = PDRDragModel::New
(
PDRProperties,
turbulence,
rho, rho,
U, U,
phi phi,
); thermo
)
);
//- Create the flame-wrinkling model
autoPtr<XiModel> flameWrinkling = XiModel::New Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
( (
PDRProperties, "dpdt",
thermo, runTime.timeName(),
turbulence, mesh
Su, ),
rho, mesh,
b, dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
phi );
);
Info<< "Calculating turbulent flame speed field St\n" << endl; Info<< "Creating field kinetic energy K\n" << endl;
volScalarField St volScalarField K("K", 0.5*magSqr(U));
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
(
IOobject
( (
IOobject "Su",
( runTime.timeName(),
"St", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::NO_READ, ),
IOobject::AUTO_WRITE mesh
), );
flameWrinkling->Xi()*Su
); Info<< "Reading field betav\n" << endl;
volScalarField betav
(
IOobject
(
"betav",
mesh.facesInstance(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
Info<< "Reading field Lobs\n" << endl;
volScalarField Lobs
(
IOobject
(
"Lobs",
mesh.facesInstance(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
Info<< "Reading field CT\n" << endl;
volSymmTensorField CT
(
IOobject
(
"CT",
mesh.facesInstance(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
Info<< "Reading field Nv\n" << endl;
volScalarField Nv
(
IOobject
(
"Nv",
mesh.facesInstance(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
Info<< "Reading field nsv\n" << endl;
volSymmTensorField nsv
(
IOobject
(
"nsv",
mesh.facesInstance(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
IOdictionary PDRProperties
(
IOobject
(
"PDRProperties",
runTime.constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
//- Create the drag model
autoPtr<PDRDragModel> drag = PDRDragModel::New
(
PDRProperties,
turbulence,
rho,
U,
phi
);
//- Create the flame-wrinkling model
autoPtr<XiModel> flameWrinkling = XiModel::New
(
PDRProperties,
thermo,
turbulence,
Su,
rho,
b,
phi
);
Info<< "Calculating turbulent flame speed field St\n" << endl;
volScalarField St
(
IOobject
(
"St",
runTime.timeName(),
mesh,
IOobject::NO_READ,
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(composition.Y("ft"));
} }
fields.add(b); fields.add(b);
fields.add(thermo.he()); fields.add(thermo.he());
fields.add(thermo.heu()); fields.add(thermo.heu());
flameWrinkling->addXi(fields); flameWrinkling->addXi(fields);

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

@ -1,140 +1,141 @@
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");
basicMultiComponentMixture& composition = thermo.composition();
volScalarField rho
(
IOobject
( (
psiuReactionThermo::New(mesh) "rho",
); runTime.timeName(),
psiuReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "ha", "ea");
basicMultiComponentMixture& composition = thermo.composition();
volScalarField rho
(
IOobject
(
"rho",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
thermo.rho()
);
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField& b = composition.Y("b");
Info<< "min(b) = " << min(b).value() << endl;
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh, mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0) IOobject::NO_READ,
); IOobject::AUTO_WRITE
),
thermo.rho()
);
Info<< "Creating field kinetic energy K\n" << endl; volScalarField& p = thermo.p();
volScalarField K("K", 0.5*magSqr(U)); const volScalarField& psi = thermo.psi();
Info<< "Creating field Xi\n" << endl; volScalarField& b = composition.Y("b");
volScalarField Xi Info<< "min(b) = " << min(b).value() << endl;
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
( (
IOobject "U",
( runTime.timeName(),
"Xi", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::MUST_READ, ),
IOobject::AUTO_WRITE mesh
), );
#include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh mesh
); ),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating the unstrained laminar flame speed\n" << endl; Info<< "Creating field Xi\n" << endl;
autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed volScalarField Xi
(
IOobject
( (
laminarFlameSpeed::New(thermo) "Xi",
); runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
Info<< "Reading strained laminar flame speed field Su\n" << endl; Info<< "Creating the unstrained laminar flame speed\n" << endl;
volScalarField Su autoPtr<laminarFlameSpeed> unstrainedLaminarFlameSpeed
(
laminarFlameSpeed::New(thermo)
);
Info<< "Reading strained laminar flame speed field Su\n" << endl;
volScalarField Su
(
IOobject
( (
IOobject "Su",
( runTime.timeName(),
"Su", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::MUST_READ, ),
IOobject::AUTO_WRITE mesh
), );
mesh
);
dimensionedScalar SuMin = 0.01*Su.average(); dimensionedScalar SuMin = 0.01*Su.average();
dimensionedScalar SuMax = 4*Su.average(); dimensionedScalar SuMax = 4*Su.average();
Info<< "Calculating turbulent flame speed field St\n" << endl; Info<< "Calculating turbulent flame speed field St\n" << endl;
volScalarField St volScalarField St
(
IOobject
( (
IOobject "St",
( runTime.timeName(),
"St", mesh,
runTime.timeName(), IOobject::NO_READ,
mesh, IOobject::AUTO_WRITE
IOobject::NO_READ, ),
IOobject::AUTO_WRITE Xi*Su
), );
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(composition.Y("ft"));
} }
fields.add(b); fields.add(b);
fields.add(thermo.he()); fields.add(thermo.he());
fields.add(thermo.heu()); fields.add(thermo.heu());

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

@ -1,148 +1,150 @@
Info<< "Creating combustion model\n" << endl; Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::psiCombustionModel> combustion autoPtr<combustionModels::psiCombustionModel> combustion
(
combustionModels::psiCombustionModel::New
( (
combustionModels::psiCombustionModel::New
(
mesh
)
);
Info<< "Reading thermophysical properties\n" << endl;
psiReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
basicMultiComponentMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("inertSpecie"));
Info<< "Creating field rho\n" << endl;
volScalarField rho
(
IOobject
(
"rho",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
thermo.rho()
);
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh mesh
); )
);
#include "compressibleCreatePhi.H" Info<< "Reading thermophysical properties\n" << endl;
Info<< "Creating turbulence model\n" << endl; psiReactionThermo& thermo = combustion->thermo();
autoPtr<compressible::turbulenceModel> turbulence thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
basicMultiComponentMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("inertSpecie"));
Info<< "Creating field rho\n" << endl;
volScalarField rho
(
IOobject
( (
compressible::turbulenceModel::New "rho",
( runTime.timeName(),
rho,
U,
phi,
thermo
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
volScalarField dQ
(
IOobject
(
"dQ",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh, mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0) IOobject::NO_READ,
); IOobject::AUTO_WRITE
),
thermo.rho()
);
volScalarField& p = thermo.p();
const volScalarField& T = thermo.T();
const volScalarField& psi = thermo.psi();
Info<< "Creating field dpdt\n" << endl; Info<< "\nReading field U\n" << endl;
volScalarField dpdt volVectorField U
(
IOobject
( (
IOobject "U",
( runTime.timeName(),
"dpdt",
runTime.timeName(),
mesh
),
mesh, mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0) IOobject::MUST_READ,
); IOobject::AUTO_WRITE
),
mesh
);
Info<< "Creating field kinetic energy K\n" << endl; #include "compressibleCreatePhi.H"
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating turbulence model\n" << endl;
#include "readGravitationalAcceleration.H" autoPtr<compressible::turbulenceModel> turbulence
#include "readhRef.H" (
#include "gh.H" compressible::turbulenceModel::New
volScalarField p_rgh
( (
IOobject rho,
( U,
"p_rgh", phi,
runTime.timeName(), thermo
mesh, )
IOobject::MUST_READ, );
IOobject::AUTO_WRITE
), // Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
volScalarField dQ
(
IOobject
(
"dQ",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh mesh
); ),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
// Force p_rgh to be consistent with p Info<< "Creating field kinetic energy K\n" << endl;
p_rgh = p - rho*gh; volScalarField K("K", 0.5*magSqr(U));
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i) #include "readGravitationalAcceleration.H"
{ #include "readhRef.H"
fields.add(Y[i]); #include "gh.H"
}
fields.add(thermo.he());
IOdictionary additionalControlsDict
volScalarField p_rgh
(
IOobject
( (
IOobject "p_rgh",
( runTime.timeName(),
"additionalControls", mesh,
runTime.constant(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::MUST_READ_IF_MODIFIED, ),
IOobject::NO_WRITE mesh
) );
);
Switch solvePrimaryRegion // Force p_rgh to be consistent with p
p_rgh = p - rho*gh;
mesh.setFluxRequired(p_rgh.name());
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
IOdictionary additionalControlsDict
(
IOobject
( (
additionalControlsDict.lookup("solvePrimaryRegion") "additionalControls",
); runTime.constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
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" #include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
Info << "Creating turbulence model.\n" << nl; Info << "Creating turbulence model.\n" << nl;
autoPtr<compressible::turbulenceModel> turbulence 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" #include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
Info << "Creating turbulence model.\n" << nl; Info << "Creating turbulence model.\n" << nl;
autoPtr<compressible::turbulenceModel> turbulence 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& psi = thermo.psi();
const volScalarField& T = thermo.T(); const volScalarField& T = thermo.T();
#include "compressibleCreatePhi.H" #include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
Info << "Creating turbulence model.\n" << nl; Info << "Creating turbulence model.\n" << nl;
autoPtr<compressible::turbulenceModel> turbulence autoPtr<compressible::turbulenceModel> turbulence

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

@ -1,90 +1,92 @@
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");
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField rho
(
IOobject
( (
psiThermo::New(mesh) "rho",
); runTime.timeName(),
psiThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
volScalarField rho
(
IOobject
(
"rho",
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
thermo.rho()
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H"
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
pimple.dict(),
GREAT,
dimDensity
)
);
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
pimple.dict(),
0,
dimDensity
)
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh, mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0) IOobject::READ_IF_PRESENT,
); IOobject::AUTO_WRITE
),
thermo.rho()
);
Info<< "Creating field kinetic energy K\n" << endl; Info<< "Reading field U\n" << endl;
volScalarField K("K", 0.5*magSqr(U)); volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H"
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
pimple.dict(),
GREAT,
dimDensity
)
);
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
pimple.dict(),
0,
dimDensity
)
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
mesh.setFluxRequired(p.name());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));

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

@ -1,81 +1,83 @@
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");
volScalarField rho
(
IOobject
( (
psiThermo::New(mesh) "rho",
); runTime.timeName(),
psiThermo& thermo = pThermo(); mesh,
thermo.validate(args.executable(), "h", "e"); IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
thermo.rho()
);
volScalarField rho volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
( (
IOobject "U",
( runTime.timeName(),
"rho", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::READ_IF_PRESENT, ),
IOobject::AUTO_WRITE mesh
), );
thermo.rho()
);
volScalarField& p = thermo.p(); #include "compressibleCreatePhi.H"
const volScalarField& psi = thermo.psi();
Info<< "Reading field U\n" << endl;
volVectorField U label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, simple.dict(), pRefCell, pRefValue);
mesh.setFluxRequired(p.name());
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
( (
IOobject "rhoMax",
( simple.dict(),
"U", GREAT,
runTime.timeName(), dimDensity
mesh, )
IOobject::MUST_READ, );
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H" dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, simple.dict(), pRefCell, pRefValue);
dimensionedScalar rhoMax
( (
dimensionedScalar::lookupOrDefault "rhoMin",
( simple.dict(),
"rhoMax", 0,
simple.dict(), dimDensity
GREAT, )
dimDensity );
)
);
dimensionedScalar rhoMin Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
compressible::RASModel::New
( (
dimensionedScalar::lookupOrDefault rho,
( U,
"rhoMin", phi,
simple.dict(), thermo
0, )
dimDensity );
)
);
Info<< "Creating turbulence model\n" << endl; dimensionedScalar initialMass = fvc::domainIntegrate(rho);
autoPtr<compressible::RASModel> turbulence
(
compressible::RASModel::New
(
rho,
U,
phi,
thermo
)
);
dimensionedScalar initialMass = fvc::domainIntegrate(rho);

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

@ -1,80 +1,82 @@
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");
volScalarField rho
(
IOobject
( (
rhoThermo::New(mesh) "rho",
); runTime.timeName(),
rhoThermo& thermo = pThermo(); mesh,
thermo.validate(args.executable(), "h", "e"); IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
thermo.rho()
);
volScalarField rho volScalarField& p = thermo.p();
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
( (
IOobject "U",
( runTime.timeName(),
"rho", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::READ_IF_PRESENT, ),
IOobject::AUTO_WRITE mesh
), );
thermo.rho()
);
volScalarField& p = thermo.p(); #include "compressibleCreatePhi.H"
Info<< "Reading field U\n" << endl;
volVectorField U label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, simple.dict(), pRefCell, pRefValue);
mesh.setFluxRequired(p.name());
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
( (
IOobject "rhoMax",
( simple.dict(),
"U", GREAT,
runTime.timeName(), dimDensity
mesh, )
IOobject::MUST_READ, );
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H" dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, simple.dict(), pRefCell, pRefValue);
dimensionedScalar rhoMax
( (
dimensionedScalar::lookupOrDefault "rhoMin",
( simple.dict(),
"rhoMax", 0,
simple.dict(), dimDensity
GREAT, )
dimDensity );
)
);
dimensionedScalar rhoMin Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::RASModel> turbulence
(
compressible::RASModel::New
( (
dimensionedScalar::lookupOrDefault rho,
( U,
"rhoMin", phi,
simple.dict(), thermo
0, )
dimDensity );
)
);
Info<< "Creating turbulence model\n" << endl; dimensionedScalar initialMass = fvc::domainIntegrate(rho);
autoPtr<compressible::RASModel> turbulence
(
compressible::RASModel::New
(
rho,
U,
phi,
thermo
)
);
dimensionedScalar initialMass = fvc::domainIntegrate(rho);

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

@ -1,55 +1,56 @@
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");
volScalarField& p = thermo.p();
volScalarField& e = thermo.he();
const volScalarField& psi = thermo.psi();
volScalarField rho
(
IOobject
( (
psiThermo::New(mesh) "rho",
); runTime.timeName(),
psiThermo& thermo = pThermo();
thermo.validate(args.executable(), "e");
volScalarField& p = thermo.p();
volScalarField& e = thermo.he();
const volScalarField& psi = thermo.psi();
volScalarField rho
(
IOobject
(
"rho",
runTime.timeName(),
mesh
),
thermo.rho()
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh mesh
); ),
thermo.rho()
);
#include "compressibleCreatePhi.H" Info<< "Reading field U\n" << endl;
volVectorField U
(
Info<< "Creating turbulence model\n" << endl; IOobject
autoPtr<compressible::turbulenceModel> turbulence
( (
compressible::turbulenceModel::New "U",
( runTime.timeName(),
rho, mesh,
U, IOobject::MUST_READ,
phi, IOobject::AUTO_WRITE
thermo ),
) mesh
); );
Info<< "Creating field kinetic energy K\n" << endl; #include "compressibleCreatePhi.H"
volScalarField K("K", 0.5*magSqr(U));
mesh.setFluxRequired(p.name());
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));

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

@ -1,44 +1,46 @@
Info<< "Reading field p\n" << endl; Info<< "Reading field p\n" << endl;
volScalarField p volScalarField p
(
IOobject
( (
IOobject "p",
( runTime.timeName(),
"p", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::MUST_READ, ),
IOobject::AUTO_WRITE mesh
), );
mesh
);
Info<< "Reading field U\n" << endl; Info<< "Reading field U\n" << endl;
volVectorField U volVectorField U
(
IOobject
( (
IOobject "U",
( runTime.timeName(),
"U", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::MUST_READ, ),
IOobject::AUTO_WRITE mesh
), );
mesh
);
volScalarField rho volScalarField rho
(
IOobject
( (
IOobject "rho",
( runTime.timeName(),
"rho", mesh,
runTime.timeName(), IOobject::NO_READ,
mesh, IOobject::AUTO_WRITE
IOobject::NO_READ, ),
IOobject::AUTO_WRITE rhoO + psi*p
), );
rhoO + psi*p
);
#include "compressibleCreatePhi.H" #include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());

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

@ -1,107 +1,110 @@
Info<< "Reading transportProperties\n" << endl; Info<< "Reading transportProperties\n" << endl;
IOdictionary transportProperties IOdictionary transportProperties
(
IOobject
( (
IOobject "transportProperties",
( runTime.constant(),
"transportProperties", mesh,
runTime.constant(), IOobject::MUST_READ_IF_MODIFIED,
mesh, IOobject::NO_WRITE
IOobject::MUST_READ_IF_MODIFIED, )
IOobject::NO_WRITE );
)
);
dimensionedScalar rho dimensionedScalar rho
(
transportProperties.lookup("rho")
);
dimensionedScalar nu
(
transportProperties.lookup("nu")
);
dimensionedScalar mu
(
transportProperties.lookup("mu")
);
dimensionedScalar sigma
(
transportProperties.lookup("sigma")
);
Info<< "Reading field p\n" << endl;
volScalarField p
(
IOobject
( (
transportProperties.lookup("rho") "p",
); runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
dimensionedScalar nu
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
( (
transportProperties.lookup("nu") "U",
); runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
dimensionedScalar mu #include "createPhi.H"
Info<< "Reading field pB\n" << endl;
volScalarField pB
(
IOobject
( (
transportProperties.lookup("mu") "pB",
); runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
dimensionedScalar sigma
Info<< "Reading field B\n" << endl;
volVectorField B
(
IOobject
( (
transportProperties.lookup("sigma") "B",
); runTime.timeName(),
mesh,
Info<< "Reading field p\n" << endl; IOobject::MUST_READ,
volScalarField p IOobject::AUTO_WRITE
( ),
IOobject mesh
( );
"p",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
Info<< "Reading field U\n" << endl; #include "createPhiB.H"
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "createPhi.H" dimensionedScalar DB = 1.0/(mu*sigma);
DB.name() = "DB";
Info<< "Reading field pB\n" << endl; dimensionedScalar DBU = 1.0/(2.0*mu*rho);
volScalarField pB DBU.name() = "DBU";
(
IOobject
(
"pB",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
Info<< "Reading field B\n" << endl; label pRefCell = 0;
volVectorField B scalar pRefValue = 0.0;
( setRefCell(p, piso.dict(), pRefCell, pRefValue);
IOobject
(
"B",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
mesh.setFluxRequired(p.name());
#include "createPhiB.H" mesh.setFluxRequired(pB.name());
dimensionedScalar DB = 1.0/(mu*sigma);
DB.name() = "DB";
dimensionedScalar DBU = 1.0/(2.0*mu*rho);
DBU.name() = "DBU";
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, piso.dict(), pRefCell, pRefValue);

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

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

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

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

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

@ -1,88 +1,90 @@
Info<< "Reading thermophysical properties\n" << endl; Info<< "Reading thermophysical properties\n" << endl;
autoPtr<rhoThermo> pThermo(rhoThermo::New(mesh)); autoPtr<rhoThermo> pThermo(rhoThermo::New(mesh));
rhoThermo& thermo = pThermo(); rhoThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e"); thermo.validate(args.executable(), "h", "e");
volScalarField rho volScalarField rho
(
IOobject
( (
IOobject "rho",
( runTime.timeName(),
"rho",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
thermo.rho()
);
volScalarField& p = thermo.p();
const volScalarField& psi = thermo.psi();
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
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
(
IOobject
(
"p_rgh",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
// Force p_rgh to be consistent with p
p_rgh = p - rho*gh;
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh, mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0) IOobject::NO_READ,
); IOobject::NO_WRITE
),
thermo.rho()
);
Info<< "Creating field kinetic energy K\n" << endl; volScalarField& p = thermo.p();
volScalarField K("K", 0.5*magSqr(U)); const volScalarField& psi = thermo.psi();
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H"
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
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
(
IOobject
(
"p_rgh",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
// Force p_rgh to be consistent with p
p_rgh = p - rho*gh;
mesh.setFluxRequired(p_rgh.name());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));

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

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

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

@ -1,222 +1,224 @@
// Initialise fluid field pointer lists // Initialise fluid field pointer lists
PtrList<rhoThermo> thermoFluid(fluidRegions.size()); PtrList<rhoThermo> thermoFluid(fluidRegions.size());
PtrList<volScalarField> rhoFluid(fluidRegions.size()); PtrList<volScalarField> rhoFluid(fluidRegions.size());
PtrList<volVectorField> UFluid(fluidRegions.size()); PtrList<volVectorField> UFluid(fluidRegions.size());
PtrList<surfaceScalarField> phiFluid(fluidRegions.size()); PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size()); PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size());
PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size()); PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
PtrList<volScalarField> p_rghFluid(fluidRegions.size()); PtrList<volScalarField> p_rghFluid(fluidRegions.size());
PtrList<volScalarField> ghFluid(fluidRegions.size()); PtrList<volScalarField> ghFluid(fluidRegions.size());
PtrList<surfaceScalarField> ghfFluid(fluidRegions.size()); PtrList<surfaceScalarField> ghfFluid(fluidRegions.size());
PtrList<radiation::radiationModel> radiation(fluidRegions.size()); PtrList<radiation::radiationModel> radiation(fluidRegions.size());
List<scalar> initialMassFluid(fluidRegions.size()); List<scalar> initialMassFluid(fluidRegions.size());
List<label> pRefCellFluid(fluidRegions.size(), 0); List<label> pRefCellFluid(fluidRegions.size(), 0);
List<scalar> pRefValueFluid(fluidRegions.size(), 0.0); List<scalar> pRefValueFluid(fluidRegions.size(), 0.0);
List<bool> frozenFlowFluid(fluidRegions.size(), false); List<bool> frozenFlowFluid(fluidRegions.size(), false);
PtrList<dimensionedScalar> rhoMax(fluidRegions.size()); PtrList<dimensionedScalar> rhoMax(fluidRegions.size());
PtrList<dimensionedScalar> rhoMin(fluidRegions.size()); PtrList<dimensionedScalar> rhoMin(fluidRegions.size());
PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size()); PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size());
PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size()); PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size());
// Populate fluid field pointer lists // Populate fluid field pointer lists
forAll(fluidRegions, i) forAll(fluidRegions, i)
{ {
Info<< "*** Reading fluid mesh thermophysical properties for region " Info<< "*** Reading fluid mesh thermophysical properties for region "
<< fluidRegions[i].name() << nl << endl; << fluidRegions[i].name() << nl << endl;
Info<< " Adding to thermoFluid\n" << endl; Info<< " Adding to thermoFluid\n" << endl;
thermoFluid.set thermoFluid.set
(
i,
rhoThermo::New(fluidRegions[i]).ptr()
);
Info<< " Adding to rhoFluid\n" << endl;
rhoFluid.set
(
i,
new volScalarField
( (
i, IOobject
rhoThermo::New(fluidRegions[i]).ptr()
);
Info<< " Adding to rhoFluid\n" << endl;
rhoFluid.set
(
i,
new volScalarField
( (
IOobject "rho",
( runTime.timeName(),
"rho", fluidRegions[i],
runTime.timeName(), IOobject::NO_READ,
fluidRegions[i], IOobject::AUTO_WRITE
IOobject::NO_READ, ),
IOobject::AUTO_WRITE thermoFluid[i].rho()
), )
thermoFluid[i].rho() );
Info<< " Adding to UFluid\n" << endl;
UFluid.set
(
i,
new volVectorField
(
IOobject
(
"U",
runTime.timeName(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
fluidRegions[i]
)
);
Info<< " Adding to phiFluid\n" << endl;
phiFluid.set
(
i,
new surfaceScalarField
(
IOobject
(
"phi",
runTime.timeName(),
fluidRegions[i],
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
linearInterpolate(rhoFluid[i]*UFluid[i])
& fluidRegions[i].Sf()
)
);
Info<< " Adding to gFluid\n" << endl;
gFluid.set
(
i,
new uniformDimensionedVectorField
(
IOobject
(
"g",
runTime.constant(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::NO_WRITE
) )
); )
);
Info<< " Adding to UFluid\n" << endl; Info<< " Adding to turbulence\n" << endl;
UFluid.set turbulence.set
(
i,
compressible::turbulenceModel::New
( (
i, rhoFluid[i],
new volVectorField UFluid[i],
phiFluid[i],
thermoFluid[i]
).ptr()
);
Info<< " Adding to ghFluid\n" << endl;
ghFluid.set
(
i,
new volScalarField("gh", gFluid[i] & fluidRegions[i].C())
);
Info<< " Adding to ghfFluid\n" << endl;
ghfFluid.set
(
i,
new surfaceScalarField("ghf", gFluid[i] & fluidRegions[i].Cf())
);
p_rghFluid.set
(
i,
new volScalarField
(
IOobject
( (
IOobject "p_rgh",
( runTime.timeName(),
"U", fluidRegions[i],
runTime.timeName(), IOobject::MUST_READ,
fluidRegions[i], IOobject::AUTO_WRITE
IOobject::MUST_READ, ),
IOobject::AUTO_WRITE fluidRegions[i]
), )
fluidRegions[i] );
// 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,
radiation::radiationModel::New(thermoFluid[i].T())
);
initialMassFluid[i] = fvc::domainIntegrate(rhoFluid[i]).value();
const dictionary& simpleDict =
fluidRegions[i].solutionDict().subDict("SIMPLE");
setRefCell
(
thermoFluid[i].p(),
p_rghFluid[i],
simpleDict,
pRefCellFluid[i],
pRefValueFluid[i]
);
simpleDict.readIfPresent("frozenFlow", frozenFlowFluid[i]);
rhoMax.set
(
i,
new dimensionedScalar
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
simpleDict,
GREAT,
dimDensity
) )
); )
);
Info<< " Adding to phiFluid\n" << endl; rhoMin.set
phiFluid.set (
i,
new dimensionedScalar
( (
i, dimensionedScalar::lookupOrDefault
new surfaceScalarField
( (
IOobject "rhoMin",
( simpleDict,
"phi", 0,
runTime.timeName(), dimDensity
fluidRegions[i],
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
linearInterpolate(rhoFluid[i]*UFluid[i])
& fluidRegions[i].Sf()
) )
); )
);
Info<< " Adding to gFluid\n" << endl; Info<< " Adding MRF\n" << endl;
gFluid.set MRFfluid.set
( (
i, i,
new uniformDimensionedVectorField new IOMRFZoneList(fluidRegions[i])
( );
IOobject
(
"g",
runTime.constant(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::NO_WRITE
)
)
);
Info<< " Adding to turbulence\n" << endl; Info<< " Adding fvOptions\n" << endl;
turbulence.set fluidFvOptions.set
( (
i, i,
compressible::turbulenceModel::New new fv::IOoptionList(fluidRegions[i])
( );
rhoFluid[i], }
UFluid[i],
phiFluid[i],
thermoFluid[i]
).ptr()
);
Info<< " Adding to ghFluid\n" << endl;
ghFluid.set
(
i,
new volScalarField("gh", gFluid[i] & fluidRegions[i].C())
);
Info<< " Adding to ghfFluid\n" << endl;
ghfFluid.set
(
i,
new surfaceScalarField("ghf", gFluid[i] & fluidRegions[i].Cf())
);
p_rghFluid.set
(
i,
new volScalarField
(
IOobject
(
"p_rgh",
runTime.timeName(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
fluidRegions[i]
)
);
// Force p_rgh to be consistent with p
p_rghFluid[i] = thermoFluid[i].p() - rhoFluid[i]*ghFluid[i];
radiation.set
(
i,
radiation::radiationModel::New(thermoFluid[i].T())
);
initialMassFluid[i] = fvc::domainIntegrate(rhoFluid[i]).value();
const dictionary& simpleDict =
fluidRegions[i].solutionDict().subDict("SIMPLE");
setRefCell
(
thermoFluid[i].p(),
p_rghFluid[i],
simpleDict,
pRefCellFluid[i],
pRefValueFluid[i]
);
simpleDict.readIfPresent("frozenFlow", frozenFlowFluid[i]);
rhoMax.set
(
i,
new dimensionedScalar
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
simpleDict,
GREAT,
dimDensity
)
)
);
rhoMin.set
(
i,
new dimensionedScalar
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
simpleDict,
0,
dimDensity
)
)
);
Info<< " Adding MRF\n" << endl;
MRFfluid.set
(
i,
new IOMRFZoneList(fluidRegions[i])
);
Info<< " Adding fvOptions\n" << endl;
fluidFvOptions.set
(
i,
new fv::IOoptionList(fluidRegions[i])
);
}

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

@ -1,212 +1,214 @@
// Initialise fluid field pointer lists // Initialise fluid field pointer lists
PtrList<rhoThermo> thermoFluid(fluidRegions.size()); PtrList<rhoThermo> thermoFluid(fluidRegions.size());
PtrList<volScalarField> rhoFluid(fluidRegions.size()); PtrList<volScalarField> rhoFluid(fluidRegions.size());
PtrList<volVectorField> UFluid(fluidRegions.size()); PtrList<volVectorField> UFluid(fluidRegions.size());
PtrList<surfaceScalarField> phiFluid(fluidRegions.size()); PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size()); PtrList<uniformDimensionedVectorField> gFluid(fluidRegions.size());
PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size()); PtrList<compressible::turbulenceModel> turbulence(fluidRegions.size());
PtrList<volScalarField> p_rghFluid(fluidRegions.size()); PtrList<volScalarField> p_rghFluid(fluidRegions.size());
PtrList<volScalarField> ghFluid(fluidRegions.size()); PtrList<volScalarField> ghFluid(fluidRegions.size());
PtrList<surfaceScalarField> ghfFluid(fluidRegions.size()); PtrList<surfaceScalarField> ghfFluid(fluidRegions.size());
PtrList<radiation::radiationModel> radiation(fluidRegions.size()); PtrList<radiation::radiationModel> radiation(fluidRegions.size());
PtrList<volScalarField> KFluid(fluidRegions.size()); PtrList<volScalarField> KFluid(fluidRegions.size());
PtrList<volScalarField> dpdtFluid(fluidRegions.size()); PtrList<volScalarField> dpdtFluid(fluidRegions.size());
List<scalar> initialMassFluid(fluidRegions.size()); List<scalar> initialMassFluid(fluidRegions.size());
List<bool> frozenFlowFluid(fluidRegions.size(), false); List<bool> frozenFlowFluid(fluidRegions.size(), false);
PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size()); PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size());
PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size()); PtrList<fv::IOoptionList> fluidFvOptions(fluidRegions.size());
// Populate fluid field pointer lists // Populate fluid field pointer lists
forAll(fluidRegions, i) forAll(fluidRegions, i)
{ {
Info<< "*** Reading fluid mesh thermophysical properties for region " Info<< "*** Reading fluid mesh thermophysical properties for region "
<< fluidRegions[i].name() << nl << endl; << fluidRegions[i].name() << nl << endl;
Info<< " Adding to thermoFluid\n" << endl; Info<< " Adding to thermoFluid\n" << endl;
thermoFluid.set thermoFluid.set
(
i,
rhoThermo::New(fluidRegions[i]).ptr()
);
Info<< " Adding to rhoFluid\n" << endl;
rhoFluid.set
(
i,
new volScalarField
( (
i, IOobject
rhoThermo::New(fluidRegions[i]).ptr()
);
Info<< " Adding to rhoFluid\n" << endl;
rhoFluid.set
(
i,
new volScalarField
( (
IOobject "rho",
( runTime.timeName(),
"rho",
runTime.timeName(),
fluidRegions[i],
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
thermoFluid[i].rho()
)
);
Info<< " Adding to UFluid\n" << endl;
UFluid.set
(
i,
new volVectorField
(
IOobject
(
"U",
runTime.timeName(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
fluidRegions[i]
)
);
Info<< " Adding to phiFluid\n" << endl;
phiFluid.set
(
i,
new surfaceScalarField
(
IOobject
(
"phi",
runTime.timeName(),
fluidRegions[i],
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
linearInterpolate(rhoFluid[i]*UFluid[i])
& fluidRegions[i].Sf()
)
);
Info<< " Adding to gFluid\n" << endl;
gFluid.set
(
i,
new uniformDimensionedVectorField
(
IOobject
(
"g",
runTime.constant(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::NO_WRITE
)
)
);
Info<< " Adding to turbulence\n" << endl;
turbulence.set
(
i,
compressible::turbulenceModel::New
(
rhoFluid[i],
UFluid[i],
phiFluid[i],
thermoFluid[i]
).ptr()
);
Info<< " Adding to ghFluid\n" << endl;
ghFluid.set
(
i,
new volScalarField("gh", gFluid[i] & fluidRegions[i].C())
);
Info<< " Adding to ghfFluid\n" << endl;
ghfFluid.set
(
i,
new surfaceScalarField("ghf", gFluid[i] & fluidRegions[i].Cf())
);
p_rghFluid.set
(
i,
new volScalarField
(
IOobject
(
"p_rgh",
runTime.timeName(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
fluidRegions[i]
)
);
// Force p_rgh to be consistent with p
p_rghFluid[i] = thermoFluid[i].p() - rhoFluid[i]*ghFluid[i];
radiation.set
(
i,
radiation::radiationModel::New(thermoFluid[i].T())
);
initialMassFluid[i] = fvc::domainIntegrate(rhoFluid[i]).value();
Info<< " Adding to KFluid\n" << endl;
KFluid.set
(
i,
new volScalarField
(
"K",
0.5*magSqr(UFluid[i])
)
);
Info<< " Adding to dpdtFluid\n" << endl;
dpdtFluid.set
(
i,
new volScalarField
(
IOobject
(
"dpdt",
runTime.timeName(),
fluidRegions[i]
),
fluidRegions[i], fluidRegions[i],
dimensionedScalar IOobject::NO_READ,
( IOobject::AUTO_WRITE
"dpdt", ),
thermoFluid[i].p().dimensions()/dimTime, thermoFluid[i].rho()
0 )
) );
Info<< " Adding to UFluid\n" << endl;
UFluid.set
(
i,
new volVectorField
(
IOobject
(
"U",
runTime.timeName(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
fluidRegions[i]
)
);
Info<< " Adding to phiFluid\n" << endl;
phiFluid.set
(
i,
new surfaceScalarField
(
IOobject
(
"phi",
runTime.timeName(),
fluidRegions[i],
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
linearInterpolate(rhoFluid[i]*UFluid[i])
& fluidRegions[i].Sf()
)
);
Info<< " Adding to gFluid\n" << endl;
gFluid.set
(
i,
new uniformDimensionedVectorField
(
IOobject
(
"g",
runTime.constant(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::NO_WRITE
) )
); )
);
const dictionary& pimpleDict = Info<< " Adding to turbulence\n" << endl;
fluidRegions[i].solutionDict().subDict("PIMPLE"); turbulence.set
pimpleDict.readIfPresent("frozenFlow", frozenFlowFluid[i]); (
i,
Info<< " Adding MRF\n" << endl; compressible::turbulenceModel::New
MRFfluid.set
( (
i, rhoFluid[i],
new IOMRFZoneList(fluidRegions[i]) UFluid[i],
); phiFluid[i],
thermoFluid[i]
).ptr()
);
Info<< " Adding fvOptions\n" << endl; Info<< " Adding to ghFluid\n" << endl;
fluidFvOptions.set ghFluid.set
(
i,
new volScalarField("gh", gFluid[i] & fluidRegions[i].C())
);
Info<< " Adding to ghfFluid\n" << endl;
ghfFluid.set
(
i,
new surfaceScalarField("ghf", gFluid[i] & fluidRegions[i].Cf())
);
p_rghFluid.set
(
i,
new volScalarField
( (
i, IOobject
new fv::IOoptionList(fluidRegions[i]) (
); "p_rgh",
} runTime.timeName(),
fluidRegions[i],
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
fluidRegions[i]
)
);
// 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,
radiation::radiationModel::New(thermoFluid[i].T())
);
initialMassFluid[i] = fvc::domainIntegrate(rhoFluid[i]).value();
Info<< " Adding to KFluid\n" << endl;
KFluid.set
(
i,
new volScalarField
(
"K",
0.5*magSqr(UFluid[i])
)
);
Info<< " Adding to dpdtFluid\n" << endl;
dpdtFluid.set
(
i,
new volScalarField
(
IOobject
(
"dpdt",
runTime.timeName(),
fluidRegions[i]
),
fluidRegions[i],
dimensionedScalar
(
"dpdt",
thermoFluid[i].p().dimensions()/dimTime,
0
)
)
);
const dictionary& pimpleDict =
fluidRegions[i].solutionDict().subDict("PIMPLE");
pimpleDict.readIfPresent("frozenFlow", frozenFlowFluid[i]);
Info<< " Adding MRF\n" << endl;
MRFfluid.set
(
i,
new IOMRFZoneList(fluidRegions[i])
);
Info<< " Adding fvOptions\n" << endl;
fluidFvOptions.set
(
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");

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

@ -1,164 +1,165 @@
word continuousPhaseName word continuousPhaseName
( (
IOdictionary IOdictionary
(
IOobject
(
"transportProperties",
runTime.constant(),
mesh,
IOobject::MUST_READ
)
).lookup("continuousPhaseName")
);
Info<< "Reading field U\n" << endl;
volVectorField Uc
( (
IOobject IOobject
( (
IOobject::groupName("U", continuousPhaseName), "transportProperties",
runTime.timeName(), runTime.constant(),
mesh, mesh,
IOobject::MUST_READ, IOobject::MUST_READ
IOobject::AUTO_WRITE
),
mesh
);
Info<< "Reading field p\n" << endl;
volScalarField p
(
IOobject
(
"p",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
Info<< "Reading/calculating continuous-phase face flux field phic\n"
<< endl;
surfaceScalarField phic
(
IOobject
(
IOobject::groupName("phi", continuousPhaseName),
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
linearInterpolate(Uc) & mesh.Sf()
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, pimple.dict(), pRefCell, pRefValue);
Info<< "Creating turbulence model\n" << endl;
singlePhaseTransportModel continuousPhaseTransport(Uc, phic);
dimensionedScalar rhocValue
(
IOobject::groupName("rho", continuousPhaseName),
dimDensity,
continuousPhaseTransport.lookup
(
IOobject::groupName("rho", continuousPhaseName)
) )
); ).lookup("continuousPhaseName")
);
volScalarField rhoc Info<< "Reading field U\n" << endl;
volVectorField Uc
(
IOobject
( (
IOobject IOobject::groupName("U", continuousPhaseName),
( runTime.timeName(),
rhocValue.name(),
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh, mesh,
rhocValue IOobject::MUST_READ,
); IOobject::AUTO_WRITE
),
mesh
);
volScalarField muc Info<< "Reading field p\n" << endl;
volScalarField p
(
IOobject
( (
IOobject "p",
( runTime.timeName(),
IOobject::groupName("mu", continuousPhaseName),
runTime.timeName(),
mesh,
IOobject::NO_READ,
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
(
IOobject
(
IOobject::groupName("alpha", continuousPhaseName),
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
mesh, mesh,
dimensionedScalar("0", dimless, 0) IOobject::MUST_READ,
); IOobject::AUTO_WRITE
),
mesh
);
word kinematicCloudName("kinematicCloud");
args.optionReadIfPresent("cloudName", kinematicCloudName);
Info<< "Constructing kinematicCloud " << kinematicCloudName << endl; Info<< "Reading/calculating continuous-phase face flux field phic\n"
basicKinematicTypeCloud kinematicCloud << endl;
surfaceScalarField phic
(
IOobject
( (
kinematicCloudName, IOobject::groupName("phi", continuousPhaseName),
rhoc, runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
linearInterpolate(Uc) & mesh.Sf()
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell(p, pimple.dict(), pRefCell, pRefValue);
mesh.setFluxRequired(p.name());
Info<< "Creating turbulence model\n" << endl;
singlePhaseTransportModel continuousPhaseTransport(Uc, phic);
dimensionedScalar rhocValue
(
IOobject::groupName("rho", continuousPhaseName),
dimDensity,
continuousPhaseTransport.lookup
(
IOobject::groupName("rho", continuousPhaseName)
)
);
volScalarField rhoc
(
IOobject
(
rhocValue.name(),
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
rhocValue
);
volScalarField muc
(
IOobject
(
IOobject::groupName("mu", continuousPhaseName),
runTime.timeName(),
mesh,
IOobject::NO_READ,
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
(
IOobject
(
IOobject::groupName("alpha", continuousPhaseName),
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("0", dimless, 0)
);
word kinematicCloudName("kinematicCloud");
args.optionReadIfPresent("cloudName", kinematicCloudName);
Info<< "Constructing kinematicCloud " << kinematicCloudName << endl;
basicKinematicTypeCloud kinematicCloud
(
kinematicCloudName,
rhoc,
Uc,
muc,
g
);
// 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();
surfaceScalarField alphacf("alphacf", fvc::interpolate(alphac));
surfaceScalarField alphaPhic("alphaPhic", alphacf*phic);
autoPtr<PhaseIncompressibleTurbulenceModel<singlePhaseTransportModel> >
continuousPhaseTurbulence
(
PhaseIncompressibleTurbulenceModel<singlePhaseTransportModel>::New
(
alphac,
Uc, Uc,
muc, alphaPhic,
g phic,
); continuousPhaseTransport
)
// 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();
surfaceScalarField alphacf("alphacf", fvc::interpolate(alphac));
surfaceScalarField alphaPhic("alphaPhic", alphacf*phic);
autoPtr<PhaseIncompressibleTurbulenceModel<singlePhaseTransportModel> >
continuousPhaseTurbulence
(
PhaseIncompressibleTurbulenceModel<singlePhaseTransportModel>::New
(
alphac,
Uc,
alphaPhic,
phic,
continuousPhaseTransport
)
);

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

@ -1,141 +1,143 @@
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");
SLGThermo slgThermo(mesh, thermo);
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("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();
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
volScalarField rho
(
IOobject
( (
combustionModels::psiCombustionModel::New(mesh) "rho",
); runTime.timeName(),
psiReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("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();
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
volScalarField rho
(
IOobject
(
"rho",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
thermo.rho()
);
// lagrangian effective density field - used externally (optional)
volScalarField rhoEffLagrangian
(
IOobject
(
"rhoEffLagrangian",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh, mesh,
dimensionedScalar("zero", dimDensity, 0.0) IOobject::NO_READ,
); IOobject::AUTO_WRITE
),
thermo.rho()
);
// dynamic pressure field - used externally (optional) // lagrangian effective density field - used externally (optional)
volScalarField pDyn volScalarField rhoEffLagrangian
(
IOobject
( (
IOobject "rhoEffLagrangian",
( runTime.timeName(),
"pDyn",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh, mesh,
dimensionedScalar("zero", dimPressure, 0.0) IOobject::NO_READ,
); IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("zero", dimDensity, 0.0)
);
// dynamic pressure field - used externally (optional)
Info<< "\nReading field U\n" << endl; volScalarField pDyn
volVectorField U (
IOobject
( (
IOobject "pDyn",
( runTime.timeName(),
"U", mesh,
runTime.timeName(), IOobject::NO_READ,
mesh, IOobject::AUTO_WRITE
IOobject::MUST_READ, ),
IOobject::AUTO_WRITE mesh,
), dimensionedScalar("zero", dimPressure, 0.0)
);
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh mesh
); ),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
#include "compressibleCreatePhi.H" Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
Info<< "Creating turbulence model\n" << endl; volScalarField dQ
autoPtr<compressible::turbulenceModel> turbulence (
IOobject
( (
compressible::turbulenceModel::New "dQ",
( runTime.timeName(),
rho,
U,
phi,
thermo
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh, mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0) IOobject::NO_READ,
); IOobject::AUTO_WRITE
),
Info<< "Creating field kinetic energy K\n" << endl; mesh,
volScalarField K("K", 0.5*magSqr(U)); dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);
volScalarField dQ
(
IOobject
(
"dQ",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);

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

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

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

@ -1,133 +1,135 @@
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");
SLGThermo slgThermo(mesh, thermo);
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("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 rho
(
IOobject
( (
combustionModels::rhoCombustionModel::New(mesh) "rho",
); runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
thermo.rho()
);
rhoReactionThermo& thermo = combustion->thermo(); Info<< "\nReading field U\n" << endl;
thermo.validate(args.executable(), "h", "e"); volVectorField U
(
SLGThermo slgThermo(mesh, thermo); IOobject
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("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 rho
( (
IOobject "U",
( runTime.timeName(),
"rho", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::NO_READ, ),
IOobject::AUTO_WRITE mesh
), );
thermo.rho()
);
Info<< "\nReading field U\n" << endl; #include "compressibleCreatePhi.H"
volVectorField U
mesh.setFluxRequired(p.name());
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
( (
IOobject "rhoMax",
( pimple.dict(),
"U", GREAT,
runTime.timeName(), dimDensity
mesh, )
IOobject::MUST_READ, );
IOobject::AUTO_WRITE
), dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
pimple.dict(),
0,
dimDensity
)
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh mesh
); ),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
#include "compressibleCreatePhi.H" Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
dimensionedScalar rhoMax Info<< "Creating multi-variate interpolation scheme\n" << endl;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
volScalarField dQ
(
IOobject
( (
dimensionedScalar::lookupOrDefault "dQ",
( runTime.timeName(),
"rhoMax",
pimple.dict(),
GREAT,
dimDensity
)
);
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
pimple.dict(),
0,
dimDensity
)
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh, mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0) IOobject::NO_READ,
); IOobject::AUTO_WRITE
),
Info<< "Creating field kinetic energy K\n" << endl; mesh,
volScalarField K("K", 0.5*magSqr(U)); dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);
Info<< "Creating multi-variate interpolation scheme\n" << endl;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
volScalarField dQ
(
IOobject
(
"dQ",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);

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

@ -1,118 +1,119 @@
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");
SLGThermo slgThermo(mesh, thermo);
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("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 rho
(
IOobject
( (
combustionModels::rhoCombustionModel::New(mesh) "rho",
); runTime.timeName(),
rhoReactionThermo& thermo = combustion->thermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("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 rho
(
IOobject
(
"rho",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
thermo.rho()
);
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H"
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
simple.dict(),
GREAT,
dimDensity
)
);
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
simple.dict(),
0,
dimDensity
)
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating multi-variate interpolation scheme\n" << endl;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
volScalarField dQ
(
IOobject
(
"dQ",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh, mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0) IOobject::NO_READ,
); IOobject::AUTO_WRITE
),
thermo.rho()
);
Info<< "\nReading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "compressibleCreatePhi.H"
mesh.setFluxRequired(p.name());
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
simple.dict(),
GREAT,
dimDensity
)
);
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
simple.dict(),
0,
dimDensity
)
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating multi-variate interpolation scheme\n" << endl;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
volScalarField dQ
(
IOobject
(
"dQ",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
);

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

@ -1,131 +1,133 @@
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");
SLGThermo slgThermo(mesh, thermo);
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("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 rho
(
IOobject
( (
combustionModels::psiCombustionModel::New(mesh) "rho",
); runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
thermo.rho()
);
psiReactionThermo& thermo = combustion->thermo(); Info<< "\nReading field U\n" << endl;
thermo.validate(args.executable(), "h", "e"); volVectorField U
(
SLGThermo slgThermo(mesh, thermo); IOobject
basicSpecieMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
const word inertSpecie(thermo.lookup("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 rho
( (
IOobject "U",
( runTime.timeName(),
"rho", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::READ_IF_PRESENT, ),
IOobject::AUTO_WRITE mesh
), );
thermo.rho()
);
Info<< "\nReading field U\n" << endl; #include "compressibleCreatePhi.H"
volVectorField U
mesh.setFluxRequired(p.name());
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
( (
IOobject "rhoMax",
( pimple.dict(),
"U", GREAT,
runTime.timeName(), dimDensity
mesh, )
IOobject::MUST_READ, );
IOobject::AUTO_WRITE
), dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
pimple.dict(),
0,
dimDensity
)
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh mesh
); ),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
#include "compressibleCreatePhi.H" Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K("K", 0.5*magSqr(U));
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
dimensionedScalar rhoMax forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
volScalarField dQ
(
IOobject
( (
dimensionedScalar::lookupOrDefault "dQ",
( runTime.timeName(),
"rhoMax",
pimple.dict(),
GREAT,
dimDensity
)
);
dimensionedScalar rhoMin
(
dimensionedScalar::lookupOrDefault
(
"rhoMin",
pimple.dict(),
0,
dimDensity
)
);
Info<< "Creating turbulence model\n" << endl;
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New
(
rho,
U,
phi,
thermo
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh, mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0) IOobject::NO_READ,
); IOobject::AUTO_WRITE
),
Info<< "Creating field kinetic energy K\n" << endl; mesh,
volScalarField K("K", 0.5*magSqr(U)); dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields; );
forAll(Y, i)
{
fields.add(Y[i]);
}
fields.add(thermo.he());
volScalarField dQ
(
IOobject
(
"dQ",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
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)")); surfaceScalarField rhof(fvc::interpolate(rho, "div(phi,rho)"));
dimensionedScalar rAUf("rAUf", dimTime, 1.0); dimensionedScalar rAUf("rAUf", dimTime, 1.0);
mesh.setFluxRequired(pcorr.name());
while (pimple.correctNonOrthogonal()) while (pimple.correctNonOrthogonal())
{ {
fvScalarMatrix pcorrEqn fvScalarMatrix pcorrEqn

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -1,115 +1,116 @@
Info<< "Reading field p_rgh\n" << endl; Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh volScalarField p_rgh
(
IOobject
( (
IOobject "p_rgh",
( runTime.timeName(),
"p_rgh",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh, mesh,
dimensionedVector("U", dimVelocity, vector::zero) IOobject::MUST_READ,
); IOobject::AUTO_WRITE
),
mesh
);
surfaceScalarField phi volVectorField U
(
IOobject
( (
IOobject "U",
( runTime.timeName(),
"phi",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh, mesh,
dimensionedScalar("phi", dimArea*dimVelocity, 0) IOobject::NO_READ,
); IOobject::AUTO_WRITE
),
mesh,
dimensionedVector("U", dimVelocity, vector::zero)
);
multiphaseSystem fluid(U, phi); surfaceScalarField phi
(
forAllIter(PtrDictionary<phaseModel>, fluid.phases(), iter) IOobject
{
phaseModel& phase = iter();
const volScalarField& alpha = phase;
U += alpha*phase.U();
phi += fvc::interpolate(alpha)*phase.phi();
}
scalar slamDampCoeff
( (
fluid.lookupOrDefault<scalar>("slamDampCoeff", 1) "phi",
); runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("phi", dimArea*dimVelocity, 0)
);
dimensionedScalar maxSlamVelocity multiphaseSystem fluid(U, phi);
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
(
fluid.lookupOrDefault<scalar>("slamDampCoeff", 1)
);
dimensionedScalar maxSlamVelocity
(
"maxSlamVelocity",
dimVelocity,
fluid.lookupOrDefault<scalar>("maxSlamVelocity", GREAT)
);
volScalarField rho
(
IOobject
( (
"maxSlamVelocity", "rho",
dimVelocity, runTime.timeName(),
fluid.lookupOrDefault<scalar>("maxSlamVelocity", GREAT) mesh,
); IOobject::NO_READ,
IOobject::AUTO_WRITE
),
fluid.rho()
);
volScalarField rho // Construct incompressible turbulence model
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, fluid)
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"
#include "gh.H"
volScalarField p
(
IOobject
( (
IOobject "p",
( runTime.timeName(),
"rho", mesh,
runTime.timeName(), IOobject::NO_READ,
mesh, IOobject::AUTO_WRITE
IOobject::NO_READ, ),
IOobject::AUTO_WRITE p_rgh + rho*gh
), );
fluid.rho()
);
label pRefCell = 0;
// Construct incompressible turbulence model scalar pRefValue = 0.0;
autoPtr<incompressible::turbulenceModel> turbulence setRefCell
( (
incompressible::turbulenceModel::New(U, phi, fluid) p,
); p_rgh,
pimple.dict(),
pRefCell,
#include "readGravitationalAcceleration.H" pRefValue
#include "readhRef.H" );
#include "gh.H" mesh.setFluxRequired(p_rgh.name());
volScalarField p
(
IOobject
(
"p",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
p_rgh + rho*gh
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);

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

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

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

@ -1,76 +1,77 @@
Info<< "Reading field p (kinematic)\n" << endl; Info<< "Reading field p (kinematic)\n" << endl;
volScalarField p volScalarField p
(
IOobject
( (
IOobject "p",
( runTime.timeName(),
"p",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
#include "createPhi.H"
singlePhaseTransportModel laminarTransport(U, phi);
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, laminarTransport)
);
#include "readGravitationalAcceleration.H"
Info<< "Creating field zeta\n" << endl;
volVectorField zeta
(
IOobject
(
"zeta",
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
mesh, mesh,
dimensionedVector("zero", dimLength, vector::zero) IOobject::MUST_READ,
); IOobject::AUTO_WRITE
),
mesh
);
Info<< "Creating field p_gh\n" << endl; Info<< "Reading field U\n" << endl;
volScalarField p_gh volVectorField U
(
IOobject
( (
IOobject "U",
( runTime.timeName(),
"p_gh", mesh,
runTime.timeName(), IOobject::MUST_READ,
mesh, IOobject::AUTO_WRITE
IOobject::MUST_READ, ),
IOobject::AUTO_WRITE mesh
), );
mesh
);
// Force p_gh to be consistent with p #include "createPhi.H"
// Height is made relative to field 'refLevel'
p_gh = p - (g & mesh.C()); singlePhaseTransportModel laminarTransport(U, phi);
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, laminarTransport)
);
#include "readGravitationalAcceleration.H"
Info<< "Creating field zeta\n" << endl;
volVectorField zeta
(
IOobject
(
"zeta",
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
mesh,
dimensionedVector("zero", dimLength, vector::zero)
);
Info<< "Creating field p_gh\n" << endl;
volScalarField p_gh
(
IOobject
(
"p_gh",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
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());
label p_ghRefCell = 0; label p_ghRefCell = 0;
scalar p_ghRefValue = 0.0; scalar p_ghRefValue = 0.0;
setRefCell(p_gh, pimple.dict(), p_ghRefCell, p_ghRefValue); setRefCell(p_gh, pimple.dict(), p_ghRefCell, p_ghRefValue);
mesh.setFluxRequired(p_gh.name());

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

@ -1,76 +1,78 @@
#include "readGravitationalAcceleration.H" #include "readGravitationalAcceleration.H"
#include "readhRef.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();
phaseModel& phase1 = fluid.phase1();
phaseModel& phase2 = fluid.phase2();
volScalarField& alpha1 = phase1;
volScalarField& alpha2 = phase2;
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();
surfaceScalarField& phi = fluid.phi();
dimensionedScalar pMin
(
"pMin",
dimPressure,
fluid.lookup("pMin")
);
#include "gh.H"
rhoThermo& thermo1 = phase1.thermo();
rhoThermo& thermo2 = phase2.thermo();
volScalarField& p = thermo1.p();
volScalarField& rho1 = thermo1.rho();
const volScalarField& psi1 = thermo1.psi();
volScalarField& rho2 = thermo2.rho();
const volScalarField& psi2 = thermo2.psi();
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
( (
twoPhaseSystem::New(mesh) "p_rgh",
); runTime.timeName(),
twoPhaseSystem& fluid = fluidPtr(); mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
phaseModel& phase1 = fluid.phase1(); label pRefCell = 0;
phaseModel& phase2 = fluid.phase2(); scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
mesh.setFluxRequired(p_rgh.name());
mesh.setFluxRequired(alpha1.name());
volScalarField& alpha1 = phase1; const IOMRFZoneList& MRF = fluid.MRF();
volScalarField& alpha2 = phase2; fv::IOoptionList& fvOptions = fluid.fvOptions();
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();
surfaceScalarField& phi = fluid.phi();
dimensionedScalar pMin
(
"pMin",
dimPressure,
fluid.lookup("pMin")
);
#include "gh.H"
rhoThermo& thermo1 = phase1.thermo();
rhoThermo& thermo2 = phase2.thermo();
volScalarField& p = thermo1.p();
volScalarField& rho1 = thermo1.rho();
const volScalarField& psi1 = thermo1.psi();
volScalarField& rho2 = thermo2.rho();
const volScalarField& psi2 = thermo2.psi();
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
const IOMRFZoneList& MRF = fluid.MRF();
fv::IOoptionList& fvOptions = fluid.fvOptions();

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

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

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

@ -1,100 +1,102 @@
#include "readGravitationalAcceleration.H" #include "readGravitationalAcceleration.H"
#include "readhRef.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& phase1 = fluid.phase1();
phaseModel& phase2 = fluid.phase2(); phaseModel& phase2 = fluid.phase2();
volScalarField& alpha1 = phase1; volScalarField& alpha1 = phase1;
volScalarField& alpha2 = phase2; volScalarField& alpha2 = phase2;
volVectorField& U1 = phase1.U(); volVectorField& U1 = phase1.U();
surfaceScalarField& phi1 = phase1.phi(); surfaceScalarField& phi1 = phase1.phi();
surfaceScalarField& alphaPhi1 = phase1.alphaPhi(); surfaceScalarField& alphaPhi1 = phase1.alphaPhi();
surfaceScalarField& alphaRhoPhi1 = phase1.alphaRhoPhi(); surfaceScalarField& alphaRhoPhi1 = phase1.alphaRhoPhi();
volVectorField& U2 = phase2.U(); volVectorField& U2 = phase2.U();
surfaceScalarField& phi2 = phase2.phi(); surfaceScalarField& phi2 = phase2.phi();
surfaceScalarField& alphaPhi2 = phase2.alphaPhi(); surfaceScalarField& alphaPhi2 = phase2.alphaPhi();
surfaceScalarField& alphaRhoPhi2 = phase2.alphaRhoPhi(); surfaceScalarField& alphaRhoPhi2 = phase2.alphaRhoPhi();
surfaceScalarField& phi = fluid.phi(); surfaceScalarField& phi = fluid.phi();
dimensionedScalar pMin dimensionedScalar pMin
(
"pMin",
dimPressure,
fluid.lookup("pMin")
);
#include "gh.H"
rhoThermo& thermo1 = phase1.thermo();
rhoThermo& thermo2 = phase2.thermo();
volScalarField& p = thermo1.p();
volScalarField& rho1 = thermo1.rho();
const volScalarField& psi1 = thermo1.psi();
volScalarField& rho2 = thermo2.rho();
const volScalarField& psi2 = thermo2.psi();
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
( (
"pMin", "p_rgh",
dimPressure, runTime.timeName(),
fluid.lookup("pMin")
);
#include "gh.H"
rhoThermo& thermo1 = phase1.thermo();
rhoThermo& thermo2 = phase2.thermo();
volScalarField& p = thermo1.p();
volScalarField& rho1 = thermo1.rho();
const volScalarField& psi1 = thermo1.psi();
volScalarField& rho2 = thermo2.rho();
const volScalarField& psi2 = thermo2.psi();
Info<< "Reading field p_rgh\n" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
);
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
fluid.U()
);
label pRefCell = 0;
scalar pRefValue = 0.0;
setRefCell
(
p,
p_rgh,
pimple.dict(),
pRefCell,
pRefValue
);
Info<< "Creating field dpdt\n" << endl;
volScalarField dpdt
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh, mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0) IOobject::MUST_READ,
); IOobject::AUTO_WRITE
),
mesh
);
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
fluid.U()
);
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
(
IOobject
(
"dpdt",
runTime.timeName(),
mesh
),
mesh,
dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
);
Info<< "Creating field kinetic energy K\n" << endl; Info<< "Creating field kinetic energy K\n" << endl;
volScalarField K1(IOobject::groupName("K", phase1.name()), 0.5*magSqr(U1)); volScalarField K1(IOobject::groupName("K", phase1.name()), 0.5*magSqr(U1));
volScalarField K2(IOobject::groupName("K", phase2.name()), 0.5*magSqr(U2)); 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)"); 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); fvc::makeAbsolute(phi, U);
} }
mesh.setFluxRequired(pcorr.name());
while (pimple.correctNonOrthogonal()) while (pimple.correctNonOrthogonal())
{ {
// Solve for pcorr such that the divergence of the corrected flux // Solve for pcorr such that the divergence of the corrected flux
@ -156,6 +158,8 @@ void Foam::CorrectPhi
pcorrTypes pcorrTypes
); );
mesh.setFluxRequired(pcorr.name());
while (pimple.correctNonOrthogonal()) while (pimple.correctNonOrthogonal())
{ {
// Solve for pcorr such that the divergence of the corrected flux // 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) if (debug)
{ {

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

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

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

@ -29,7 +29,7 @@ License
#include "fvmDiv.H" #include "fvmDiv.H"
#include "fvmLaplacian.H" #include "fvmLaplacian.H"
#include "fvcReconstruct.H" #include "fvcReconstruct.H"
#include "volPointInterpolation.H" #include "volPointInterpolation.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -89,7 +89,7 @@ void Foam::PackingModels::Implicit<CloudType>::cacheFields(const bool store)
PackingModel<CloudType>::cacheFields(store); PackingModel<CloudType>::cacheFields(store);
if (store) if (store)
{ {
const fvMesh& mesh = this->owner().mesh(); const fvMesh& mesh = this->owner().mesh();
const dimensionedScalar deltaT = this->owner().db().time().deltaT(); const dimensionedScalar deltaT = this->owner().db().time().deltaT();
const word& cloudName = this->owner().name(); const word& cloudName = this->owner().name();
@ -108,6 +108,7 @@ void Foam::PackingModels::Implicit<CloudType>::cacheFields(const bool store)
cloudName + ":uSqrAverage" cloudName + ":uSqrAverage"
); );
mesh.setFluxRequired(alpha_.name());
// Property fields // Property fields
// ~~~~~~~~~~~~~~~ // ~~~~~~~~~~~~~~~
@ -140,7 +141,7 @@ void Foam::PackingModels::Implicit<CloudType>::cacheFields(const bool store)
//Info << " rho: " << rho.internalField() << endl; //Info << " rho: " << rho.internalField() << endl;
//Info << endl; //Info << endl;
// Stress field // Stress field
// ~~~~~~~~~~~~ // ~~~~~~~~~~~~

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

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

2
tutorials/Alltest
View File

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

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

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

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

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

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

@ -47,11 +47,5 @@ snGradSchemes
default corrected; 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; 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; default corrected;
} }
fluxRequired
{
default no;
p ;
}
// ************************************************************************* // // ************************************************************************* //

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

@ -29,8 +29,4 @@ divSchemes
laplacianSchemes 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 laplacianSchemes
{} {}
fluxRequired
{}
// ************************************************************************* // // ************************************************************************* //

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

@ -71,11 +71,5 @@ snGradSchemes
default limited corrected 0.5; 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; default uncorrected;
} }
fluxRequired
{
default no;
deltaf;
}
// ************************************************************************* // // ************************************************************************* //

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

@ -64,11 +64,5 @@ snGradSchemes
default corrected; 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; default uncorrected;
} }
fluxRequired
{
default no;
}
// ************************************************************************* // // ************************************************************************* //

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

@ -59,12 +59,4 @@ snGradSchemes
default corrected; 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; default corrected;
} }
fluxRequired
{
default no;
}
// ************************************************************************* // // ************************************************************************* //

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -51,11 +51,5 @@ snGradSchemes
default corrected; 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; 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; default corrected;
} }
fluxRequired
{
default no;
p_rgh;
}
// ************************************************************************* // // ************************************************************************* //

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

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

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

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

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

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

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

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

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

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

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

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

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