266 lines
12 KiB
C
266 lines
12 KiB
C
// Calculate third order dissipative term as outlined by Demirdzic
|
|
// This removes unphysical high frequency oscillations that may
|
|
// appear in the solution. This term goes to zero on convergence
|
|
// assuming a linear/quadratic displacement field, or the error
|
|
// is second order
|
|
|
|
// volVectorField divThirdOrderTerm
|
|
// (
|
|
// IOobject
|
|
// (
|
|
// "divThirdOrderTerm",
|
|
// runTime.timeName(),
|
|
// mesh,
|
|
// IOobject::NO_READ,
|
|
// IOobject::NO_WRITE
|
|
// ),
|
|
// mesh,
|
|
// dimensionedVector("zero", dimForce/dimVolume, vector::zero)
|
|
// );
|
|
|
|
// average gradU of neighbouring cell centres
|
|
// interpolation scheme should be midPoint
|
|
surfaceTensorField averageGradU("averageGradU", fvc::interpolate(gradU, "averageGradU"));
|
|
|
|
// average face gradU extrapolated from neighbouring cell centres
|
|
surfaceTensorField extrapGradU
|
|
(
|
|
IOobject
|
|
(
|
|
"extrapGradU",
|
|
runTime.timeName(),
|
|
mesh,
|
|
IOobject::NO_READ,
|
|
IOobject::NO_WRITE
|
|
),
|
|
mesh,
|
|
dimensionedTensor("zero", dimless, tensor::zero)
|
|
);
|
|
|
|
volVectorField gradGradUcompXX = fvc::grad(gradU.component(tensor::XX), "gradGradU");
|
|
volVectorField gradGradUcompXY = fvc::grad(gradU.component(tensor::XY), "gradGradU");
|
|
volVectorField gradGradUcompXZ = fvc::grad(gradU.component(tensor::XZ), "gradGradU");
|
|
volVectorField gradGradUcompYX = fvc::grad(gradU.component(tensor::YX), "gradGradU");
|
|
volVectorField gradGradUcompYY = fvc::grad(gradU.component(tensor::YY), "gradGradU");
|
|
volVectorField gradGradUcompYZ = fvc::grad(gradU.component(tensor::YZ), "gradGradU");
|
|
volVectorField gradGradUcompZX = fvc::grad(gradU.component(tensor::ZX), "gradGradU");
|
|
volVectorField gradGradUcompZY = fvc::grad(gradU.component(tensor::ZY), "gradGradU");
|
|
volVectorField gradGradUcompZZ = fvc::grad(gradU.component(tensor::ZZ), "gradGradU");
|
|
|
|
// third order tensor components
|
|
volScalarField gradGradUXXX = gradGradUcompXX.component(vector::X);
|
|
volScalarField gradGradUXXY = gradGradUcompXY.component(vector::X);
|
|
volScalarField gradGradUXXZ = gradGradUcompXZ.component(vector::X);
|
|
|
|
volScalarField gradGradUXYX = gradGradUcompYX.component(vector::X);
|
|
volScalarField gradGradUXYY = gradGradUcompYY.component(vector::X);
|
|
volScalarField gradGradUXYZ = gradGradUcompYZ.component(vector::X);
|
|
|
|
volScalarField gradGradUXZX = gradGradUcompZX.component(vector::X);
|
|
volScalarField gradGradUXZY = gradGradUcompZY.component(vector::X);
|
|
volScalarField gradGradUXZZ = gradGradUcompZZ.component(vector::X);
|
|
|
|
volScalarField gradGradUYXX = gradGradUcompXX.component(vector::Y);
|
|
volScalarField gradGradUYXY = gradGradUcompXY.component(vector::Y);
|
|
volScalarField gradGradUYXZ = gradGradUcompXZ.component(vector::Y);
|
|
|
|
volScalarField gradGradUYYX = gradGradUcompYX.component(vector::Y);
|
|
volScalarField gradGradUYYY = gradGradUcompYY.component(vector::Y);
|
|
volScalarField gradGradUYYZ = gradGradUcompYZ.component(vector::Y);
|
|
|
|
volScalarField gradGradUYZX = gradGradUcompZX.component(vector::Y);
|
|
volScalarField gradGradUYZY = gradGradUcompZY.component(vector::Y);
|
|
volScalarField gradGradUYZZ = gradGradUcompZZ.component(vector::Y);
|
|
|
|
volScalarField gradGradUZXX = gradGradUcompXX.component(vector::Z);
|
|
volScalarField gradGradUZXY = gradGradUcompXY.component(vector::Z);
|
|
volScalarField gradGradUZXZ = gradGradUcompXZ.component(vector::Z);
|
|
|
|
volScalarField gradGradUZYX = gradGradUcompYX.component(vector::Z);
|
|
volScalarField gradGradUZYY = gradGradUcompYY.component(vector::Z);
|
|
volScalarField gradGradUZYZ = gradGradUcompYZ.component(vector::Z);
|
|
|
|
volScalarField gradGradUZZX = gradGradUcompZX.component(vector::Z);
|
|
volScalarField gradGradUZZY = gradGradUcompZY.component(vector::Z);
|
|
volScalarField gradGradUZZZ = gradGradUcompZZ.component(vector::Z);
|
|
|
|
forAll(extrapGradU.internalField(), facei)
|
|
{
|
|
const label own = mesh.owner()[facei];
|
|
const label nei = mesh.neighbour()[facei];
|
|
const vector deltaOwn = mesh.Cf()[facei] - mesh.C()[own];
|
|
const vector deltaNei = mesh.Cf()[facei] - mesh.C()[nei];
|
|
const tensor& gradUOwn = gradU.internalField()[own];
|
|
const tensor& gradUNei = gradU.internalField()[nei];
|
|
|
|
// as there is there is no thirdOrderTensor class, we will
|
|
// calculate (deltaOwn&gradGradUOwn) out manually
|
|
// tensor deltaOwnDotgradGradUOwn = tensor::zero;
|
|
// tensor deltaNeiDotgradGradUNei = tensor::zero;
|
|
|
|
// deltaOwnDotgradGradUOwn[tensor::XX] = deltaOwn & gradGradUcompXX.internalField()[own];
|
|
// deltaNeiDotgradGradUNei[tensor::XX] = deltaNei & gradGradUcompXX.internalField()[nei];
|
|
// deltaOwnDotgradGradUOwn[tensor::XY] = deltaOwn & gradGradUcompXY.internalField()[own];
|
|
// deltaNeiDotgradGradUNei[tensor::XY] = deltaNei & gradGradUcompXY.internalField()[nei];
|
|
// deltaOwnDotgradGradUOwn[tensor::XZ] = deltaOwn & gradGradUcompXZ.internalField()[own];
|
|
// deltaNeiDotgradGradUNei[tensor::XZ] = deltaNei & gradGradUcompXZ.internalField()[nei];
|
|
|
|
// deltaOwnDotgradGradUOwn[tensor::YX] = deltaOwn & gradGradUcompYX.internalField()[own];
|
|
// deltaNeiDotgradGradUNei[tensor::YX] = deltaNei & gradGradUcompYX.internalField()[nei];
|
|
// deltaOwnDotgradGradUOwn[tensor::YY] = deltaOwn & gradGradUcompYY.internalField()[own];
|
|
// deltaNeiDotgradGradUNei[tensor::YY] = deltaNei & gradGradUcompYY.internalField()[nei];
|
|
// deltaOwnDotgradGradUOwn[tensor::YZ] = deltaOwn & gradGradUcompYZ.internalField()[own];
|
|
// deltaNeiDotgradGradUNei[tensor::YZ] = deltaNei & gradGradUcompYZ.internalField()[nei];
|
|
|
|
// deltaOwnDotgradGradUOwn[tensor::ZX] = deltaOwn & gradGradUcompZX.internalField()[own];
|
|
// deltaNeiDotgradGradUNei[tensor::ZX] = deltaNei & gradGradUcompZX.internalField()[nei];
|
|
// deltaOwnDotgradGradUOwn[tensor::ZY] = deltaOwn & gradGradUcompZY.internalField()[own];
|
|
// deltaNeiDotgradGradUNei[tensor::ZY] = deltaNei & gradGradUcompZY.internalField()[nei];
|
|
// deltaOwnDotgradGradUOwn[tensor::ZZ] = deltaOwn & gradGradUcompZZ.internalField()[own];
|
|
// deltaNeiDotgradGradUNei[tensor::ZZ] = deltaNei & gradGradUcompZZ.internalField()[nei];
|
|
|
|
scalar gradGradUXXXOwn = gradGradUXXX.internalField()[own];
|
|
scalar gradGradUXXYOwn = gradGradUXXY.internalField()[own];
|
|
scalar gradGradUXXZOwn = gradGradUXXZ.internalField()[own];
|
|
|
|
scalar gradGradUXYXOwn = gradGradUXYX.internalField()[own];
|
|
scalar gradGradUXYYOwn = gradGradUXYY.internalField()[own];
|
|
scalar gradGradUXYZOwn = gradGradUXYZ.internalField()[own];
|
|
|
|
scalar gradGradUXZXOwn = gradGradUXZX.internalField()[own];
|
|
scalar gradGradUXZYOwn = gradGradUXZY.internalField()[own];
|
|
scalar gradGradUXZZOwn = gradGradUXZZ.internalField()[own];
|
|
|
|
|
|
scalar gradGradUYXXOwn = gradGradUYXX.internalField()[own];
|
|
scalar gradGradUYXYOwn = gradGradUYXY.internalField()[own];
|
|
scalar gradGradUYXZOwn = gradGradUYXZ.internalField()[own];
|
|
|
|
scalar gradGradUYYXOwn = gradGradUYYX.internalField()[own];
|
|
scalar gradGradUYYYOwn = gradGradUYYY.internalField()[own];
|
|
scalar gradGradUYYZOwn = gradGradUYYZ.internalField()[own];
|
|
|
|
scalar gradGradUYZXOwn = gradGradUYZX.internalField()[own];
|
|
scalar gradGradUYZYOwn = gradGradUYZY.internalField()[own];
|
|
scalar gradGradUYZZOwn = gradGradUYZZ.internalField()[own];
|
|
|
|
|
|
scalar gradGradUZXXOwn = gradGradUZXX.internalField()[own];
|
|
scalar gradGradUZXYOwn = gradGradUZXY.internalField()[own];
|
|
scalar gradGradUZXZOwn = gradGradUZXZ.internalField()[own];
|
|
|
|
scalar gradGradUZYXOwn = gradGradUZYX.internalField()[own];
|
|
scalar gradGradUZYYOwn = gradGradUZYY.internalField()[own];
|
|
scalar gradGradUZYZOwn = gradGradUZYZ.internalField()[own];
|
|
|
|
scalar gradGradUZZXOwn = gradGradUZZX.internalField()[own];
|
|
scalar gradGradUZZYOwn = gradGradUZZY.internalField()[own];
|
|
scalar gradGradUZZZOwn = gradGradUZZZ.internalField()[own];
|
|
|
|
|
|
// nei
|
|
scalar gradGradUXXXNei = gradGradUXXX.internalField()[nei];
|
|
scalar gradGradUXXYNei = gradGradUXXY.internalField()[nei];
|
|
scalar gradGradUXXZNei = gradGradUXXZ.internalField()[nei];
|
|
|
|
scalar gradGradUXYXNei = gradGradUXYX.internalField()[nei];
|
|
scalar gradGradUXYYNei = gradGradUXYY.internalField()[nei];
|
|
scalar gradGradUXYZNei = gradGradUXYZ.internalField()[nei];
|
|
|
|
scalar gradGradUXZXNei = gradGradUXZX.internalField()[nei];
|
|
scalar gradGradUXZYNei = gradGradUXZY.internalField()[nei];
|
|
scalar gradGradUXZZNei = gradGradUXZZ.internalField()[nei];
|
|
|
|
|
|
scalar gradGradUYXXNei = gradGradUYXX.internalField()[nei];
|
|
scalar gradGradUYXYNei = gradGradUYXY.internalField()[nei];
|
|
scalar gradGradUYXZNei = gradGradUYXZ.internalField()[nei];
|
|
|
|
scalar gradGradUYYXNei = gradGradUYYX.internalField()[nei];
|
|
scalar gradGradUYYYNei = gradGradUYYY.internalField()[nei];
|
|
scalar gradGradUYYZNei = gradGradUYYZ.internalField()[nei];
|
|
|
|
scalar gradGradUYZXNei = gradGradUYZX.internalField()[nei];
|
|
scalar gradGradUYZYNei = gradGradUYZY.internalField()[nei];
|
|
scalar gradGradUYZZNei = gradGradUYZZ.internalField()[nei];
|
|
|
|
|
|
scalar gradGradUZXXNei = gradGradUZXX.internalField()[nei];
|
|
scalar gradGradUZXYNei = gradGradUZXY.internalField()[nei];
|
|
scalar gradGradUZXZNei = gradGradUZXZ.internalField()[nei];
|
|
|
|
scalar gradGradUZYXNei = gradGradUZYX.internalField()[nei];
|
|
scalar gradGradUZYYNei = gradGradUZYY.internalField()[nei];
|
|
scalar gradGradUZYZNei = gradGradUZYZ.internalField()[nei];
|
|
|
|
scalar gradGradUZZXNei = gradGradUZZX.internalField()[nei];
|
|
scalar gradGradUZZYNei = gradGradUZZY.internalField()[nei];
|
|
scalar gradGradUZZZNei = gradGradUZZZ.internalField()[nei];
|
|
|
|
tensor deltaOwnDotgradGradUOwn =tensor
|
|
(
|
|
deltaOwn.x()*gradGradUXXXOwn + deltaOwn.y()*gradGradUYXXOwn + deltaOwn.z()*gradGradUZXXOwn,
|
|
deltaOwn.x()*gradGradUXXYOwn + deltaOwn.y()*gradGradUYXYOwn + deltaOwn.z()*gradGradUZXYOwn,
|
|
deltaOwn.x()*gradGradUXXZOwn + deltaOwn.y()*gradGradUYXZOwn + deltaOwn.z()*gradGradUZXZOwn,
|
|
|
|
deltaOwn.x()*gradGradUXYXOwn + deltaOwn.y()*gradGradUYYXOwn + deltaOwn.z()*gradGradUZYXOwn,
|
|
deltaOwn.x()*gradGradUXYYOwn + deltaOwn.y()*gradGradUYYYOwn + deltaOwn.z()*gradGradUZYYOwn,
|
|
deltaOwn.x()*gradGradUXYZOwn + deltaOwn.y()*gradGradUYYZOwn + deltaOwn.z()*gradGradUZYZOwn,
|
|
|
|
deltaOwn.x()*gradGradUXZXOwn + deltaOwn.y()*gradGradUYZXOwn + deltaOwn.z()*gradGradUZZXOwn,
|
|
deltaOwn.x()*gradGradUXZYOwn + deltaOwn.y()*gradGradUYZYOwn + deltaOwn.z()*gradGradUZZYOwn,
|
|
deltaOwn.x()*gradGradUXZZOwn + deltaOwn.y()*gradGradUYZZOwn + deltaOwn.z()*gradGradUZZZOwn
|
|
);
|
|
|
|
tensor deltaNeiDotgradGradUNei = tensor
|
|
(
|
|
deltaNei.x()*gradGradUXXXNei + deltaNei.y()*gradGradUYXXNei + deltaNei.z()*gradGradUZXXNei,
|
|
deltaNei.x()*gradGradUXXYNei + deltaNei.y()*gradGradUYXYNei + deltaNei.z()*gradGradUZXYNei,
|
|
deltaNei.x()*gradGradUXXZNei + deltaNei.y()*gradGradUYXZNei + deltaNei.z()*gradGradUZXZNei,
|
|
|
|
deltaNei.x()*gradGradUXYXNei + deltaNei.y()*gradGradUYYXNei + deltaNei.z()*gradGradUZYXNei,
|
|
deltaNei.x()*gradGradUXYYNei + deltaNei.y()*gradGradUYYYNei + deltaNei.z()*gradGradUZYYNei,
|
|
deltaNei.x()*gradGradUXYZNei + deltaNei.y()*gradGradUYYZNei + deltaNei.z()*gradGradUZYZNei,
|
|
|
|
deltaNei.x()*gradGradUXZXNei + deltaNei.y()*gradGradUYZXNei + deltaNei.z()*gradGradUZZXNei,
|
|
deltaNei.x()*gradGradUXZYNei + deltaNei.y()*gradGradUYZYNei + deltaNei.z()*gradGradUZZYNei,
|
|
deltaNei.x()*gradGradUXZZNei + deltaNei.y()*gradGradUYZZNei + deltaNei.z()*gradGradUZZZNei
|
|
);
|
|
|
|
|
|
// get average of extrapolated values
|
|
tensor extrapFaceGrad =
|
|
0.5*
|
|
(
|
|
gradUOwn + (deltaOwnDotgradGradUOwn)
|
|
+
|
|
gradUNei + (deltaNeiDotgradGradUNei)
|
|
);
|
|
|
|
extrapGradU.internalField()[facei] = extrapFaceGrad;
|
|
|
|
}
|
|
|
|
// correction is zero on boundary
|
|
forAll(extrapGradU.boundaryField(), patchi)
|
|
{
|
|
extrapGradU.boundaryField()[patchi] =
|
|
averageGradU.boundaryField()[patchi];
|
|
}
|
|
|
|
// calculate thirdOrderTerm
|
|
volVectorField divThirdOrderTerm
|
|
(
|
|
"thirdOrderTerm",
|
|
fvc::div
|
|
(
|
|
(2*muf+lambdaf)*mesh.Sf() & (extrapGradU - averageGradU)
|
|
)
|
|
);
|
|
|
|
// if(runTime.outputTime())
|
|
// {
|
|
// divThirdOrderTerm.write();
|
|
// averageGradU.write();
|
|
// extrapGradU.write();
|
|
// }
|