int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "createFields.H"
#include "initContinuityErrs.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< nl << "Starting time loop" << endl;
while (runTime.loop())
{
#include "readPISOControls.H"
#include "readBPISOControls.H"
Info<< "Time = " << runTime.timeName() << nl << endl;
#include "CourantNo.H"
{
fvVectorMatrix UEqn
(
fvm::ddt(U)
+ fvm::div(phi, U)
- fvc::div(phiB, 2.0*DBU*B)
- fvm::laplacian(nu, U)
+ fvc::grad(DBU*magSqr(B))
);
solve(UEqn == -fvc::grad(p));
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
volScalarField rUA = 1.0/UEqn.A();
U = rUA*UEqn.H();
phi = (fvc::interpolate(U) & mesh.Sf())
+ fvc::ddtPhiCorr(rUA, U, phi);
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrix pEqn
(
fvm::laplacian(rUA, p) == fvc::div(phi)
);
pEqn.setReference(pRefCell, pRefValue);
pEqn.solve();
if (nonOrth == nNonOrthCorr)
{
phi -= pEqn.flux();
}
}
#include "continuityErrs.H"
U -= rUA*fvc::grad(p);
U.correctBoundaryConditions();
}
}
// --- B-PISO loop
for (int Bcorr=0; Bcorr<nBcorr; Bcorr++)
{
fvVectorMatrix BEqn
(
fvm::ddt(B)
+ fvm::div(phi, B)
- fvc::div(phiB, U)
- fvm::laplacian(DB, B)
);
BEqn.solve();
volScalarField rBA = 1.0/BEqn.A();
phiB = (fvc::interpolate(B) & mesh.Sf())
+ fvc::ddtPhiCorr(rBA, B, phiB);
fvScalarMatrix pBEqn
(
fvm::laplacian(rBA, pB) == fvc::div(phiB)
);
pBEqn.solve();
phiB -= pBEqn.flux();
#include "magneticFieldErr.H"
}
runTime.write();
}
Info<< "End\n" << endl;
return 0;
}
void realizableKE_Veh::correct()
{
RASModel::correct();
if (!turbulence_)
{
return;
}
const volTensorField gradU(fvc::grad(U_));
const volScalarField S2(2*magSqr(dev(symm(gradU))));
const volScalarField magS(sqrt(S2));
const volScalarField eta(magS*k_/epsilon_);
tmp<volScalarField> C1 = max(eta/(scalar(5) + eta), scalar(0.43));
volScalarField G("RASModel::G", nut_*S2);
//Estimating source terms for vehicle canopy
volVectorField Fi = 0.5*Cfcar_*VAD_*mag(U_-Ucar_)*(U_-Ucar_);
volScalarField Fk = (U_-Ucar_)&Fi;
volScalarField Fepsilon = epsilon_*sqrt(k_)*Cecar_/L_;
// Update epsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::Sp(fvc::div(phi_), epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
Fepsilon
+ C1*magS*epsilon_
- fvm::Sp
(
C2_*epsilon_/(k_ + sqrt(nu()*epsilon_)),
epsilon_
)
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, epsilonMin_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi_, k_)
- fvm::Sp(fvc::div(phi_), k_)
- fvm::laplacian(DkEff(), k_)
==
Fk
+ G - fvm::Sp(epsilon_/k_, k_)
);
kEqn().relax();
solve(kEqn);
bound(k_, kMin_);
// Re-calculate viscosity
nut_ = rCmu(gradU, S2, magS)*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
}
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
# include "readThermodynamicProperties.H"
# include "createFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
surfaceScalarField phiv
(
IOobject
(
"phiv",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
fvc::interpolate(rhoU)/fvc::interpolate(rho) & mesh.Sf()
);
scalar CoNum = max
(
mesh.surfaceInterpolation::deltaCoeffs()
*mag(phiv)/mesh.magSf()
).value()*runTime.deltaT().value();
Info<< "\nMax Courant Number = " << CoNum << endl;
solve
(
fvm::ddt(rho)
+ fvm::div(phiv, rho)
);
p = rho/psi;
solve
(
fvm::ddt(rhoU)
+ fvm::div(phiv, rhoU)
==
- fvc::grad(p)
);
U == rhoU/rho;
surfaceScalarField phiv2
(
IOobject
(
"phiv2",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
fvc::interpolate(rhoU)/fvc::interpolate(rho) & mesh.Sf()
);
solve
(
fvm::ddt(rhoE)
+ fvm::div(phiv, rhoE)
==
- fvc::div(phiv2, p)
);
T = (rhoE - 0.5*rho*magSqr(rhoU/rho))/Cv/rho;
psi = 1.0/(R*T);
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
void Foam::JohnsonJacksonParticleThetaFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
// lookup the fluid model and the phase
const twoPhaseSystem& fluid = db().lookupObject<twoPhaseSystem>
(
"phaseProperties"
);
const phaseModel& phased
(
fluid.phase1().name() == internalField().group()
? fluid.phase1()
: fluid.phase2()
);
// lookup all the fields on this patch
const fvPatchScalarField& alpha
(
patch().lookupPatchField<volScalarField, scalar>
(
phased.volScalarField::name()
)
);
const fvPatchVectorField& U
(
patch().lookupPatchField<volVectorField, vector>
(
IOobject::groupName("U", phased.name())
)
);
const fvPatchScalarField& gs0
(
patch().lookupPatchField<volScalarField, scalar>
(
IOobject::groupName("gs0", phased.name())
)
);
const fvPatchScalarField& kappa
(
patch().lookupPatchField<volScalarField, scalar>
(
IOobject::groupName("kappa", phased.name())
)
);
const scalarField Theta(patchInternalField());
// lookup the packed volume fraction
dimensionedScalar alphaMax
(
"alphaMax",
dimless,
db()
.lookupObject<IOdictionary>
(
IOobject::groupName("turbulenceProperties", phased.name())
)
.subDict("RAS")
.subDict("kineticTheoryCoeffs")
.lookup("alphaMax")
);
// calculate the reference value and the value fraction
if (restitutionCoefficient_.value() != 1.0)
{
this->refValue() =
(2.0/3.0)
*specularityCoefficient_.value()
*magSqr(U)
/(scalar(1) - sqr(restitutionCoefficient_.value()));
this->refGrad() = 0.0;
scalarField c
(
constant::mathematical::pi
*alpha
*gs0
*(scalar(1) - sqr(restitutionCoefficient_.value()))
*sqrt(3*Theta)
/max(4*kappa*alphaMax.value(), small)
);
this->valueFraction() = c/(c + patch().deltaCoeffs());
}
// for a restitution coefficient of 1, the boundary degenerates to a fixed
// gradient condition
else
{
this->refValue() = 0.0;
this->refGrad() =
pos0(alpha - small)
*constant::mathematical::pi
*specularityCoefficient_.value()
*alpha
*gs0
*sqrt(3*Theta)
*magSqr(U)
/max(6*kappa*alphaMax.value(), small);
this->valueFraction() = 0;
}
mixedFvPatchScalarField::updateCoeffs();
}
void Foam::mapNearestMethod::calculateAddressing
(
labelListList& srcToTgtCellAddr,
scalarListList& srcToTgtCellWght,
labelListList& tgtToSrcCellAddr,
scalarListList& tgtToSrcCellWght,
const label srcSeedI,
const label tgtSeedI,
const labelList& srcCellIDs,
boolList& mapFlag,
label& startSeedI
)
{
List<DynamicList<label> > srcToTgt(src_.nCells());
List<DynamicList<label> > tgtToSrc(tgt_.nCells());
const scalarField& srcVc = src_.cellVolumes();
const scalarField& tgtVc = tgt_.cellVolumes();
{
label srcCellI = srcSeedI;
label tgtCellI = tgtSeedI;
do
{
// find nearest tgt cell
findNearestCell(src_, tgt_, srcCellI, tgtCellI);
// store src/tgt cell pair
srcToTgt[srcCellI].append(tgtCellI);
tgtToSrc[tgtCellI].append(srcCellI);
// mark source cell srcCellI and tgtCellI as matched
mapFlag[srcCellI] = false;
// accumulate intersection volume
V_ += srcVc[srcCellI];
// find new source cell
setNextNearestCells
(
startSeedI,
srcCellI,
tgtCellI,
mapFlag,
srcCellIDs
);
}
while (srcCellI >= 0);
}
// for the case of multiple source cells per target cell, select the
// nearest source cell only and discard the others
const vectorField& srcCc = src_.cellCentres();
const vectorField& tgtCc = tgt_.cellCentres();
forAll(tgtToSrc, targetCellI)
{
if (tgtToSrc[targetCellI].size() > 1)
{
const vector& tgtC = tgtCc[targetCellI];
DynamicList<label>& srcCells = tgtToSrc[targetCellI];
label srcCellI = srcCells[0];
scalar d = magSqr(tgtC - srcCc[srcCellI]);
for (label i = 1; i < srcCells.size(); i++)
{
label srcI = srcCells[i];
scalar dNew = magSqr(tgtC - srcCc[srcI]);
if (dNew < d)
{
d = dNew;
srcCellI = srcI;
}
}
srcCells.clear();
srcCells.append(srcCellI);
}
}
// If there are more target cells than source cells, some target cells
// might not yet be mapped
forAll(tgtToSrc, tgtCellI)
{
if (tgtToSrc[tgtCellI].empty())
{
label srcCellI = findMappedSrcCell(tgtCellI, tgtToSrc);
findNearestCell(tgt_, src_, tgtCellI, srcCellI);
tgtToSrc[tgtCellI].append(srcCellI);
}
}
// transfer addressing into persistent storage
forAll(srcToTgtCellAddr, i)
{
srcToTgtCellWght[i] = scalarList(srcToTgt[i].size(), srcVc[i]);
srcToTgtCellAddr[i].transfer(srcToTgt[i]);
}
void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
{
if (debug)
{
Info<< "extendedLeastSquaresVectors::makeLeastSquaresVectors() :"
<< "Constructing least square gradient vectors"
<< endl;
}
const fvMesh& mesh = mesh_;
pVectorsPtr_ = new surfaceVectorField
(
IOobject
(
"LeastSquaresP",
mesh_.pointsInstance(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh_,
dimensionedVector("zero", dimless/dimLength, vector::zero)
);
surfaceVectorField& lsP = *pVectorsPtr_;
nVectorsPtr_ = new surfaceVectorField
(
IOobject
(
"LeastSquaresN",
mesh_.pointsInstance(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh_,
dimensionedVector("zero", dimless/dimLength, vector::zero)
);
surfaceVectorField& lsN = *nVectorsPtr_;
// Set local references to mesh data
const unallocLabelList& owner = mesh_.owner();
const unallocLabelList& neighbour = mesh_.neighbour();
// Build the d-vectors
surfaceVectorField d = mesh_.Sf()/(mesh_.magSf()*mesh_.deltaCoeffs());
if (!mesh_.orthogonal())
{
d -= mesh_.correctionVectors()/mesh_.deltaCoeffs();
}
// Set up temporary storage for the dd tensor (before inversion)
symmTensorField dd(mesh_.nCells(), symmTensor::zero);
forAll(owner, faceI)
{
symmTensor wdd = 1.0/magSqr(d[faceI])*sqr(d[faceI]);
dd[owner[faceI]] += wdd;
dd[neighbour[faceI]] += wdd;
}
void gammaSST<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const surfaceScalarField& alphaRhoPhi = this->alphaRhoPhi_;
const volVectorField& U = this->U_;
volScalarField& nut = this->nut_;
volScalarField& omega_ = this->omega_;
volScalarField& k_ = this->k_;
eddyViscosity<RASModel<BasicTurbulenceModel> >::correct();
volScalarField divU(fvc::div(fvc::absolute(this->phi(), U)));
tmp<volTensorField> tgradU = fvc::grad(U);
const volScalarField S2(2*magSqr(symm(tgradU())));
const volScalarField S("S", sqrt(S2));
const volScalarField W("Omega", sqrt(2*magSqr(skew(tgradU()))));
volScalarField G(this->GName(), nut*S*W);
tgradU.clear();
// Update omega and G at the wall
omega_.boundaryFieldRef().updateCoeffs();
const volScalarField CDkOmega
( "CD",
(2*this->alphaOmega2_)*(fvc::grad(k_) & fvc::grad(omega_))/omega_
);
const volScalarField F1("F1", this->F1(CDkOmega));
{
volScalarField gamma(this->gamma(F1));
volScalarField beta(this->beta(F1));
// Turbulent frequency equation
tmp<fvScalarMatrix> omegaEqn
(
fvm::ddt(alpha, rho, omega_)
+ fvm::div(alphaRhoPhi, omega_)
- fvm::laplacian(alpha*rho*this->DomegaEff(F1), omega_)
==
alpha*rho*gamma*S*W
- fvm::Sp(alpha*rho*beta*omega_, omega_)
- fvm::SuSp
(
alpha*rho*(F1 - scalar(1))*CDkOmega/omega_,
omega_
)
);
omegaEqn.ref().relax();
omegaEqn.ref().boundaryManipulate(omega_.boundaryFieldRef());
solve(omegaEqn);
bound(omega_, this->omegaMin_);
}
// Turbulent kinetic energy equation
const volScalarField FonLim(
"FonLim",
min( max(sqr(this->y_)*S/this->nu() / (
2.2*ReThetacLim_) - 1., 0.), 3.)
);
const volScalarField PkLim(
"PkLim",
5*Ck_ * max(gammaInt()-0.2,0.) * (1-gammaInt()) * FonLim *
max(3*CSEP_*this->nu() - this->nut_, 0.*this->nut_) * S * W
);
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(alpha, rho, k_)
+ fvm::div(alphaRhoPhi, k_)
- fvm::laplacian(alpha*rho*this->DkEff(F1), k_)
==
alpha*rho*(G*gammaInt() + PkLim)
- fvm::Sp(max(gammaInt(),scalar(0.1)) * alpha*rho*this->betaStar_*omega_, k_)
);
kEqn.ref().relax();
solve(kEqn);
bound(k_, this->kMin_);
this->correctNut(S2, this->F23());
// Intermittency equation (2)
volScalarField Pgamma1 = Flength_ * S * gammaInt_ * Fonset(S);
volScalarField Pgamma2 = ca2_ * W * gammaInt_ * Fturb();
tmp<fvScalarMatrix> gammaEqn
(
fvm::ddt(alpha, rho, gammaInt_)
+ fvm::div(alphaRhoPhi, gammaInt_)
- fvm::laplacian(alpha*rho*this->DgammaEff(), gammaInt_)
==
alpha*rho*Pgamma1 - fvm::Sp(alpha*rho*Pgamma1, gammaInt_) +
alpha*rho*Pgamma2 - fvm::Sp(alpha*rho*ce2_*Pgamma2, gammaInt_)
);
gammaEqn.ref().relax();
solve(gammaEqn);
bound(gammaInt_,scalar(0));
if (debug && this->runTime_.outputTime()) {
S.write();
W.write();
F1.write();
CDkOmega.write();
const volScalarField Pgamma("Pgamma", Pgamma1*(scalar(1)-gammaInt_));
Pgamma.write();
const volScalarField Egamma("Egamma", Pgamma2*(scalar(1)-ce2_*gammaInt_));
Egamma.write();
FonLim.write();
PkLim.write();
Fonset(S)().write();
FPG()().write();
}
}
void Foam::AnisothermalPhaseModel<BasePhaseModel>::correctKinematics()
{
BasePhaseModel::correctKinematics();
K_ = 0.5*magSqr(this->U());
}
void Foam::meshRefinement::snapToSurface
(
labelList& pointSurfaceRegion,
labelList& edgeSurfaceRegion,
scalarField& edgeWeight
)
{
const edgeList& edges = mesh_.edges();
const pointField& points = mesh_.points();
pointSurfaceRegion.setSize(points.size());
pointSurfaceRegion = -1;
edgeSurfaceRegion.setSize(edges.size());
edgeSurfaceRegion = -1;
edgeWeight.setSize(edges.size());
edgeWeight = -GREAT;
// Do test for intersections
// ~~~~~~~~~~~~~~~~~~~~~~~~~
labelList surface1;
List<pointIndexHit> hit1;
labelList region1;
//vectorField normal1;
labelList surface2;
List<pointIndexHit> hit2;
labelList region2;
//vectorField normal2;
{
vectorField start(edges.size());
vectorField end(edges.size());
forAll(edges, edgei)
{
const edge& e = edges[edgei];
start[edgei] = points[e[0]];
end[edgei] = points[e[1]];
}
surfaces_.findNearestIntersection
(
//labelList(1, 0), //identity(surfaces_.surfaces().size()),
identity(surfaces_.surfaces().size()),
start,
end,
surface1,
hit1,
region1,
//normal1,
surface2,
hit2,
region2
//normal2
);
}
// Adjust location
// ~~~~~~~~~~~~~~~
pointField newPoints(points);
label nAdjusted = 0;
const labelListList& pointEdges = mesh_.pointEdges();
forAll(pointEdges, pointi)
{
const point& pt = points[pointi];
const labelList& pEdges = pointEdges[pointi];
// Get the nearest intersection
label minEdgei = -1;
scalar minFraction = 0.5; // Harpoon 0.25; // Samm?
forAll(pEdges, pEdgei)
{
label edgei = pEdges[pEdgei];
if (hit1[edgei].hit())
{
const point& hitPt = hit1[edgei].hitPoint();
const edge& e = edges[edgei];
label otherPointi = e.otherVertex(pointi);
const point& otherPt = points[otherPointi];
vector eVec(otherPt-pt);
scalar f = eVec&(hitPt-pt)/magSqr(eVec);
if (f < minFraction)
{
minEdgei = edgei;
minFraction = f;
}
}
}
if (minEdgei != -1 && minFraction >= 0.01)
{
// Move point to intersection with minEdgei
if (pointSurfaceRegion[pointi] == -1)
{
pointSurfaceRegion[pointi] = surfaces_.globalRegion
(
surface1[minEdgei],
region1[minEdgei]
);
newPoints[pointi] = hit1[minEdgei].hitPoint();
nAdjusted++;
}
}
}
Foam::jjc2014Zone::jjc2014Zone
(
const word& name,
const fvMesh& mesh,
const dictionary& dict
)
:
name_(name),
mesh_(mesh),
dict_(dict),
cellZoneID_(mesh_.cellZones().findZoneID(name)),
#if OFVERSION<230 || EXTBRANCH == 1
coordSys_(dict, mesh),
#else
coordSys_(mesh, dict),
#endif
porosity_( readScalar( dict_.lookup("porosity") ) ),
addedMassCoeff_( readScalar( dict_.lookup("gammaAddedMass") ) ),
D_("D", dimensionSet(0, -2, 0, 0, 0), tensor::zero),
F_("F", dimensionSet(0, -1, 0, 0, 0), tensor::zero)
{
Info<< "Creating porous zone: " << name_ << endl;
autoPtr<Foam::porosityCoefficient> pcPtr( Foam::porosityCoefficient::New( dict ) );
bool foundZone = (cellZoneID_ != -1);
reduce(foundZone, orOp<bool>());
if (!foundZone && Pstream::master())
{
FatalErrorIn
(
"Foam::jjc2014Zone::jjc2014Zone"
"(const fvMesh&, const word&, const dictionary&)"
) << "cannot find porous cellZone " << name_
<< exit(FatalError);
}
// porosity
if (porosity_ <= 0.0 || porosity_ > 1.0)
{
FatalIOErrorIn
(
"Foam::jjc2014Zone::jjc2014Zone"
"(const fvMesh&, const word&, const dictionary&)",
dict_
)
<< "out-of-range porosity value " << porosity_
<< exit(FatalIOError);
}
// local-to-global transformation tensor
#if OFVERSION<230 || EXTBRANCH == 1
const tensor& E = coordSys_.R();
#else
const tensor E = coordSys_.R().R();
#endif
dimensionedVector d( pcPtr->linearCoefficient() );
if (D_.dimensions() != d.dimensions())
{
FatalIOErrorIn
(
"Foam::jjc2014Zone::jjc2014Zone"
"(const fvMesh&, const word&, const dictionary&)",
dict_
) << "incorrect dimensions for d: " << d.dimensions()
<< " should be " << D_.dimensions()
<< exit(FatalIOError);
}
checkNegativeResistance(d);
D_.value().xx() = d.value().x();
D_.value().yy() = d.value().y();
D_.value().zz() = d.value().z();
D_.value() = (E & D_ & E.T()).value();
dimensionedVector f( pcPtr->quadraticCoefficient() );
if (F_.dimensions() != f.dimensions())
{
FatalIOErrorIn
(
"Foam::jjc2014Zone::jjc2014Zone"
"(const fvMesh&, const word&, const dictionary&)",
dict_
) << "incorrect dimensions for f: " << f.dimensions()
<< " should be " << F_.dimensions()
<< exit(FatalIOError);
}
checkNegativeResistance(f);
F_.value().xx() = 0.5 * f.value().x();
F_.value().yy() = 0.5 * f.value().y();
F_.value().zz() = 0.5 * f.value().z();
F_.value() = (E & F_ & E.T()).value();
// it is an error not to define anything
if
(
magSqr(D_.value()) <= VSMALL
&& magSqr(F_.value()) <= VSMALL
)
{
FatalIOErrorIn
(
"Foam::jjc2014Zone::jjc2014Zone"
"(const fvMesh&, const word&, const dictionary&)",
dict_
) << "neither powerLaw (C0/C1) "
"nor Darcy-Forchheimer law (d/f) specified"
<< exit(FatalIOError);
}
}
void Foam::directAMI<SourcePatch, TargetPatch>::appendToDirectSeeds
(
labelList& mapFlag,
labelList& srcTgtSeed,
DynamicList<label>& srcSeeds,
DynamicList<label>& nonOverlapFaces,
label& srcFacei,
label& tgtFacei
) const
{
const labelList& srcNbr = this->srcPatch_.faceFaces()[srcFacei];
const labelList& tgtNbr = this->tgtPatch_.faceFaces()[tgtFacei];
const pointField& srcPoints = this->srcPatch_.points();
const pointField& tgtPoints = this->tgtPatch_.points();
const vectorField& srcCf = this->srcPatch_.faceCentres();
forAll(srcNbr, i)
{
label srcI = srcNbr[i];
if ((mapFlag[srcI] == 0) && (srcTgtSeed[srcI] == -1))
{
// first attempt: match by comparing face centres
const face& srcF = this->srcPatch_[srcI];
const point& srcC = srcCf[srcI];
scalar tol = GREAT;
forAll(srcF, fpI)
{
const point& p = srcPoints[srcF[fpI]];
scalar d2 = magSqr(p - srcC);
if (d2 < tol)
{
tol = d2;
}
}
tol = max(SMALL, 0.0001*sqrt(tol));
bool found = false;
forAll(tgtNbr, j)
{
label tgtI = tgtNbr[j];
const face& tgtF = this->tgtPatch_[tgtI];
const point tgtC = tgtF.centre(tgtPoints);
if (mag(srcC - tgtC) < tol)
{
// new match - append to lists
found = true;
srcTgtSeed[srcI] = tgtI;
srcSeeds.append(srcI);
break;
}
}
// second attempt: match by shooting a ray into the tgt face
if (!found)
{
const vector srcN = srcF.normal(srcPoints);
forAll(tgtNbr, j)
{
label tgtI = tgtNbr[j];
const face& tgtF = this->tgtPatch_[tgtI];
pointHit ray = tgtF.ray(srcCf[srcI], srcN, tgtPoints);
if (ray.hit())
{
// new match - append to lists
found = true;
srcTgtSeed[srcI] = tgtI;
srcSeeds.append(srcI);
break;
}
}
}
// Returns miss or hit with face (0..5) and region(always 0)
Foam::pointIndexHit Foam::searchableBox::findNearest
(
const point& bbMid,
const point& sample,
const scalar nearestDistSqr
) const
{
// Point can be inside or outside. For every component direction can be
// left of min, right of max or inbetween.
// - outside points: project first one x plane (either min().x()
// or max().x()), then onto y plane and finally z. You should be left
// with intersection point
// - inside point: find nearest side (compare to mid point). Project onto
// that.
// The face is set to the last projected face.
// Outside point projected onto cube. Assume faces 0..5.
pointIndexHit info(true, sample, -1);
bool outside = false;
// (for internal points) per direction what nearest cube side is
point near;
for (direction dir = 0; dir < vector::nComponents; dir++)
{
if (info.rawPoint()[dir] < min()[dir])
{
projectOntoCoordPlane(dir, min(), info);
outside = true;
}
else if (info.rawPoint()[dir] > max()[dir])
{
projectOntoCoordPlane(dir, max(), info);
outside = true;
}
else if (info.rawPoint()[dir] > bbMid[dir])
{
near[dir] = max()[dir];
}
else
{
near[dir] = min()[dir];
}
}
// For outside points the info will be correct now. Handle inside points
// using the three near distances. Project onto the nearest plane.
if (!outside)
{
vector dist(cmptMag(info.rawPoint() - near));
if (dist.x() < dist.y())
{
if (dist.x() < dist.z())
{
// Project onto x plane
projectOntoCoordPlane(vector::X, near, info);
}
else
{
projectOntoCoordPlane(vector::Z, near, info);
}
}
else
{
if (dist.y() < dist.z())
{
projectOntoCoordPlane(vector::Y, near, info);
}
else
{
projectOntoCoordPlane(vector::Z, near, info);
}
}
}
// Check if outside. Optimisation: could do some checks on distance already
// on components above
if (magSqr(info.rawPoint() - sample) > nearestDistSqr)
{
info.setMiss();
info.setIndex(-1);
}
return info;
}
void Foam::timeVaryingMappedTotalPressureFvPatchScalarField::updateCoeffs
(
const vectorField& Up
)
{
if (updated())
{
return;
}
// Map the total-pressure field onto this field
timeVaryingMappedFixedValueFvPatchScalarField::updateCoeffs();
const scalarField p0 = *this;
const fvsPatchField<scalar>& phip =
patch().lookupPatchField<surfaceScalarField, scalar>(phiName_);
if (dimensionedInternalField().dimensions() == dimPressure/dimDensity)
{
if (rhoName_ == "none")
{
operator==(p0 - 0.5*(1.0 - pos(phip))*magSqr(Up));
}
else if (rhoName_ == "rho")
{
operator==(p0/rho_ - 0.5*(1.0 - pos(phip))*magSqr(Up));
}
else
{
FatalErrorIn
(
"timeVaryingMappedTotalPressureFvPatchScalarField::"
"updateCoeffs()"
) << " rhoName set inconsistently, rhoName = " << rhoName_
<< ".\n"
<< " Set rhoName to 'rho' or 'none' depending on the "
"definition of total pressure." << nl
<< " on patch " << this->patch().name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalError);
}
}
else if (dimensionedInternalField().dimensions() == dimPressure)
{
if (rhoName_ != "none")
{
const fvPatchField<scalar>& rho =
patch().lookupPatchField<volScalarField, scalar>(rhoName_);
operator==(p0 - 0.5*rho*(1.0 - pos(phip))*magSqr(Up));
}
else if (psiName_ != "none")
{
const fvPatchField<scalar>& psip =
patch().lookupPatchField<volScalarField, scalar>(psiName_);
if (gamma_ > 1.0)
{
scalar gM1ByG = (gamma_ - 1.0)/gamma_;
operator==
(
p0
/pow
(
(1.0 + 0.5*psip*gM1ByG*(1.0 - pos(phip))*magSqr(Up)),
1.0/gM1ByG
)
);
}
else
{
operator==(p0/(1.0 + 0.5*psip*(1.0 - pos(phip))*magSqr(Up)));
}
}
else
{
FatalErrorIn
(
"timeVaryingMappedTotalPressureFvPatchScalarField::"
"updateCoeffs()"
) << " rhoName or psiName set inconsistently, rhoName = "
<< rhoName_ << ", psiName = " << psiName_ << ".\n"
<< " Set either rhoName or psiName depending on the "
"definition of total pressure." << nl
<< " Set the unused variable(s) to 'none'.\n"
<< " on patch " << this->patch().name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalError);
}
}
else
{
FatalErrorIn
(
"timeVaryingMappedTotalPressureFvPatchScalarField::updateCoeffs()"
) << "Incorrect dimensions for pressure "
<< dimensionedInternalField().dimensions()
<< " Should be either " << dimPressure
<< " for compressible/variable density flow\n"
<< " or " << dimPressure/dimDensity
<< " for incompressible flow.\n"
<< " on patch " << this->patch().name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalError);
}
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createDynamicFvMesh.H"
pimpleControl pimple(mesh);
#include "createFields.H"
#include "readTimeControls.H"
bool checkMeshCourantNo =
readBool(pimple.dict().lookup("checkMeshCourantNo"));
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "initContinuityErrs.H"
#include "readCourantType.H"
dimensionedScalar v_zero("v_zero", dimVolume/dimTime, 0.0);
Info<< "\nStarting time loop\n" << endl;
#include "createSurfaceFields.H"
#include "markBadQualityCells.H"
while (runTime.run())
{
#include "acousticCourantNo.H"
#include "compressibleCourantNo.H"
#include "readTimeControls.H"
#include "setDeltaT.H"
runTime++;
psi.oldTime();
rho.oldTime();
p.oldTime();
U.oldTime();
h.oldTime();
Info<< "Time = " << runTime.timeName() << nl << endl;
// --- Move mesh and update fluxes
{
// Do any mesh changes
mesh.update();
if (mesh.changing())
{
if (runTime.timeIndex() > 1)
{
surfaceScalarField amNew = min(min(phiv_pos - fvc::meshPhi(rho,U) - cSf_pos, phiv_neg - fvc::meshPhi(rho,U) - cSf_neg), v_zero);
phiNeg += kappa*(amNew - am)*p_neg*psi_neg;
phiPos += (1.0 - kappa)*(amNew - am)*p_neg*psi_neg;
}
else
{
phiNeg -= fvc::meshPhi(rho,U) * fvc::interpolate(rho);
}
phi = phiPos + phiNeg;
if (checkMeshCourantNo)
{
#include "meshCourantNo.H"
}
#include "markBadQualityCells.H"
}
}
// --- Solve density
solve
(
fvm::ddt(rho) + fvc::div(phi)
);
Info<< "rho max/min : " << max(rho).value()
<< " " << min(rho).value() << endl;
// --- Solve momentum
#include "UEqn.H"
// --- Solve energy
#include "hEqn.H"
// --- Solve pressure (PISO)
{
while (pimple.correct())
{
#include "pEqnDyM.H"
}
#include "updateKappa.H"
}
// --- Solve turbulence
turbulence->correct();
Ek = 0.5*magSqr(U);
EkChange = fvc::ddt(rho,Ek) + fvc::div(phiPos,Ek) + fvc::div(phiNeg,Ek);
dpdt = fvc::ddt(p) - fvc::div(fvc::meshPhi(rho,U), p);
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
tmp<volScalarField> SpalartAllmaras::epsilon() const
{
return 2*nuEff()*magSqr(symm(fvc::grad(U())));
}
Foam::pointIndexHit Foam::searchableCylinder::findNearest
(
const point& sample,
const scalar nearestDistSqr
) const
{
pointIndexHit info(false, sample, -1);
vector v(sample - point1_);
// Decompose sample-point1 into normal and parallel component
scalar parallel = (v & unitDir_);
// Remove the parallel component and normalise
v -= parallel*unitDir_;
scalar magV = mag(v);
if (magV < ROOTVSMALL)
{
v = vector::zero;
}
else
{
v /= magV;
}
if (parallel <= 0)
{
// nearest is at point1 end cap. Clip to radius.
info.setPoint(point1_ + min(magV, radius_)*v);
}
else if (parallel >= magDir_)
{
// nearest is at point2 end cap. Clip to radius.
info.setPoint(point2_ + min(magV, radius_)*v);
}
else
{
// inbetween endcaps. Might either be nearer endcaps or cylinder wall
// distance to endpoint: parallel or parallel-magDir
// distance to cylinder wall: magV-radius_
// Nearest cylinder point
point cylPt = sample + (radius_-magV)*v;
if (parallel < 0.5*magDir_)
{
// Project onto p1 endcap
point end1Pt = point1_ + min(magV, radius_)*v;
if (magSqr(sample-cylPt) < magSqr(sample-end1Pt))
{
info.setPoint(cylPt);
}
else
{
info.setPoint(end1Pt);
}
}
else
{
// Project onto p2 endcap
point end2Pt = point2_ + min(magV, radius_)*v;
if (magSqr(sample-cylPt) < magSqr(sample-end2Pt))
{
info.setPoint(cylPt);
}
else
{
info.setPoint(end2Pt);
}
}
}
if (magSqr(sample - info.rawPoint()) < nearestDistSqr)
{
info.setHit();
info.setIndex(0);
}
return info;
}
void LienCubicKE::correct()
{
RASModel::correct();
if (!turbulence_)
{
return;
}
gradU_ = fvc::grad(U_);
// generation term
tmp<volScalarField> S2 = symm(gradU_) && gradU_;
volScalarField G
(
"RASModel::G",
Cmu_*sqr(k_)/epsilon_*S2 - (nonlinearStress_ && gradU_)
);
// Update epsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
C1_*G*epsilon_/k_
- fvm::Sp(C2_*epsilon_/k_, epsilon_)
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, epsilonMin_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi_, k_)
- fvm::laplacian(DkEff(), k_)
==
G
- fvm::Sp(epsilon_/k_, k_)
);
kEqn().relax();
solve(kEqn);
bound(k_, kMin_);
// Re-calculate viscosity
eta_ = k_/epsilon_*sqrt(2.0*magSqr(0.5*(gradU_ + gradU_.T())));
ksi_ = k_/epsilon_*sqrt(2.0*magSqr(0.5*(gradU_ - gradU_.T())));
Cmu_ = 2.0/(3.0*(A1_ + eta_ + alphaKsi_*ksi_));
fEta_ = A2_ + pow(eta_, 3.0);
C5viscosity_ =
- 2.0*pow(Cmu_, 3.0)*pow(k_, 4.0)/pow(epsilon_, 3.0)
*(magSqr(gradU_ + gradU_.T()) - magSqr(gradU_ - gradU_.T()));
nut_ = Cmu_*sqr(k_)/epsilon_ + C5viscosity_;
nut_.correctBoundaryConditions();
nonlinearStress_ = symm
(
// quadratic terms
pow(k_, 3.0)/sqr(epsilon_)*
(
Ctau1_/fEta_*
(
(gradU_ & gradU_)
+ (gradU_ & gradU_)().T()
)
+ Ctau2_/fEta_*(gradU_ & gradU_.T())
+ Ctau3_/fEta_*(gradU_.T() & gradU_)
)
// cubic term C4
- 20.0*pow(k_, 4.0)/pow(epsilon_, 3.0)
*pow(Cmu_, 3.0)
*(
((gradU_ & gradU_) & gradU_.T())
+ ((gradU_ & gradU_.T()) & gradU_.T())
- ((gradU_.T() & gradU_) & gradU_)
- ((gradU_.T() & gradU_.T()) & gradU_)
)
);
}
int main(int argc, char *argv[])
{
#include "postProcess.H"
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "createControl.H"
#include "createFields.H"
#include "createFvOptions.H"
#include "initContinuityErrs.H"
#include "createTimeControls.H"
#include "compressibleCourantNo.H"
#include "setInitialDeltaT.H"
turbulence->validate();
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.run())
{
#include "readTimeControls.H"
#include "compressibleCourantNo.H"
#include "setDeltaT.H"
runTime++;
Info<< "Time = " << runTime.timeName() << nl << endl;
#include "rhoEqn.H"
// --- Pressure-velocity PIMPLE corrector loop
while (pimple.loop())
{
#include "UEqn.H"
#include "EEqn.H"
// --- Pressure corrector loop
while (pimple.correct())
{
#include "pEqn.H"
}
if (pimple.turbCorr())
{
turbulence->correct();
}
}
rho = thermo.rho();
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << endl;
Info<< "Inflow : " << -1.0* sum(phi.boundaryField()[inlet]) <<" [kg/s]" << endl;
Info<< "Outflow : " << sum(phi.boundaryField()[outlet]) <<" [kg/s]" << endl;
Info<< "EnergyInflow : " << -1.0* sum( phi.boundaryField()[inlet] * ( thermo.he().boundaryField()[inlet] + 0.5*magSqr(U.boundaryField()[inlet]) ) ) <<" [W]" << endl;
Info<< "EnergyOutflow : " << sum( phi.boundaryField()[outlet] * ( thermo.he().boundaryField()[outlet] + 0.5*magSqr(U.boundaryField()[outlet]) ) ) <<" [W]" << endl;
Info<< "EnergyBalance : " << sum( phi.boundaryField()[outlet] * ( thermo.he().boundaryField()[outlet] + 0.5*magSqr(U.boundaryField()[outlet]) ) )
+1.0* sum( phi.boundaryField()[inlet] * ( thermo.he().boundaryField()[inlet] + 0.5*magSqr(U.boundaryField()[inlet]) ) ) <<" [W]" << endl;
Info<< "rho max/avg/min : " << gMax(thermo.rho()) << " " << gAverage(thermo.rho()) << " " << gMin(thermo.rho()) << endl;
Info<< "T max/avg/min : " << gMax(thermo.T()) << " " << gAverage(thermo.T()) << " " << gMin(thermo.T()) << endl;
Info<< "P max/avg/min : " << gMax(thermo.p()) << " " << gAverage(thermo.p()) << " " << gMin(thermo.p()) << endl;
Info<< "Prg max/avg/min : " << gMax(p_rgh) << " " << gAverage(p_rgh) << " " << gMin(p_rgh) << endl;
Info<< "U max/avg/min : " << max(U.component(2)).value() << " " << average(U.component(2)).value() << " " << min(U.component(2)).value() << endl;
Info<< "Prg max-min : " << gMax(p_rgh) - gMin(p_rgh) << endl;
Info<< " " << endl;
Info<< "sngrad(rho) :" << gMax(snGradRho.boundaryField()[outlet]) << " " << gAverage(snGradRho.boundaryField()[outlet]) << " " << gMin(snGradRho.boundaryField()[outlet]) << endl;
Info<< " " << endl;
}
Info<< "End\n" << endl;
return 0;
}
LienCubicKE::LienCubicKE
(
const volVectorField& U,
const surfaceScalarField& phi,
transportModel& transport,
const word& turbulenceModelName,
const word& modelName
)
:
RASModel(modelName, U, phi, transport, turbulenceModelName),
C1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C1",
coeffDict_,
1.44
)
),
C2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C2",
coeffDict_,
1.92
)
),
sigmak_
(
dimensioned<scalar>::lookupOrAddToDict
(
"sigmak",
coeffDict_,
1.0
)
),
sigmaEps_
(
dimensioned<scalar>::lookupOrAddToDict
(
"sigmaEps",
coeffDict_,
1.3
)
),
A1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"A1",
coeffDict_,
1.25
)
),
A2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"A2",
coeffDict_,
1000.0
)
),
Ctau1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ctau1",
coeffDict_,
-4.0
)
),
Ctau2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ctau2",
coeffDict_,
13.0
)
),
Ctau3_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ctau3",
coeffDict_,
-2.0
)
),
alphaKsi_
(
dimensioned<scalar>::lookupOrAddToDict
(
"alphaKsi",
coeffDict_,
0.9
)
),
k_
(
IOobject
(
"k",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
autoCreateK("k", mesh_)
),
epsilon_
(
IOobject
(
"epsilon",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
autoCreateEpsilon("epsilon", mesh_)
),
gradU_(fvc::grad(U)),
eta_
(
k_/bound(epsilon_, epsilonMin_)
*sqrt(2.0*magSqr(0.5*(gradU_ + gradU_.T())))
),
ksi_
(
k_/epsilon_
*sqrt(2.0*magSqr(0.5*(gradU_ - gradU_.T())))
),
Cmu_(2.0/(3.0*(A1_ + eta_ + alphaKsi_*ksi_))),
fEta_(A2_ + pow(eta_, 3.0)),
C5viscosity_
(
- 2.0*pow3(Cmu_)*pow4(k_)/pow3(epsilon_)
*(
magSqr(gradU_ + gradU_.T())
- magSqr(gradU_ - gradU_.T())
)
),
nut_
(
IOobject
(
"nut",
runTime_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
autoCreateNut("nut", mesh_)
),
nonlinearStress_
(
"nonlinearStress",
// quadratic terms
symm
(
pow(k_, 3.0)/sqr(epsilon_)
*(
Ctau1_/fEta_
*(
(gradU_ & gradU_)
+ (gradU_ & gradU_)().T()
)
+ Ctau2_/fEta_*(gradU_ & gradU_.T())
+ Ctau3_/fEta_*(gradU_.T() & gradU_)
)
// cubic term C4
- 20.0*pow(k_, 4.0)/pow(epsilon_, 3.0)
*pow(Cmu_, 3.0)
*(
((gradU_ & gradU_) & gradU_.T())
+ ((gradU_ & gradU_.T()) & gradU_.T())
- ((gradU_.T() & gradU_) & gradU_)
- ((gradU_.T() & gradU_.T()) & gradU_)
)
)
)
{
bound(k_, kMin_);
// already bounded: bound(epsilon_, epsilonMin_);
nut_ = Cmu_*sqr(k_)/epsilon_ + C5viscosity_;
nut_.correctBoundaryConditions();
printCoeffs();
}
forAll(pd, patchFaceI)
{
dd[faceCells[patchFaceI]] +=
(1.0/magSqr(pd[patchFaceI]))*sqr(pd[patchFaceI]);
}
Foam::label Foam::globalIndexAndTransform::matchTransform
(
const List<vectorTensorTransform>& refTransforms,
label& matchedRefTransformI,
const vectorTensorTransform& testTransform,
scalar tolerance,
bool checkBothSigns
) const
{
matchedRefTransformI = -1;
forAll(refTransforms, i)
{
const vectorTensorTransform& refTransform = refTransforms[i];
scalar maxVectorMag = sqrt
(
max(magSqr(testTransform.t()), magSqr(refTransform.t()))
);
// Test the difference between vector parts to see if it is
// less than tolerance times the larger vector part magnitude.
scalar vectorDiff =
mag(refTransform.t() - testTransform.t())
/(maxVectorMag + VSMALL)
/tolerance;
// Test the difference between tensor parts to see if it is
// less than the tolerance. sqrt(3.0) factor used to scale
// differnces as this is magnitude of a rotation tensor. If
// neither transform has a rotation, then the test is not
// necessary.
scalar tensorDiff = 0;
if (refTransform.hasR() || testTransform.hasR())
{
tensorDiff =
mag(refTransform.R() - testTransform.R())
/sqrt(3.0)
/tolerance;
}
// ...Diff result is < 1 if the test part matches the ref part
// within tolerance
if (vectorDiff < 1 && tensorDiff < 1)
{
matchedRefTransformI = i;
return +1;
}
if (checkBothSigns)
{
// Test the inverse transform differences too
vectorDiff =
mag(refTransform.t() + testTransform.t())
/(maxVectorMag + VSMALL)
/tolerance;
tensorDiff = 0;
if (refTransform.hasR() || testTransform.hasR())
{
tensorDiff =
mag(refTransform.R() - testTransform.R().T())
/sqrt(3.0)
/tolerance;
}
if (vectorDiff < 1 && tensorDiff < 1)
{
matchedRefTransformI = i;
return -1;
}
}
}
return 0;
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
pisoControl piso(mesh);
pisoControl bpiso(mesh, "BPISO");
#include "createFields.H"
#include "initContinuityErrs.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< nl << "Starting time loop" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
#include "CourantNo.H"
{
fvVectorMatrix UEqn
(
fvm::ddt(U)
+ fvm::div(phi, U)
- fvc::div(phiB, 2.0*DBU*B)
- fvm::laplacian(nu, U)
+ fvc::grad(DBU*magSqr(B))
);
if (piso.momentumPredictor())
{
solve(UEqn == -fvc::grad(p));
}
// --- PISO loop
while (piso.correct())
{
volScalarField rAU(1.0/UEqn.A());
surfaceScalarField rAUf("rAUf", fvc::interpolate(rAU));
volVectorField HbyA("HbyA", U);
HbyA = rAU*UEqn.H();
surfaceScalarField phiHbyA
(
"phiHbyA",
(fvc::interpolate(HbyA) & mesh.Sf())
+ rAUf*fvc::ddtCorr(U, phi)
);
while (piso.correctNonOrthogonal())
{
fvScalarMatrix pEqn
(
fvm::laplacian(rAUf, p) == fvc::div(phiHbyA)
);
pEqn.setReference(pRefCell, pRefValue);
pEqn.solve(mesh.solver(p.select(piso.finalInnerIter())));
if (piso.finalNonOrthogonalIter())
{
phi = phiHbyA - pEqn.flux();
}
}
#include "continuityErrs.H"
U = HbyA - rAU*fvc::grad(p);
U.correctBoundaryConditions();
}
}
// --- B-PISO loop
while (bpiso.correct())
{
fvVectorMatrix BEqn
(
fvm::ddt(B)
+ fvm::div(phi, B)
- fvc::div(phiB, U)
- fvm::laplacian(DB, B)
);
BEqn.solve();
volScalarField rAB(1.0/BEqn.A());
surfaceScalarField rABf("rABf", fvc::interpolate(rAB));
phiB = (fvc::interpolate(B) & mesh.Sf())
+ rABf*fvc::ddtCorr(B, phiB);
while (bpiso.correctNonOrthogonal())
{
fvScalarMatrix pBEqn
(
fvm::laplacian(rABf, pB) == fvc::div(phiB)
);
pBEqn.solve(mesh.solver(pB.select(bpiso.finalInnerIter())));
if (bpiso.finalNonOrthogonalIter())
{
phiB -= pBEqn.flux();
}
}
#include "magneticFieldErr.H"
}
runTime.write();
}
Info<< "End\n" << endl;
return 0;
}
void Foam::uniformTotalPressureFvPatchScalarField::updateCoeffs
(
const vectorField& Up
)
{
if (updated())
{
return;
}
scalar p0 = pressure_->value(this->db().time().timeOutputValue());
const fvsPatchField<scalar>& phip =
patch().lookupPatchField<surfaceScalarField, scalar>(phiName_);
if (psiName_ == "none" && rhoName_ == "none")
{
operator==(p0 - 0.5*(1.0 - pos(phip))*magSqr(Up));
}
else if (rhoName_ == "none")
{
const fvPatchField<scalar>& psip =
patch().lookupPatchField<volScalarField, scalar>(psiName_);
if (gamma_ > 1.0)
{
scalar gM1ByG = (gamma_ - 1.0)/gamma_;
operator==
(
p0
/pow
(
(1.0 + 0.5*psip*gM1ByG*(1.0 - pos(phip))*magSqr(Up)),
1.0/gM1ByG
)
);
}
else
{
operator==(p0/(1.0 + 0.5*psip*(1.0 - pos(phip))*magSqr(Up)));
}
}
else if (psiName_ == "none")
{
const fvPatchField<scalar>& rho =
patch().lookupPatchField<volScalarField, scalar>(rhoName_);
operator==(p0 - 0.5*rho*(1.0 - pos(phip))*magSqr(Up));
}
else
{
FatalErrorInFunction
<< " rho or psi set inconsitently, rho = " << rhoName_
<< ", psi = " << psiName_ << ".\n"
<< " Set either rho or psi or neither depending on the "
"definition of total pressure.\n"
<< " Set the unused variables to 'none'.\n"
<< " on patch " << this->patch().name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalError);
}
fixedValueFvPatchScalarField::updateCoeffs();
}
