Foam::anisotropicFilter::anisotropicFilter
(
const fvMesh& mesh,
const dictionary& bd
)
:
LESfilter(mesh),
widthCoeff_(readScalar(bd.subDict(type() + "Coeffs").lookup("widthCoeff"))),
coeff_
(
IOobject
(
"anisotropicFilterCoeff",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedVector("zero", dimLength*dimLength, Zero),
calculatedFvPatchScalarField::typeName
)
{
for (direction d=0; d<vector::nComponents; d++)
{
coeff_.internalField().replace
(
d,
(1/widthCoeff_)*
sqr
(
2.0*mesh.V()
/fvc::surfaceSum(mag(mesh.Sf().component(d)))().internalField()
)
);
}
}
Foam::anisotropicFilter::anisotropicFilter
(
const fvMesh& mesh,
scalar widthCoeff
)
:
LESfilter(mesh),
widthCoeff_(widthCoeff),
coeff_
(
IOobject
(
"anisotropicFilterCoeff",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedVector("zero", dimLength*dimLength, vector::zero),
calculatedFvPatchVectorField::typeName
)
{
for (direction d=0; d<vector::nComponents; d++)
{
coeff_.internalField().replace
(
d,
(2.0/widthCoeff_)*mesh.V()
/fvc::surfaceSum(mag(mesh.Sf().component(d)))().internalField()
);
}
}
void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
{
Info<< "Reading velocity field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
Info<< "Reading/calculating face flux field phi\n" << endl;
surfaceScalarField phi
(
IOobject
(
"phi",
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE
),
linearInterpolate(U) & mesh.Sf()
);
Info<< "Creating LES filter width field LESdelta\n" << endl;
volScalarField LESdelta
(
IOobject
(
"LESdelta",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensionedScalar("LESdelta", dimLength, SMALL)
);
singlePhaseTransportModel laminarTransport(U, phi);
autoPtr<incompressible::LESModel> sgsModel
(
incompressible::LESModel::New(U, phi, laminarTransport)
);
LESdelta.internalField() = sgsModel->delta();
LESdelta.write();
Info<< "End" << endl;
}
void Foam::quadraticFitSnGradData::findFaceDirs
(
vector& idir, // value changed in return
vector& jdir, // value changed in return
vector& kdir, // value changed in return
const fvMesh& mesh,
const label faci
)
{
idir = mesh.Sf()[faci];
idir /= mag(idir);
#ifndef SPHERICAL_GEOMETRY
if (mesh.nGeometricD() <= 2) // find the normal direcion
{
if (mesh.geometricD()[0] == -1)
{
kdir = vector(1, 0, 0);
}
else if (mesh.geometricD()[1] == -1)
{
kdir = vector(0, 1, 0);
}
else
{
kdir = vector(0, 0, 1);
}
}
else // 3D so find a direction in the plane of the face
{
const face& f = mesh.faces()[faci];
kdir = mesh.points()[f[0]] - mesh.points()[f[1]];
}
#else
// Spherical geometry so kdir is the radial direction
kdir = mesh.Cf()[faci];
#endif
if (mesh.nGeometricD() == 3)
{
// Remove the idir component from kdir and normalise
kdir -= (idir & kdir)*idir;
scalar magk = mag(kdir);
if (magk < SMALL)
{
FatalErrorIn("findFaceDirs") << " calculated kdir = zero"
<< exit(FatalError);
}
else
{
kdir /= magk;
}
}
jdir = kdir ^ idir;
}
void printIntegrate
(
const fvMesh& mesh,
const IOobject& fieldHeader,
const label patchI,
bool& done
)
{
if (!done && fieldHeader.headerClassName() == FieldType::typeName)
{
Info<< " Reading " << fieldHeader.headerClassName() << " "
<< fieldHeader.name() << endl;
FieldType field(fieldHeader, mesh);
Info<< " Integral of " << fieldHeader.name()
<< " over vector area of patch "
<< mesh.boundary()[patchI].name() << '[' << patchI << ']' << " = "
<< gSum
(
mesh.Sf().boundaryField()[patchI]
*field.boundaryField()[patchI]
)
<< nl;
Info<< " Integral of " << fieldHeader.name()
<< " over area magnitude of patch "
<< mesh.boundary()[patchI].name() << '[' << patchI << ']' << " = "
<< gSum
(
mesh.magSf().boundaryField()[patchI]
*field.boundaryField()[patchI]
)
<< nl;
done = true;
}
}
Foam::phaseModel::phaseModel
(
const fvMesh& mesh,
const dictionary& transportProperties,
const word& phaseName
)
:
dict_
(
transportProperties.subDict("phase" + phaseName)
),
name_(phaseName),
d_
(
dict_.lookup("d")
),
nu_
(
dict_.lookup("nu")
),
rho_
(
dict_.lookup("rho")
),
U_
(
IOobject
(
"U" + phaseName,
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
)
{
const word phiName = "phi" + phaseName;
IOobject phiHeader
(
phiName,
mesh.time().timeName(),
mesh,
IOobject::NO_READ
);
if (phiHeader.headerOk())
{
Info<< "Reading face flux field " << phiName << endl;
phiPtr_.reset
(
new surfaceScalarField
(
IOobject
(
phiName,
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
)
);
}
else
{
Info<< "Calculating face flux field " << phiName << endl;
wordList phiTypes
(
U_.boundaryField().size(),
calculatedFvPatchScalarField::typeName
);
for (label i=0; i<U_.boundaryField().size(); i++)
{
if (isType<fixedValueFvPatchVectorField>(U_.boundaryField()[i]))
{
phiTypes[i] = fixedValueFvPatchScalarField::typeName;
}
}
phiPtr_.reset
(
new surfaceScalarField
(
IOobject
(
phiName,
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
fvc::interpolate(U_) & mesh.Sf(),
phiTypes
)
);
}
}
Foam::incompressiblePhase::incompressiblePhase
(
const fvMesh& mesh,
const dictionary& transportProperties,
const word& phaseName
)
:
name_(phaseName),
dict_(transportProperties.subDict("phase" + phaseName)),
mu_(dict_.lookup("mu")),
rho_(dict_.lookup("rho")),
U_
(
IOobject
(
"U" + phaseName,
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
)
{
const word phiName = "phi" + phaseName;
IOobject phiHeader
(
phiName,
mesh.time().timeName(),
mesh,
IOobject::NO_READ
);
if (phiHeader.headerOk())
{
phiPtr_.reset
(
new surfaceScalarField
(
IOobject
(
phiName,
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
)
);
}
else
{
wordList phiTypes
(
U_.boundaryField().size(),
calculatedFvPatchScalarField::typeName
);
for (label i=0; i<U_.boundaryField().size(); i++)
{
if (isA<fixedValueFvPatchVectorField>(U_.boundaryField()[i]))
{
phiTypes[i] = fixedValueFvPatchScalarField::typeName;
}
}
phiPtr_.reset
(
new surfaceScalarField
(
IOobject
(
phiName,
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
Foam::linearInterpolate(U_) & mesh.Sf(),
phiTypes
)
);
}
}
