void reactingOneDimRPvol2::solveContinuity()
{
if (debug)
{
InfoInFunction << endl;
}
const scalarField mass0 = rho_*regionMesh().V();
fvScalarMatrix rhoEqn
(
fvm::ddt(rho_)
+ fvc::div(phiPyrolysis_)
==
- solidChemistry_->RRg()
);
if (regionMesh().moving())
{
surfaceScalarField phiRhoMesh
(
fvc::interpolate(rho_)*regionMesh().phi()
);
rhoEqn += fvc::div(phiRhoMesh);
}
rhoEqn.solve();
updateMesh(mass0);
}
FaPatchValueExpressionDriver::FaPatchValueExpressionDriver(
const dictionary& dict,
const fvMesh&mesh
)
:
FaCommonValueExpressionDriver(dict),
patch_(
faRegionMesh(
regionMesh(
dict,
mesh,
searchOnDisc()
)).boundary()[
getPatchID(
faRegionMesh(
regionMesh(
dict,
mesh,
searchOnDisc()
)),
dict.lookup(
"faPatchName"
)
)
]
)
{
}
void reactingOneDim21::solveEnergy()
{
if (debug)
{
Info<< "reactingOneDim21::solveEnergy()" << endl;
}
tmp<volScalarField> alpha(solidThermo_.alpha());
dimensionedScalar Cp0("Cp0", dimEnergy/dimMass/dimTemperature, solidThermo_.composition().Cp(0, 1.0e05, 300.) );
dimensionedScalar Cp1("Cp1", dimEnergy/dimMass/dimTemperature, solidThermo_.composition().Cp(1, 1.0e05, 300.) );
fvScalarMatrix hEqn
(
fvm::ddt(rho_, h_)
- fvm::laplacian(alpha, h_)
+ fvc::laplacian(alpha, h_)
- fvc::laplacian(kappa(), T())
==
chemistrySh_
// - fvm::Sp(solidChemistry_->RRg(), h_)
+ solidChemistry_->RRs(0)*T()*Cp0
+ solidChemistry_->RRs(1)*T()*Cp1
);
if (gasHSource_)
{
const surfaceScalarField phiGas(fvc::interpolate(phiHsGas_));
hEqn += fvc::div(phiGas);
}
if (QrHSource_)
{
const surfaceScalarField phiQr(fvc::interpolate(Qr_)*nMagSf());
hEqn += fvc::div(phiQr);
}
if (regionMesh().moving())
{
surfaceScalarField phihMesh
(
fvc::interpolate(rho_*h_)*regionMesh().phi()
);
hEqn += fvc::div(phihMesh);
}
hEqn.relax();
hEqn.solve();
}
FaceZoneValueExpressionDriver::FaceZoneValueExpressionDriver(const dictionary& dict,const fvMesh&mesh)
:
SubsetValueExpressionDriver(dict),
faceZone_(
regionMesh(dict,mesh).faceZones()[
getFaceZoneID(
regionMesh(dict,mesh),
dict.lookup(
"zoneName"
)
)
]
)
{
}
scalar kinematicSingleLayer::CourantNumber() const
{
scalar CoNum = 0.0;
if (regionMesh().nInternalFaces() > 0)
{
const scalarField sumPhi
(
fvc::surfaceSum(mag(phi_))().primitiveField()
/ (deltaRho_.primitiveField() + ROOTVSMALL)
);
forAll(delta_, i)
{
if (delta_[i] > deltaCoLimit_)
{
CoNum = max(CoNum, sumPhi[i]/(delta_[i]*magSf()[i]));
}
}
CoNum *= 0.5*time_.deltaTValue();
}
reduce(CoNum, maxOp<scalar>());
Info<< "Film max Courant number: " << CoNum << endl;
return CoNum;
}
void Foam::regionModels::regionModel::evolve()
{
if (active_)
{
if (primaryMesh_.changing())
{
FatalErrorIn("regionModel::evolve()")
<< "Currently not possible to apply " << modelName_
<< " model to moving mesh cases" << nl << abort(FatalError);
}
Info<< "\nEvolving " << modelName_ << " for region "
<< regionMesh().name() << endl;
// Update any input information
//read();
// Pre-evolve
preEvolveRegion();
// Increment the region equations up to the new time level
evolveRegion();
// Provide some feedback
if (infoOutput_)
{
Info<< incrIndent;
info();
Info<< endl << decrIndent;
}
}
}
void reactingOneDimRPvol2::solveSpeciesMass()
{
if (debug)
{
InfoInFunction << endl;
}
volScalarField Yt(0.0*Ys_[0]);
for (label i=0; i<Ys_.size()-1; i++)
{
volScalarField& Yi = Ys_[i];
fvScalarMatrix YiEqn
(
fvm::ddt(rho_, Yi)
+ fvc::div(phiPyrolysis_, Yi)
==
solidChemistry_->RRs(i)
);
if (regionMesh().moving())
{
surfaceScalarField phiYiRhoMesh
(
fvc::interpolate(Yi*rho_)*regionMesh().phi()
);
YiEqn += fvc::div(phiYiRhoMesh);
}
YiEqn.solve(regionMesh().solver("Yi"));
Yi.max(0.0);
Yt += Yi;
}
Ys_[Ys_.size() - 1] = 1.0 - Yt;
//-Correct density from mixture density
forAll(rho_, celli)
{
scalar rc = 0;
forAll(Ys_, i)
{
rc += Ys_[i][celli]/solidThermo_.composition().rho(i, 1.0e5, 300.0);
}
forAll(intCoupledPatchIDs_, i)
{
const label patchi = intCoupledPatchIDs_[i];
const polyPatch& ppCoupled = rbm[patchi];
const vectorField& pNormals = ppCoupled.faceNormals();
nMagSfBf[patchi] = regionMesh().Sf().boundaryField()[patchi] & pNormals;
forAll(pNormals, localFacei)
{
const vector& n = pNormals[localFacei];
const labelList& faces = boundaryFaceFaces_[localPyrolysisFacei++];
forAll(faces, facei)
{
const label faceID = faces[facei];
nMagSf[faceID] = regionMesh().Sf()[faceID] & n;
}
}
}
void reactingOneDim::solveEnergy()
{
if (debug)
{
InfoInFunction << endl;
}
tmp<volScalarField> alpha(solidThermo_.alpha());
fvScalarMatrix hEqn
(
fvm::ddt(rho_, h_)
- fvm::laplacian(alpha, h_)
+ fvc::laplacian(alpha, h_)
- fvc::laplacian(kappa(), T())
==
chemistrySh_
- fvm::Sp(solidChemistry_->RRg(), h_)
);
if (gasHSource_)
{
const surfaceScalarField phiGas(fvc::interpolate(phiHsGas_));
hEqn += fvc::div(phiGas);
}
if (QrHSource_)
{
const surfaceScalarField phiQr(fvc::interpolate(Qr_)*nMagSf());
hEqn += fvc::div(phiQr);
}
if (regionMesh().moving())
{
surfaceScalarField phihMesh
(
fvc::interpolate(rho_*h_)*regionMesh().phi()
);
hEqn += fvc::div(phihMesh);
}
hEqn.relax();
hEqn.solve();
}
scalar reactingOneDim::solidRegionDiffNo() const
{
scalar DiNum = 0.0;
if (regionMesh().nInternalFaces() > 0)
{
surfaceScalarField KrhoCpbyDelta
(
regionMesh().surfaceInterpolation::deltaCoeffs()
* fvc::interpolate(K_)
/ fvc::interpolate(Cp()*rho_)
);
DiNum = max(KrhoCpbyDelta.internalField())*time_.deltaTValue();
}
return DiNum;
}
void noPyrolysis::constructThermoChemistry()
{
solidChemistry_.reset
(
solidChemistryModel::New(regionMesh()).ptr()
);
solidThermo_.reset(&solidChemistry_->solidThermo());
}
tmp<Foam::fvVectorMatrix> kinematicSingleLayer::solveMomentum
(
const volScalarField& pu,
const volScalarField& pp
)
{
if (debug)
{
InfoInFunction << endl;
}
// Momentum
tmp<fvVectorMatrix> tUEqn
(
fvm::ddt(deltaRho_, U_)
+ fvm::div(phi_, U_)
==
- USp_
// - fvm::SuSp(rhoSp_, U_)
- rhoSp_*U_
+ forces_.correct(U_)
+ turbulence_->Su(U_)
);
fvVectorMatrix& UEqn = tUEqn.ref();
UEqn.relax();
if (momentumPredictor_)
{
solve
(
UEqn
==
fvc::reconstruct
(
- fvc::interpolate(delta_)
* (
regionMesh().magSf()
* (
fvc::snGrad(pu, "snGrad(p)")
+ fvc::snGrad(pp, "snGrad(p)")*fvc::interpolate(delta_)
+ fvc::snGrad(delta_)*fvc::interpolate(pp)
)
- fvc::flux(rho_*gTan())
)
)
);
// Remove any patch-normal components of velocity
U_ -= nHat()*(nHat() & U_);
U_.correctBoundaryConditions();
}
return tUEqn;
}
void noPyrolysis::constructThermoChemistry()
{
solidChemistry_.reset
(
basicSolidChemistryModel::New(regionMesh()).ptr()
);
solidThermo_.reset(&solidChemistry_->solidThermo());
radiation_.reset(radiation::radiationModel::New(solidThermo_->T()).ptr());
}
void Foam::regionModels::regionModel1D::constructMeshObjects()
{
nMagSfPtr_.reset
(
new surfaceScalarField
(
IOobject
(
"nMagSf",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimArea, 0.0)
)
);
}
Foam::tmp<Foam::Field<Type> >
Foam::regionModels::regionModel::mapRegionPatchInternalField
(
const regionModel& nbrRegion,
const word& fieldName,
const label regionPatchI,
const bool flip
) const
{
typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
const fvMesh& nbrRegionMesh = nbrRegion.regionMesh();
if (nbrRegionMesh.foundObject<fieldType>(fieldName))
{
const label nbrPatchI = nbrCoupledPatchID(nbrRegion, regionPatchI);
int oldTag = UPstream::msgType();
UPstream::msgType() = oldTag + 1;
const AMIPatchToPatchInterpolation& ami =
interRegionAMI(nbrRegion, regionPatchI, nbrPatchI, flip);
const fieldType& nbrField =
nbrRegionMesh.lookupObject<fieldType>(fieldName);
const fvPatchField<Type>& nbrFieldp =
nbrField.boundaryField()[nbrPatchI];
tmp<Field<Type> > tresult
(
ami.interpolateToSource(nbrFieldp.patchInternalField())
);
UPstream::msgType() = oldTag;
return tresult;
}
else
{
const polyPatch& p = regionMesh().boundaryMesh()[regionPatchI];
return
tmp<Field<Type> >
(
new Field<Type>
(
p.size(),
pTraits<Type>::zero
)
);
}
}
CellSetValueExpressionDriver::CellSetValueExpressionDriver(const dictionary& dict,const fvMesh&mesh)
:
SetSubsetValueExpressionDriver(dict,dict.lookup("setName"),NEW),
cellSet_(
getSet<cellSet>(
regionMesh(dict,mesh),
dict.lookup("setName"),
origin_
)
)
{
}
void Foam::regionModels::singleLayerRegion::constructMeshObjects()
{
// construct patch normal vectors
nHatPtr_.reset
(
new volVectorField
(
IOobject
(
"nHat",
time_.timeName(),
regionMesh(),
IOobject::READ_IF_PRESENT,
NO_WRITE
),
regionMesh(),
dimensionedVector("zero", dimless, vector::zero),
zeroGradientFvPatchField<vector>::typeName
)
);
// construct patch areas
magSfPtr_.reset
(
new volScalarField
(
IOobject
(
"magSf",
time_.timeName(),
regionMesh(),
IOobject::READ_IF_PRESENT,
NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimArea, 0.0),
zeroGradientFvPatchField<scalar>::typeName
)
);
}
forAll(intCoupledPatchIDs_, i)
{
if (intCoupledPatchIDs_[i] == regionPatchI)
{
const mappedPatchBase& mpb =
refCast<const mappedPatchBase>
(
regionMesh().boundaryMesh()[regionPatchI]
);
mpb.reverseDistribute(regionField);
return;
}
}
void reactingOneDim21::solveSpeciesMass()
{
if (debug)
{
Info<< "reactingOneDim21::solveSpeciesMass()" << endl;
}
volScalarField Yt(0.0*Ys_[0]);
for (label i=0; i<Ys_.size()-1; i++)
{
volScalarField& Yi = Ys_[i];
fvScalarMatrix YiEqn
(
fvm::ddt(rho_, Yi)
==
solidChemistry_->RRs(i)
);
if (regionMesh().moving())
{
surfaceScalarField phiYiRhoMesh
(
fvc::interpolate(Yi*rho_)*regionMesh().phi()
);
YiEqn += fvc::div(phiYiRhoMesh);
}
YiEqn.solve(regionMesh().solver("Yi"));
Yi.max(0.0);
Yt += Yi;
}
Ys_[Ys_.size() - 1] = 1.0 - Yt;
}
Foam::wordList
Foam::regionModels::singleLayerRegion::mappedFieldAndInternalPatchTypes() const
{
wordList bTypes(regionMesh().boundaryMesh().size());
bTypes = zeroGradientFvPatchField<Type>::typeName;
forAll(intCoupledPatchIDs_, i)
{
const label patchI = intCoupledPatchIDs_[i];
bTypes[patchI] = mappedFixedInternalValueFvPatchField<Type>::typeName;
}
return bTypes;
}
void reactingOneDimRPvol2::updateMesh(const scalarField& mass0)
{
if (!moveMesh_)
{
return;
}
const scalarField newV(mass0/rho_);
Info<< "Initial/final volumes = " << gSum(regionMesh().V()) << ", "
<< gSum(newV) << " [m3]" << endl;
// move the mesh
const labelList moveMap = moveMesh(regionMesh().V() - newV, minimumDelta_);
// flag any cells that have not moved as non-reacting
forAll(moveMap, i)
{
if (moveMap[i] == 0)
{
solidChemistry_->setCellReacting(i, false);
}
}
}
void Foam::regionModels::regionModel1D::initialise()
{
if (debug)
{
Pout<< "regionModel1D::initialise()" << endl;
}
// Calculate boundaryFaceFaces and boundaryFaceCells
DynamicList<label> faceIDs;
DynamicList<label> cellIDs;
label localPyrolysisFaceI = 0;
const polyBoundaryMesh& rbm = regionMesh().boundaryMesh();
forAll(intCoupledPatchIDs_, i)
{
const label patchI = intCoupledPatchIDs_[i];
const polyPatch& ppCoupled = rbm[patchI];
forAll(ppCoupled, localFaceI)
{
label faceI = ppCoupled.start() + localFaceI;
label cellI = -1;
label nFaces = 0;
label nCells = 0;
do
{
label ownCellI = regionMesh().faceOwner()[faceI];
if (ownCellI != cellI)
{
cellI = ownCellI;
}
else
{
cellI = regionMesh().faceNeighbour()[faceI];
}
nCells++;
cellIDs.append(cellI);
const cell& cFaces = regionMesh().cells()[cellI];
faceI = cFaces.opposingFaceLabel(faceI, regionMesh().faces());
faceIDs.append(faceI);
nFaces++;
} while (regionMesh().isInternalFace(faceI));
boundaryFaceOppositeFace_[localPyrolysisFaceI] = faceI;
faceIDs.remove(); //remove boundary face.
nFaces--;
boundaryFaceFaces_[localPyrolysisFaceI].transfer(faceIDs);
boundaryFaceCells_[localPyrolysisFaceI].transfer(cellIDs);
localPyrolysisFaceI++;
nLayers_ = nCells;
}
}
void kinematicSingleLayer::updateSurfaceVelocities()
{
// Push boundary film velocity values into internal field
for (label i=0; i<intCoupledPatchIDs_.size(); i++)
{
label patchi = intCoupledPatchIDs_[i];
const polyPatch& pp = regionMesh().boundaryMesh()[patchi];
UIndirectList<vector>(Uw_, pp.faceCells()) =
U_.boundaryField()[patchi];
}
Uw_ -= nHat()*(Uw_ & nHat());
Uw_.correctBoundaryConditions();
Us_ = turbulence_->Us();
}
void reactingOneDim::solveEnergy()
{
if (debug)
{
Info<< "reactingOneDim::solveEnergy()" << endl;
}
const volScalarField rhoCp(rho_*solidThermo_.Cp());
const surfaceScalarField phiQr(fvc::interpolate(Qr_)*nMagSf());
const surfaceScalarField phiGas(fvc::interpolate(phiHsGas_));
fvScalarMatrix TEqn
(
fvm::ddt(rhoCp, T_)
- fvm::laplacian(K_, T_)
==
chemistrySh_
+ fvc::div(phiQr)
+ fvc::div(phiGas)
);
if (moveMesh_)
{
surfaceScalarField phiMesh
(
fvc::interpolate(rhoCp*T_)*regionMesh().phi()
);
TEqn -= fvc::div(phiMesh);
}
TEqn.relax();
TEqn.solve();
Info<< "pyrolysis min/max(T) = " << min(T_).value() << ", "
<< max(T_).value() << endl;
}
reactingOneDim21::reactingOneDim21
(
const word& modelType,
const fvMesh& mesh,
const dictionary& dict,
const word& regionType
)
:
pyrolysisModel(modelType, mesh, dict, regionType),
solidChemistry_(basicSolidChemistryModel::New(regionMesh())),
solidThermo_(solidChemistry_->solidThermo()),
radiation_(radiation::radiationModel::New(solidThermo_.T())),
rho_
(
IOobject
(
"rho",
regionMesh().time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
solidThermo_.rho()
),
Ys_(solidThermo_.composition().Y()),
h_(solidThermo_.he()),
nNonOrthCorr_(-1),
maxDiff_(10),
minimumDelta_(1e-4),
phiGas_
(
IOobject
(
"phiGas",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimMass/dimTime, 0.0)
),
phiHsGas_
(
IOobject
(
"phiHsGas",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimEnergy/dimTime, 0.0)
),
chemistrySh_
(
IOobject
(
"chemistrySh",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimEnergy/dimTime/dimVolume, 0.0)
),
emmBnd_
(
IOobject
(
"emmBnd",
time().timeName(),
regionMesh(),
//IOobject::NO_READ,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
radiation_->absorptionEmission().e()()
//regionMesh(),
//dimensionedScalar("zero", dimless/dimLength, 0.0)
//dimensionedScalar("zero", dimless, 0.0)
),
absBnd_
(
IOobject
(
"absBnd",
time().timeName(),
regionMesh(),
//IOobject::NO_READ,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
emmBnd_
//regionMesh(),
//dimensionedScalar("zero", dimless/dimLength, 0.0)
//dimensionedScalar("zero", dimless, 0.0)
),
Qr_
(
IOobject
(
"Qr",
time().timeName(),
regionMesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
regionMesh()
),
lostSolidMass_(dimensionedScalar("zero", dimMass, 0.0)),
addedGasMass_(dimensionedScalar("zero", dimMass, 0.0)),
totalGasMassFlux_(0.0),
totalHeatRR_(dimensionedScalar("zero", dimEnergy/dimTime, 0.0)),
gasHSource_(false),
QrHSource_(false),
useChemistrySolvers_(true)
{
if (active_)
{
read(dict);
}
}
void Foam::regionModels::regionModel::initialise()
{
if (debug)
{
Pout<< "regionModel::initialise()" << endl;
}
label nBoundaryFaces = 0;
DynamicList<label> primaryPatchIDs;
DynamicList<label> intCoupledPatchIDs;
const polyBoundaryMesh& rbm = regionMesh().boundaryMesh();
const polyBoundaryMesh& pbm = primaryMesh().boundaryMesh();
mappedPatches_.setSize(rbm.size());
forAll(rbm, patchI)
{
const polyPatch& regionPatch = rbm[patchI];
if (isA<directMappedWallPolyPatch>(regionPatch))
{
if (debug)
{
Pout<< "found " << directMappedWallPolyPatch::typeName
<< " " << regionPatch.name() << endl;
}
intCoupledPatchIDs.append(patchI);
nBoundaryFaces += regionPatch.faceCells().size();
const directMappedWallPolyPatch& dmp =
refCast<const directMappedWallPolyPatch>(regionPatch);
const label primaryPatchI = dmp.samplePolyPatch().index();
primaryPatchIDs.append(primaryPatchI);
mappedPatches_.set
(
patchI,
new directMappedPatchBase
(
pbm[primaryPatchI],
regionMesh().name(),
directMappedPatchBase::NEARESTPATCHFACE,
regionPatch.name(),
vector::zero
)
);
}
}
primaryPatchIDs_.transfer(primaryPatchIDs);
intCoupledPatchIDs_.transfer(intCoupledPatchIDs);
// mappedPatches_.resize(nCoupledPatches);
if (nBoundaryFaces == 0)
{
WarningIn("regionModel::initialise()")
<< "Region model being applied without direct mapped boundary "
<< "conditions" << endl;
}
}
reactingOneDim::reactingOneDim
(
const word& modelType,
const fvMesh& mesh,
const dictionary& dict
)
:
pyrolysisModel(modelType, mesh, dict),
solidChemistry_(solidChemistryModel::New(regionMesh())),
solidThermo_(solidChemistry_->solidThermo()),
kappa_(solidThermo_.kappa()),
K_(solidThermo_.K()),
rho_(solidThermo_.rho()),
Ys_(solidThermo_.composition().Y()),
T_(solidThermo_.T()),
primaryRadFluxName_(dict.lookupOrDefault<word>("radFluxName", "Qr")),
nNonOrthCorr_(-1),
maxDiff_(10),
minimumDelta_(1e-4),
phiGas_
(
IOobject
(
"phiGas",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimMass/dimTime, 0.0)
),
phiHsGas_
(
IOobject
(
"phiHsGas",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimEnergy/dimTime, 0.0)
),
chemistrySh_
(
IOobject
(
"chemistrySh",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimEnergy/dimTime/dimVolume, 0.0)
),
QrCoupled_
(
IOobject
(
primaryRadFluxName_,
time().timeName(),
regionMesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
regionMesh()
),
Qr_
(
IOobject
(
"QrPyr",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimEnergy/dimArea/dimTime, 0.0),
zeroGradientFvPatchVectorField::typeName
),
lostSolidMass_(dimensionedScalar("zero", dimMass, 0.0)),
addedGasMass_(dimensionedScalar("zero", dimMass, 0.0)),
totalGasMassFlux_(0.0),
totalHeatRR_(dimensionedScalar("zero", dimEnergy/dimTime, 0.0))
{
if (active_)
{
read(dict);
}
}
kinematicSingleLayer::kinematicSingleLayer
(
const word& modelType,
const fvMesh& mesh,
const dimensionedVector& g,
const word& regionType,
const bool readFields
)
:
surfaceFilmModel(modelType, mesh, g, regionType),
momentumPredictor_(solution().subDict("PISO").lookup("momentumPredictor")),
nOuterCorr_(solution().subDict("PISO").lookupOrDefault("nOuterCorr", 1)),
nCorr_(readLabel(solution().subDict("PISO").lookup("nCorr"))),
nNonOrthCorr_
(
readLabel(solution().subDict("PISO").lookup("nNonOrthCorr"))
),
cumulativeContErr_(0.0),
deltaSmall_("deltaSmall", dimLength, SMALL),
deltaCoLimit_(solution().lookupOrDefault("deltaCoLimit", 1e-4)),
rho_
(
IOobject
(
"rhof",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimDensity, 0.0),
zeroGradientFvPatchScalarField::typeName
),
mu_
(
IOobject
(
"muf",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimPressure*dimTime, 0.0),
zeroGradientFvPatchScalarField::typeName
),
sigma_
(
IOobject
(
"sigmaf",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimMass/sqr(dimTime), 0.0),
zeroGradientFvPatchScalarField::typeName
),
delta_
(
IOobject
(
"deltaf",
time().timeName(),
regionMesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
regionMesh()
),
alpha_
(
IOobject
(
"alpha",
time().timeName(),
regionMesh(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimless, 0.0),
zeroGradientFvPatchScalarField::typeName
),
U_
(
IOobject
(
"Uf",
time().timeName(),
regionMesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
regionMesh()
),
Us_
(
IOobject
(
"Usf",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
U_,
zeroGradientFvPatchScalarField::typeName
),
Uw_
(
IOobject
(
"Uwf",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
U_,
zeroGradientFvPatchScalarField::typeName
),
deltaRho_
(
IOobject
(
delta_.name() + "*" + rho_.name(),
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", delta_.dimensions()*rho_.dimensions(), 0.0),
zeroGradientFvPatchScalarField::typeName
),
phi_
(
IOobject
(
"phi",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
regionMesh(),
dimensionedScalar("0", dimLength*dimMass/dimTime, 0.0)
),
primaryMassTrans_
(
IOobject
(
"primaryMassTrans",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimMass, 0.0),
zeroGradientFvPatchScalarField::typeName
),
cloudMassTrans_
(
IOobject
(
"cloudMassTrans",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimMass, 0.0),
zeroGradientFvPatchScalarField::typeName
),
cloudDiameterTrans_
(
IOobject
(
"cloudDiameterTrans",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimLength, -1.0),
zeroGradientFvPatchScalarField::typeName
),
USp_
(
IOobject
(
"USpf",
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedVector
(
"zero", dimMass*dimVelocity/dimArea/dimTime, Zero
),
this->mappedPushedFieldPatchTypes<vector>()
),
pSp_
(
IOobject
(
"pSpf",
time_.timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimPressure, 0.0),
this->mappedPushedFieldPatchTypes<scalar>()
),
rhoSp_
(
IOobject
(
"rhoSpf",
time_.timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimMass/dimTime/dimArea, 0.0),
this->mappedPushedFieldPatchTypes<scalar>()
),
USpPrimary_
(
IOobject
(
USp_.name(), // must have same name as USp_ to enable mapping
time().timeName(),
primaryMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
primaryMesh(),
dimensionedVector("zero", USp_.dimensions(), Zero)
),
pSpPrimary_
(
IOobject
(
pSp_.name(), // must have same name as pSp_ to enable mapping
time().timeName(),
primaryMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
primaryMesh(),
dimensionedScalar("zero", pSp_.dimensions(), 0.0)
),
rhoSpPrimary_
(
IOobject
(
rhoSp_.name(), // must have same name as rhoSp_ to enable mapping
time().timeName(),
primaryMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
primaryMesh(),
dimensionedScalar("zero", rhoSp_.dimensions(), 0.0)
),
UPrimary_
(
IOobject
(
"U", // must have same name as U to enable mapping
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedVector("zero", dimVelocity, Zero),
this->mappedFieldAndInternalPatchTypes<vector>()
),
pPrimary_
(
IOobject
(
"p", // must have same name as p to enable mapping
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimPressure, 0.0),
this->mappedFieldAndInternalPatchTypes<scalar>()
),
rhoPrimary_
(
IOobject
(
"rho", // must have same name as rho to enable mapping
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimDensity, 0.0),
this->mappedFieldAndInternalPatchTypes<scalar>()
),
muPrimary_
(
IOobject
(
"thermo:mu", // must have same name as mu to enable mapping
time().timeName(),
regionMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimPressure*dimTime, 0.0),
this->mappedFieldAndInternalPatchTypes<scalar>()
),
filmThermo_(filmThermoModel::New(*this, coeffs_)),
availableMass_(regionMesh().nCells(), 0.0),
injection_(*this, coeffs_),
transfer_(*this, coeffs_),
turbulence_(filmTurbulenceModel::New(*this, coeffs_)),
forces_(*this, coeffs_),
addedMassTotal_(0.0)
{
if (readFields)
{
transferPrimaryRegionThermoFields();
correctAlpha();
correctThermoFields();
deltaRho_ == delta_*rho_;
surfaceScalarField phi0
(
IOobject
(
"phi",
time().timeName(),
regionMesh(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE,
false
),
fvc::flux(deltaRho_*U_)
);
phi_ == phi0;
}
}
void kinematicSingleLayer::solveThickness
(
const volScalarField& pu,
const volScalarField& pp,
const fvVectorMatrix& UEqn
)
{
if (debug)
{
InfoInFunction << endl;
}
volScalarField rUA(1.0/UEqn.A());
U_ = rUA*UEqn.H();
surfaceScalarField deltarUAf(fvc::interpolate(delta_*rUA));
surfaceScalarField rhof(fvc::interpolate(rho_));
surfaceScalarField phiAdd
(
"phiAdd",
regionMesh().magSf()
* (
fvc::snGrad(pu, "snGrad(p)")
+ fvc::snGrad(pp, "snGrad(p)")*fvc::interpolate(delta_)
)
- fvc::flux(rho_*gTan())
);
constrainFilmField(phiAdd, 0.0);
surfaceScalarField phid
(
"phid",
fvc::flux(U_*rho_) - deltarUAf*phiAdd*rhof
);
constrainFilmField(phid, 0.0);
surfaceScalarField ddrhorUAppf
(
"deltaCoeff",
fvc::interpolate(delta_)*deltarUAf*rhof*fvc::interpolate(pp)
);
regionMesh().setFluxRequired(delta_.name());
for (int nonOrth=0; nonOrth<=nNonOrthCorr_; nonOrth++)
{
// Film thickness equation
fvScalarMatrix deltaEqn
(
fvm::ddt(rho_, delta_)
+ fvm::div(phid, delta_)
- fvm::laplacian(ddrhorUAppf, delta_)
==
- rhoSp_
);
deltaEqn.solve();
if (nonOrth == nNonOrthCorr_)
{
phiAdd +=
fvc::interpolate(pp)
* fvc::snGrad(delta_)
* regionMesh().magSf();
phi_ == deltaEqn.flux();
}
}
// Bound film thickness by a minimum of zero
delta_.max(0.0);
// Update U field
U_ -= fvc::reconstruct(deltarUAf*phiAdd);
// Remove any patch-normal components of velocity
U_ -= nHat()*(nHat() & U_);
U_.correctBoundaryConditions();
// Continuity check
continuityCheck();
}
void Foam::regionModels::singleLayerRegion::initialise()
{
if (debug)
{
Pout<< "singleLayerRegion::initialise()" << endl;
}
label nBoundaryFaces = 0;
const polyBoundaryMesh& rbm = regionMesh().boundaryMesh();
volVectorField& nHat = nHatPtr_();
volScalarField& magSf = magSfPtr_();
forAll(intCoupledPatchIDs_, i)
{
const label patchI = intCoupledPatchIDs_[i];
const polyPatch& pp = rbm[patchI];
const labelList& fCells = pp.faceCells();
nBoundaryFaces += fCells.size();
UIndirectList<vector>(nHat, fCells) = pp.faceNormals();
UIndirectList<scalar>(magSf, fCells) = mag(pp.faceAreas());
}
nHat.correctBoundaryConditions();
magSf.correctBoundaryConditions();
if (nBoundaryFaces != regionMesh().nCells())
{
FatalErrorIn("singleLayerRegion::initialise()")
<< "Number of primary region coupled boundary faces not equal to "
<< "the number of cells in the local region" << nl << nl
<< "Number of cells = " << regionMesh().nCells() << nl
<< "Boundary faces = " << nBoundaryFaces << nl
<< abort(FatalError);
}
scalarField passiveMagSf(magSf.size(), 0.0);
passivePatchIDs_.setSize(intCoupledPatchIDs_.size(), -1);
forAll(intCoupledPatchIDs_, i)
{
const label patchI = intCoupledPatchIDs_[i];
const polyPatch& ppIntCoupled = rbm[patchI];
if (ppIntCoupled.size() > 0)
{
label cellId = rbm[patchI].faceCells()[0];
const cell& cFaces = regionMesh().cells()[cellId];
label faceI = ppIntCoupled.start();
label faceO = cFaces.opposingFaceLabel(faceI, regionMesh().faces());
label passivePatchI = rbm.whichPatch(faceO);
passivePatchIDs_[i] = passivePatchI;
const polyPatch& ppPassive = rbm[passivePatchI];
UIndirectList<scalar>(passiveMagSf, ppPassive.faceCells()) =
mag(ppPassive.faceAreas());
}
}
Pstream::listCombineGather(passivePatchIDs_, maxEqOp<label>());
Pstream::listCombineScatter(passivePatchIDs_);
magSf.field() = 0.5*(magSf + passiveMagSf);
magSf.correctBoundaryConditions();
}
