tmp<Field<Type1> >
PointPatchField<PatchField, Mesh, PointPatch, MatrixType, Type>::
patchInternalField
(
const Field<Type1>& iF
) const
{
// Check size
if (iF.size() != internalField().size())
{
FatalErrorIn
(
"tmp<Field<Type1> > PointPatchField<PatchField, PointPatch, "
"Type>::"
"patchInternalField(const Field<Type1>& iF) const"
) << "given internal field does not correspond to the mesh. "
<< "Field size: " << iF.size()
<< " mesh size: " << internalField().size()
<< abort(FatalError);
}
// get addressing
const labelList& meshPoints = patch().meshPoints();
tmp<Field<Type1> > tvalues(new Field<Type1>(meshPoints.size()));
Field<Type1>& values = tvalues();
forAll (meshPoints, pointI)
{
values[pointI] = iF[meshPoints[pointI]];
}
return tvalues;
}
void pointPatchField<Type>::addToInternalField
(
Field<Type1>& iF,
const Field<Type1>& pF,
const labelList& points
) const
{
// Check size
if (iF.size() != internalField().size())
{
FatalErrorInFunction
<< "given internal field does not correspond to the mesh. "
<< "Field size: " << iF.size()
<< " mesh size: " << internalField().size()
<< abort(FatalError);
}
if (pF.size() != size())
{
FatalErrorInFunction
<< "given patch field does not correspond to the mesh. "
<< "Field size: " << pF.size()
<< " mesh size: " << size()
<< abort(FatalError);
}
// Get the addressing
const labelList& mp = patch().meshPoints();
forAll(points, i)
{
label pointI = points[i];
iF[mp[pointI]] += pF[pointI];
}
void Foam::porousBafflePressureFvPatchField::updateCoeffs()
{
if (updated())
{
return;
}
const surfaceScalarField& phi =
db().lookupObject<surfaceScalarField>(phiName_);
const fvsPatchField<scalar>& phip =
patch().patchField<surfaceScalarField, scalar>(phi);
scalarField Un(phip/patch().magSf());
if (phi.dimensions() == dimDensity*dimVelocity*dimArea)
{
Un /= patch().lookupPatchField<volScalarField, scalar>(rhoName_);
}
scalarField magUn(mag(Un));
const turbulenceModel& turbModel = db().lookupObject<turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
internalField().group()
)
);
jump_ =
-sign(Un)
*(
D_*turbModel.nu(patch().index())
+ I_*0.5*magUn
)*magUn*length_;
if (internalField().dimensions() == dimPressure)
{
jump_ *= patch().lookupPatchField<volScalarField, scalar>(rhoName_);
}
if (debug)
{
scalar avePressureJump = gAverage(jump_);
scalar aveVelocity = gAverage(mag(Un));
Info<< patch().boundaryMesh().mesh().name() << ':'
<< patch().name() << ':'
<< " Average pressure drop :" << avePressureJump
<< " Average velocity :" << aveVelocity
<< endl;
}
fixedJumpFvPatchField<scalar>::updateCoeffs();
}
void Foam::fanPressureFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
// Retrieve flux field
const surfaceScalarField& phi =
db().lookupObject<surfaceScalarField>(phiName());
const fvsPatchField<scalar>& phip =
patch().patchField<surfaceScalarField, scalar>(phi);
int dir = 2*direction_ - 1;
// Average volumetric flow rate
scalar volFlowRate = 0;
if (phi.dimensions() == dimVelocity*dimArea)
{
volFlowRate = dir*gSum(phip);
}
else if (phi.dimensions() == dimVelocity*dimArea*dimDensity)
{
const scalarField& rhop =
patch().lookupPatchField<volScalarField, scalar>(rhoName());
volFlowRate = dir*gSum(phip/rhop);
}
else
{
FatalErrorInFunction
<< "dimensions of phi are not correct"
<< "\n on patch " << patch().name()
<< " of field " << internalField().name()
<< " in file " << internalField().objectPath() << nl
<< exit(FatalError);
}
// Pressure drop for this flow rate
const scalar pdFan = fanCurve_(max(volFlowRate, 0.0));
totalPressureFvPatchScalarField::updateCoeffs
(
p0() - dir*pdFan,
patch().lookupPatchField<volVectorField, vector>(UName())
);
}
bool PointPatchField<PatchField, Mesh, PointPatch, MatrixType, Type>::
isPointField() const
{
return
internalField().size()
== patch().boundaryMesh().mesh().nPoints();
}
void turbulentMixingLengthDissipationRateInletFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
// Lookup Cmu corresponding to the turbulence model selected
const turbulenceModel& turbModel = db().lookupObject<turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
internalField().group()
)
);
const scalar Cmu =
turbModel.coeffDict().lookupOrDefault<scalar>("Cmu", 0.09);
const scalar Cmu75 = pow(Cmu, 0.75);
const fvPatchScalarField& kp =
patch().lookupPatchField<volScalarField, scalar>(kName_);
const fvsPatchScalarField& phip =
patch().lookupPatchField<surfaceScalarField, scalar>(this->phiName_);
this->refValue() = Cmu75*kp*sqrt(kp)/mixingLength_;
this->valueFraction() = 1.0 - pos0(phip);
inletOutletFvPatchScalarField::updateCoeffs();
}
Foam::tmp<Foam::DimensionedField<Type, Foam::volMesh>>
Foam::fvFieldReconstructor::reconstructFvVolumeInternalField
(
const IOobject& fieldIoObject,
const PtrList<DimensionedField<Type, volMesh>>& procFields
) const
{
// Create the internalField
Field<Type> internalField(mesh_.nCells());
forAll(procMeshes_, proci)
{
const DimensionedField<Type, volMesh>& procField = procFields[proci];
// Set the cell values in the reconstructed field
internalField.rmap
(
procField.field(),
cellProcAddressing_[proci]
);
}
return tmp<DimensionedField<Type, volMesh>>
(
new DimensionedField<Type, volMesh>
(
fieldIoObject,
mesh_,
procFields[0].dimensions(),
internalField
)
);
}
tmp<Field<Type1> > pointPatchField<Type>::patchInternalField
(
const Field<Type1>& iF,
const labelList& meshPoints
) const
{
// Check size
if (iF.size() != internalField().size())
{
FatalErrorInFunction
<< "given internal field does not correspond to the mesh. "
<< "Field size: " << iF.size()
<< " mesh size: " << internalField().size()
<< abort(FatalError);
}
return tmp<Field<Type1> >(new Field<Type1>(iF, meshPoints));
}
void PointPatchField<PatchField, Mesh, PointPatch, MatrixType, Type>::
setInInternalField
(
Field<Type1>& iF,
const Field<Type1>& pF
) const
{
// Check size
if (iF.size() != internalField().size())
{
FatalErrorIn
(
"void PointPatchField<PatchField, Mesh, PointPatch, "
"MatrixType, Type>::setInInternalField("
"Field<Type1>& iF, const Field<Type1>& iF) const"
) << "given internal field does not correspond to the mesh. "
<< "Field size: " << iF.size()
<< " mesh size: " << internalField().size()
<< abort(FatalError);
}
if (pF.size() != size())
{
FatalErrorIn
(
"void PointPatchField<PatchField, Mesh, PointPatch, "
"MatrixType, Type>::setInInternalField("
"Field<Type1>& iF, const Field<Type1>& iF) const"
) << "given patch field does not correspond to the mesh. "
<< "Field size: " << pF.size()
<< " mesh size: " << size()
<< abort(FatalError);
}
// Get the addressing
const labelList& mp = patch().meshPoints();
forAll (mp, pointI)
{
iF[mp[pointI]] = pF[pointI];
}
}
void Foam::movingWallVelocityFvPatchVectorField::updateCoeffs()
{
if (updated())
{
return;
}
const fvMesh& mesh = internalField().mesh();
if (mesh.moving())
{
const fvPatch& p = patch();
const polyPatch& pp = p.patch();
const pointField& oldPoints = mesh.oldPoints();
vectorField oldFc(pp.size());
forAll(oldFc, i)
{
oldFc[i] = pp[i].centre(oldPoints);
}
const scalar deltaT = mesh.time().deltaTValue();
const vectorField Up((pp.faceCentres() - oldFc)/deltaT);
const volVectorField& U =
static_cast<const volVectorField&>(internalField());
scalarField phip
(
p.patchField<surfaceScalarField, scalar>(fvc::meshPhi(U))
);
const vectorField n(p.nf());
const scalarField& magSf = p.magSf();
tmp<scalarField> Un = phip/(magSf + vSmall);
vectorField::operator=(Up + n*(Un - (n & Up)));
}
void kLowReWallFunctionFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
const label patchi = patch().index();
const turbulenceModel& turbModel = db().lookupObject<turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
internalField().group()
)
);
const scalarField& y = turbModel.y()[patchi];
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const tmp<scalarField> tnuw = turbModel.nu(patchi);
const scalarField& nuw = tnuw();
const scalar Cmu25 = pow025(Cmu_);
scalarField& kw = *this;
// Set k wall values
forAll(kw, facei)
{
label celli = patch().faceCells()[facei];
scalar uTau = Cmu25*sqrt(k[celli]);
scalar yPlus = uTau*y[facei]/nuw[facei];
if (yPlus > yPlusLam_)
{
scalar Ck = -0.416;
scalar Bk = 8.366;
kw[facei] = Ck/kappa_*log(yPlus) + Bk;
}
else
{
scalar C = 11.0;
scalar Cf = (1.0/sqr(yPlus + C) + 2.0*yPlus/pow3(C) - 1.0/sqr(C));
kw[facei] = 2400.0/sqr(Ceps2_)*Cf;
}
kw[facei] *= sqr(uTau);
}
bool alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::
activePhasePair(const phasePairKey& phasePair) const
{
if (phasePair == phasePairKey(vaporPhaseName_, internalField().group()))
{
return true;
}
else
{
return false;
}
}
void v2WallFunctionFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
const label patchi = patch().index();
const turbulenceModel& turbModel = db().lookupObject<turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
internalField().group()
)
);
const scalarField& y = turbModel.y()[patchi];
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const tmp<scalarField> tnuw = turbModel.nu(patchi);
const scalarField& nuw = tnuw();
const scalar Cmu25 = pow025(Cmu_);
scalarField& v2 = *this;
// Set v2 wall values
forAll(v2, facei)
{
label celli = patch().faceCells()[facei];
scalar uTau = Cmu25*sqrt(k[celli]);
scalar yPlus = uTau*y[facei]/nuw[facei];
if (yPlus > yPlusLam_)
{
scalar Cv2 = 0.193;
scalar Bv2 = -0.94;
v2[facei] = Cv2/kappa_*log(yPlus) + Bv2;
}
else
{
scalar Cv2 = 0.193;
v2[facei] = Cv2*pow4(yPlus);
}
v2[facei] *= sqr(uTau);
}
void Foam::totalFlowRateAdvectiveDiffusiveFvPatchScalarField::updateCoeffs()
{
if (this->updated())
{
return;
}
const label patchi = patch().index();
const compressible::turbulenceModel& turbModel =
db().lookupObject<compressible::turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
internalField().group()
)
);
const fvsPatchField<scalar>& phip =
patch().lookupPatchField<surfaceScalarField, scalar>(phiName_);
const scalarField alphap(turbModel.alphaEff(patchi));
refValue() = massFluxFraction_;
refGrad() = 0.0;
valueFraction() =
1.0
/
(
1.0 +
alphap*patch().deltaCoeffs()*patch().magSf()/max(mag(phip), small)
);
mixedFvPatchField<scalar>::updateCoeffs();
if (debug)
{
scalar phi = gSum(-phip*(*this));
Info<< patch().boundaryMesh().mesh().name() << ':'
<< patch().name() << ':'
<< this->internalField().name() << " :"
<< " mass flux[Kg/s]:" << phi
<< endl;
}
}
tmp<scalarField> nutUSpaldingWallFunctionFvPatchScalarField::yPlus() const
{
const label patchi = patch().index();
const turbulenceModel& turbModel = db().lookupObject<turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
internalField().group()
)
);
const scalarField& y = turbModel.y()[patchi];
const fvPatchVectorField& Uw = turbModel.U().boundaryField()[patchi];
const tmp<scalarField> tnuw = turbModel.nu(patchi);
const scalarField& nuw = tnuw();
return y*calcUTau(mag(Uw.snGrad()))/nuw;
}
tmp<GeometricField<Type, tetPolyPatchField, tetPointMesh> >
tetPointFieldDecomposer::decomposeField
(
const GeometricField<Type, tetPolyPatchField, tetPointMesh>& field
) const
{
// Create and map the internal field values
Field<Type> internalField(field.internalField(), directAddressing());
// Create and map the patch field values
PtrList<tetPolyPatchField<Type> > patchFields
(
boundaryAddressing_.size() + 1
);
forAll (boundaryAddressing_, patchI)
{
if (boundaryAddressing_[patchI] >= 0)
{
patchFields.set
(
patchI,
tetPolyPatchField<Type>::New
(
field.boundaryField()
[boundaryAddressing_[patchI]],
processorMesh_.boundary()[patchI],
DimensionedField<Type, tetPointMesh>::null(),
*patchFieldDecompPtrs_[patchI]
)
);
}
else
{
patchFields.set
(
patchI,
new ProcessorPointPatchField
<
tetPolyPatchField,
tetPointMesh,
tetPolyPatch,
processorTetPolyPatch,
tetFemMatrix,
Type
>
(
processorMesh_.boundary()[patchI],
DimensionedField<Type, tetPointMesh>::null()
)
);
}
}
// Add the global patch by hand. This needs to be present on
// all processors
patchFields.set
(
patchFields.size() - 1,
new GlobalPointPatchField
<
tetPolyPatchField,
tetPointMesh,
tetPolyPatch,
globalTetPolyPatch,
tetFemMatrix,
Type
>
(
processorMesh_.boundary().globalPatch(),
DimensionedField<Type, tetPointMesh>::null()
)
);
// Create the field for the processor
return tmp<GeometricField<Type, tetPolyPatchField, tetPointMesh> >
(
new GeometricField<Type, tetPolyPatchField, tetPointMesh>
(
IOobject
(
field.name(),
processorMesh_().time().timeName(),
processorMesh_(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
processorMesh_,
field.dimensions(),
internalField,
patchFields
)
);
}
{
label celli = faceCells[i];
weights[celli]++;
}
}
}
cornerWeights_.setSize(bf.size());
forAll(omegaPatches, i)
{
label patchi = omegaPatches[i];
const fvPatchScalarField& wf = weights.boundaryField()[patchi];
cornerWeights_[patchi] = 1.0/wf.patchInternalField();
}
G_.setSize(internalField().size(), 0.0);
omega_.setSize(internalField().size(), 0.0);
initialised_ = true;
}
omegaWallFunctionFvPatchScalarField&
omegaWallFunctionFvPatchScalarField::omegaPatch(const label patchi)
{
const volScalarField& omega =
static_cast<const volScalarField&>(this->internalField());
const volScalarField::Boundary& bf = omega.boundaryField();
const omegaWallFunctionFvPatchScalarField& opf =
void Foam::filmPyrolysisVelocityCoupledFvPatchVectorField::updateCoeffs()
{
if (updated())
{
return;
}
typedef regionModels::surfaceFilmModels::surfaceFilmModel filmModelType;
typedef regionModels::pyrolysisModels::pyrolysisModel pyrModelType;
// Since we're inside initEvaluate/evaluate there might be processor
// comms underway. Change the tag we use.
int oldTag = UPstream::msgType();
UPstream::msgType() = oldTag+1;
bool foundFilm = db().time().foundObject<filmModelType>(filmRegionName_);
bool foundPyrolysis =
db().time().foundObject<pyrModelType>(pyrolysisRegionName_);
if (!foundFilm || !foundPyrolysis)
{
// do nothing on construction - film model doesn't exist yet
return;
}
vectorField& Up = *this;
const label patchi = patch().index();
// Retrieve film model
const filmModelType& filmModel =
db().time().lookupObject<filmModelType>(filmRegionName_);
const label filmPatchi = filmModel.regionPatchID(patchi);
scalarField alphaFilm = filmModel.alpha().boundaryField()[filmPatchi];
filmModel.toPrimary(filmPatchi, alphaFilm);
vectorField UFilm = filmModel.Us().boundaryField()[filmPatchi];
filmModel.toPrimary(filmPatchi, UFilm);
// Retrieve pyrolysis model
const pyrModelType& pyrModel =
db().time().lookupObject<pyrModelType>(pyrolysisRegionName_);
const label pyrPatchi = pyrModel.regionPatchID(patchi);
scalarField phiPyr = pyrModel.phiGas().boundaryField()[pyrPatchi];
pyrModel.toPrimary(pyrPatchi, phiPyr);
const surfaceScalarField& phi =
db().lookupObject<surfaceScalarField>(phiName_);
if (phi.dimensions() == dimVelocity*dimArea)
{
// do nothing
}
else if (phi.dimensions() == dimDensity*dimVelocity*dimArea)
{
const fvPatchField<scalar>& rhop =
patch().lookupPatchField<volScalarField, scalar>(rhoName_);
phiPyr /= rhop;
}
else
{
FatalErrorInFunction
<< "Unable to process flux field phi with dimensions "
<< phi.dimensions() << nl
<< " on patch " << patch().name()
<< " of field " << internalField().name()
<< " in file " << internalField().objectPath()
<< exit(FatalError);
}
const scalarField UAvePyr(-phiPyr/patch().magSf());
const vectorField& nf = patch().nf();
// Evaluate velocity
Up = alphaFilm*UFilm + (1.0 - alphaFilm)*UAvePyr*nf;
// Restore tag
UPstream::msgType() = oldTag;
fixedValueFvPatchVectorField::updateCoeffs();
}
void Foam::externalCoupledTemperatureMixedFvPatchScalarField::transferData
(
OFstream& os
) const
{
if (log())
{
Info<< type() << ": " << this->patch().name()
<< ": writing data to " << os.name()
<< endl;
}
const label patchi = patch().index();
// heat flux [W/m2]
scalarField qDot(this->patch().size(), 0.0);
typedef compressible::turbulenceModel cmpTurbModelType;
static word turbName
(
IOobject::groupName
(
turbulenceModel::propertiesName,
internalField().group()
)
);
static word thermoName(basicThermo::dictName);
if (db().foundObject<cmpTurbModelType>(turbName))
{
const cmpTurbModelType& turbModel =
db().lookupObject<cmpTurbModelType>(turbName);
const basicThermo& thermo = turbModel.transport();
const fvPatchScalarField& hep = thermo.he().boundaryField()[patchi];
qDot = turbModel.alphaEff(patchi)*hep.snGrad();
}
else if (db().foundObject<basicThermo>(thermoName))
{
const basicThermo& thermo = db().lookupObject<basicThermo>(thermoName);
const fvPatchScalarField& hep = thermo.he().boundaryField()[patchi];
qDot = thermo.alpha().boundaryField()[patchi]*hep.snGrad();
}
else
{
FatalErrorInFunction
<< "Condition requires either compressible turbulence and/or "
<< "thermo model to be available" << exit(FatalError);
}
// patch temperature [K]
const scalarField Tp(*this);
// near wall cell temperature [K]
const scalarField Tc(patchInternalField());
// heat transfer coefficient [W/m2/K]
const scalarField htc(qDot/(Tp - Tc + ROOTVSMALL));
if (Pstream::parRun())
{
int tag = Pstream::msgType() + 1;
List<Field<scalar>> magSfs(Pstream::nProcs());
magSfs[Pstream::myProcNo()].setSize(this->patch().size());
magSfs[Pstream::myProcNo()] = this->patch().magSf();
Pstream::gatherList(magSfs, tag);
List<Field<scalar>> values(Pstream::nProcs());
values[Pstream::myProcNo()].setSize(this->patch().size());
values[Pstream::myProcNo()] = Tp;
Pstream::gatherList(values, tag);
List<Field<scalar>> qDots(Pstream::nProcs());
qDots[Pstream::myProcNo()].setSize(this->patch().size());
qDots[Pstream::myProcNo()] = qDot;
Pstream::gatherList(qDots, tag);
List<Field<scalar>> htcs(Pstream::nProcs());
htcs[Pstream::myProcNo()].setSize(this->patch().size());
htcs[Pstream::myProcNo()] = htc;
Pstream::gatherList(htcs, tag);
if (Pstream::master())
{
forAll(values, proci)
{
const Field<scalar>& magSf = magSfs[proci];
const Field<scalar>& value = values[proci];
const Field<scalar>& qDot = qDots[proci];
const Field<scalar>& htc = htcs[proci];
forAll(magSf, facei)
{
os << magSf[facei] << token::SPACE
<< value[facei] << token::SPACE
<< qDot[facei] << token::SPACE
<< htc[facei] << token::SPACE
<< nl;
}
}
os.flush();
}
}
void Foam::JohnsonJacksonParticleSlipFvPatchVectorField::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 fvPatchScalarField& gs0
(
patch().lookupPatchField<volScalarField, scalar>
(
IOobject::groupName("gs0", phased.name())
)
);
const scalarField nu
(
patch().lookupPatchField<volScalarField, scalar>
(
IOobject::groupName("nut", phased.name())
)
);
const scalarField nuFric
(
patch().lookupPatchField<volScalarField, scalar>
(
IOobject::groupName("nuFric", phased.name())
)
);
word ThetaName(IOobject::groupName("Theta", phased.name()));
const fvPatchScalarField& Theta
(
db().foundObject<volScalarField>(ThetaName)
? patch().lookupPatchField<volScalarField, scalar>(ThetaName)
: alpha
);
// 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 slip value fraction
scalarField c
(
constant::mathematical::pi
*alpha
*gs0
*specularityCoefficient_.value()
*sqrt(3.0*Theta)
/max(6.0*(nu - nuFric)*alphaMax.value(), SMALL)
);
this->valueFraction() = c/(c + patch().deltaCoeffs());
partialSlipFvPatchVectorField::updateCoeffs();
}
tmp<GeometricField<Type, fvPatchField, volMesh> > fvMeshSubset::interpolate
(
const GeometricField<Type, fvPatchField, volMesh>& vf,
const fvMesh& sMesh,
const labelList& patchMap,
const labelList& cellMap,
const labelList& faceMap
)
{
// Create and map the internal-field values
Field<Type> internalField(vf.internalField(), cellMap);
// Create and map the patch field values
PtrList<fvPatchField<Type> > patchFields(patchMap.size());
forAll (patchFields, patchI)
{
// Set the first one by hand as it corresponds to the
// exposed internal faces. Additional interpolation can be put here
// as necessary.
if (patchMap[patchI] == -1)
{
patchFields.set
(
patchI,
new emptyFvPatchField<Type>
(
sMesh.boundary()[patchI],
DimensionedField<Type, volMesh>::null()
)
);
}
else
{
// Construct addressing
const fvPatch& subPatch = sMesh.boundary()[patchI];
const fvPatch& basePatch = vf.mesh().boundary()[patchMap[patchI]];
label baseStart = basePatch.patch().start();
label baseSize = basePatch.size();
labelList directAddressing(subPatch.size());
forAll(directAddressing, i)
{
label baseFaceI = faceMap[subPatch.patch().start()+i];
if (baseFaceI >= baseStart && baseFaceI < baseStart+baseSize)
{
directAddressing[i] = baseFaceI-baseStart;
}
else
{
// Mapped from internal face. Do what? Map from element
// 0 for now.
directAddressing[i] = 0;
}
}
patchFields.set
(
patchI,
fvPatchField<Type>::New
(
vf.boundaryField()[patchMap[patchI]],
sMesh.boundary()[patchI],
DimensionedField<Type, volMesh>::null(),
patchFieldSubset(directAddressing)
)
);
// What to do with exposed internal faces if put into this patch?
}
}
Foam::tmp<Foam::GeometricField<Type, Foam::pointPatchField, Foam::pointMesh> >
Foam::pointFieldDecomposer::decomposeField
(
const GeometricField<Type, pointPatchField, pointMesh>& field
) const
{
// Create and map the internal field values
Field<Type> internalField(field.internalField(), pointAddressing_);
// Create a list of pointers for the patchFields
PtrList<pointPatchField<Type> > patchFields(boundaryAddressing_.size());
// Create and map the patch field values
forAll(boundaryAddressing_, patchi)
{
if (patchFieldDecomposerPtrs_[patchi])
{
patchFields.set
(
patchi,
pointPatchField<Type>::New
(
field.boundaryField()[boundaryAddressing_[patchi]],
procMesh_.boundary()[patchi],
DimensionedField<Type, pointMesh>::null(),
*patchFieldDecomposerPtrs_[patchi]
)
);
}
else
{
patchFields.set
(
patchi,
new processorPointPatchField<Type>
(
procMesh_.boundary()[patchi],
DimensionedField<Type, pointMesh>::null()
)
);
}
}
// Create the field for the processor
return tmp<GeometricField<Type, pointPatchField, pointMesh> >
(
new GeometricField<Type, pointPatchField, pointMesh>
(
IOobject
(
field.name(),
procMesh_().time().timeName(),
procMesh_(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
procMesh_,
field.dimensions(),
internalField,
patchFields
)
);
}
tmp<scalarField>
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::calcAlphat
(
const scalarField& prevAlphat
) const
{
// Lookup the fluid model
const phaseSystem& fluid =
db().lookupObject<phaseSystem>("phaseProperties");
const phaseModel& phase
(
fluid.phases()[internalField().group()]
);
const label patchi = patch().index();
// Retrieve turbulence properties from model
const phaseCompressibleTurbulenceModel& turbModel =
db().lookupObject<phaseCompressibleTurbulenceModel>
(
IOobject::groupName(turbulenceModel::propertiesName, phase.name())
);
const scalar Cmu25 = pow025(Cmu_);
const scalarField& y = turbModel.y()[patchi];
const tmp<scalarField> tmuw = turbModel.mu(patchi);
const scalarField& muw = tmuw();
const tmp<scalarField> talphaw = phase.thermo().alpha(patchi);
const scalarField& alphaw = talphaw();
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const fvPatchScalarField& kw = k.boundaryField()[patchi];
const fvPatchVectorField& Uw = turbModel.U().boundaryField()[patchi];
const scalarField magUp(mag(Uw.patchInternalField() - Uw));
const scalarField magGradUw(mag(Uw.snGrad()));
const fvPatchScalarField& rhow = turbModel.rho().boundaryField()[patchi];
const fvPatchScalarField& hew =
phase.thermo().he().boundaryField()[patchi];
const fvPatchScalarField& Tw =
phase.thermo().T().boundaryField()[patchi];
scalarField Tp(Tw.patchInternalField());
// Heat flux [W/m2] - lagging alphatw
const scalarField qDot
(
(prevAlphat + alphaw)*hew.snGrad()
);
scalarField uTau(Cmu25*sqrt(kw));
scalarField yPlus(uTau*y/(muw/rhow));
scalarField Pr(muw/alphaw);
// Molecular-to-turbulent Prandtl number ratio
scalarField Prat(Pr/Prt_);
// Thermal sublayer thickness
scalarField P(this->Psmooth(Prat));
scalarField yPlusTherm(this->yPlusTherm(P, Prat));
tmp<scalarField> talphatConv(new scalarField(this->size()));
scalarField& alphatConv = talphatConv.ref();
// Populate boundary values
forAll(alphatConv, facei)
{
// Evaluate new effective thermal diffusivity
scalar alphaEff = 0.0;
if (yPlus[facei] < yPlusTherm[facei])
{
scalar A = qDot[facei]*rhow[facei]*uTau[facei]*y[facei];
scalar B = qDot[facei]*Pr[facei]*yPlus[facei];
scalar C = Pr[facei]*0.5*rhow[facei]*uTau[facei]*sqr(magUp[facei]);
alphaEff = A/(B + C + vSmall);
}
else
{
scalar A = qDot[facei]*rhow[facei]*uTau[facei]*y[facei];
scalar B =
qDot[facei]*Prt_*(1.0/kappa_*log(E_*yPlus[facei]) + P[facei]);
scalar magUc =
uTau[facei]/kappa_*log(E_*yPlusTherm[facei]) - mag(Uw[facei]);
scalar C =
0.5*rhow[facei]*uTau[facei]
*(Prt_*sqr(magUp[facei]) + (Pr[facei] - Prt_)*sqr(magUc));
alphaEff = A/(B + C + vSmall);
}
// Update convective heat transfer turbulent thermal diffusivity
alphatConv[facei] = max(0.0, alphaEff - alphaw[facei]);
}
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::fanPressureFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
// Retrieve flux field
const surfaceScalarField& phi =
db().lookupObject<surfaceScalarField>(phiName());
const fvsPatchField<scalar>& phip =
patch().patchField<surfaceScalarField, scalar>(phi);
int dir = 2*direction_ - 1;
// Average volumetric flow rate
scalar volFlowRate = 0;
if (phi.dimensions() == dimVelocity*dimArea)
{
volFlowRate = dir*gSum(phip);
}
else if (phi.dimensions() == dimVelocity*dimArea*dimDensity)
{
const scalarField& rhop =
patch().lookupPatchField<volScalarField, scalar>(rhoName());
volFlowRate = dir*gSum(phip/rhop);
}
else
{
FatalErrorInFunction
<< "dimensions of phi are not correct"
<< "\n on patch " << patch().name()
<< " of field " << internalField().name()
<< " in file " << internalField().objectPath() << nl
<< exit(FatalError);
}
if (nonDimensional_)
{
// Create an non-dimensional flow rate
volFlowRate =
120.0*volFlowRate/pow3(constant::mathematical::pi)/pow3(dm_)/rpm_;
}
// Pressure drop for this flow rate
scalar pdFan = fanCurve_(max(volFlowRate, 0.0));
if (nonDimensional_)
{
// Convert the non-dimensional deltap from curve into deltaP
pdFan = pdFan*pow4(constant::mathematical::pi)*sqr(dm_*rpm_)/1800;
}
totalPressureFvPatchScalarField::updateCoeffs
(
p0() - dir*pdFan,
patch().lookupPatchField<volVectorField, vector>(UName())
);
}
void Foam::plenumPressureFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
// Patch properties
const fvPatchField<scalar>& p = *this;
const fvPatchField<scalar>& p_old =
db().lookupObject<volScalarField>
(
internalField().name()
).oldTime().boundaryField()[patch().index()];
const fvPatchField<vector>& U =
patch().lookupPatchField<volVectorField, vector>(UName_);
const fvsPatchField<scalar>& phi =
patch().lookupPatchField<surfaceScalarField, scalar>(phiName_);
// Get the timestep
const scalar dt = db().time().deltaTValue();
// Check if operating at a new time index and update the old-time properties
// if so
if (timeIndex_ != db().time().timeIndex())
{
timeIndex_ = db().time().timeIndex();
plenumDensityOld_ = plenumDensity_;
plenumTemperatureOld_ = plenumTemperature_;
}
// Calculate the current mass flow rate
scalar massFlowRate(1.0);
if (phi.internalField().dimensions() == dimVelocity*dimArea)
{
if (hasRho_)
{
massFlowRate = - gSum(rho_*phi);
}
else
{
FatalErrorInFunction
<< "The density must be specified when using a volumetric flux."
<< exit(FatalError);
}
}
else if
(
phi.internalField().dimensions()
== dimDensity*dimVelocity*dimArea
)
{
if (hasRho_)
{
FatalErrorInFunction
<< "The density must be not specified when using a mass flux."
<< exit(FatalError);
}
else
{
massFlowRate = - gSum(phi);
}
}
else
{
FatalErrorInFunction
<< "dimensions of phi are not correct"
<< "\n on patch " << patch().name()
<< " of field " << internalField().name()
<< " in file " << internalField().objectPath() << nl
<< exit(FatalError);
}
// Calcaulate the specific heats
const scalar cv = R_/(gamma_ - 1), cp = R_*gamma_/(gamma_ - 1);
// Calculate the new plenum properties
plenumDensity_ =
plenumDensityOld_
+ (dt/plenumVolume_)*(supplyMassFlowRate_ - massFlowRate);
plenumTemperature_ =
plenumTemperatureOld_
+ (dt/(plenumDensity_*cv*plenumVolume_))
* (
supplyMassFlowRate_
*(cp*supplyTotalTemperature_ - cv*plenumTemperature_)
- massFlowRate*R_*plenumTemperature_
);
const scalar plenumPressure = plenumDensity_*R_*plenumTemperature_;
// Squared velocity magnitude at exit of channels
const scalarField U_e(magSqr(U/inletAreaRatio_));
// Exit temperature to plenum temperature ratio
const scalarField r
(
1.0 - (gamma_ - 1.0)*U_e/(2.0*gamma_*R_*plenumTemperature_)
);
// Quadratic coefficient (others not needed as b = +1.0 and c = -1.0)
const scalarField a
(
(1.0 - r)/(r*r*inletDischargeCoefficient_*inletDischargeCoefficient_)
);
// Isentropic exit temperature to plenum temperature ratio
const scalarField s(2.0/(1.0 + sqrt(1.0 + 4.0*a)));
// Exit pressure to plenum pressure ratio
const scalarField t(pow(s, gamma_/(gamma_ - 1.0)));
// Limit to prevent outflow
const scalarField p_new
(
(1.0 - pos(phi))*t*plenumPressure + pos(phi)*max(p, plenumPressure)
);
// Relaxation fraction
const scalar oneByFraction = timeScale_/dt;
const scalar fraction = oneByFraction < 1.0 ? 1.0 : 1.0/oneByFraction;
// Set the new value
operator==((1.0 - fraction)*p_old + fraction*p_new);
fixedValueFvPatchScalarField::updateCoeffs();
}
tmp<GeomField>
coupledInfo<MeshType>::subSetField
(
const GeomField& f,
const ZeroType& zeroValue,
const labelList& internalMapper
) const
{
typedef typename GeomField::InternalField InternalField;
typedef typename GeomField::PatchFieldType PatchFieldType;
typedef typename GeomField::GeometricBoundaryField GeomBdyFieldType;
typedef typename GeomField::DimensionedInternalField DimInternalField;
// Create and map the internal-field values
InternalField internalField(f.internalField(), internalMapper);
// Create and map the patch field values
label nPatches = subMesh().boundary().size();
PtrList<PatchFieldType> patchFields(nPatches);
// Define patch type names, assumed to be
// common for volume and surface fields
word emptyType(emptyPolyPatch::typeName);
word processorType(processorPolyPatch::typeName);
// Create dummy types for initial field creation
forAll(patchFields, patchI)
{
if (patchI == (nPatches - 1))
{
// Artificially set last patch
patchFields.set
(
patchI,
PatchFieldType::New
(
emptyType,
subMesh().boundary()[patchI],
DimInternalField::null()
)
);
}
else
{
patchFields.set
(
patchI,
PatchFieldType::New
(
PatchFieldType::calculatedType(),
subMesh().boundary()[patchI],
DimInternalField::null()
)
);
}
}
// Create new field from pieces
tmp<GeomField> subFld
(
new GeomField
(
IOobject
(
"subField_" + f.name(),
subMesh().time().timeName(),
subMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
subMesh(),
f.dimensions(),
internalField,
patchFields
)
);
// Set correct references for patch internal fields,
// and map values from the supplied geometric field
GeomBdyFieldType& bf = subFld().boundaryField();
forAll(bf, patchI)
{
if (patchI == (nPatches - 1))
{
// Artificially set last patch
bf.set
(
patchI,
PatchFieldType::New
(
emptyType,
subMesh().boundary()[patchI],
subFld().dimensionedInternalField()
)
);
}
else
if (isA<processorPolyPatch>(subMesh().boundary()[patchI].patch()))
{
bf.set
(
patchI,
PatchFieldType::New
(
processorType,
subMesh().boundary()[patchI],
subFld().dimensionedInternalField()
)
);
// Avoid dealing with uninitialised values
// by artificially assigning to zero
bf[patchI] == zeroValue;
}
else
{
bf.set
(
patchI,
PatchFieldType::New
(
f.boundaryField()[patchI],
subMesh().boundary()[patchI],
subFld().dimensionedInternalField(),
subMeshMapper(*this, patchI)
)
);
}
}
return subFld;
}
forAll(faceCells, i)
{
weights[faceCells[i]]++;
}
}
}
cornerWeights_.setSize(bf.size());
forAll(epsilonPatches, i)
{
label patchi = epsilonPatches[i];
const fvPatchScalarField& wf = weights.boundaryField()[patchi];
cornerWeights_[patchi] = 1.0/wf.patchInternalField();
}
G_.setSize(internalField().size(), 0.0);
epsilon_.setSize(internalField().size(), 0.0);
initialised_ = true;
}
Foam::epsilonWallFunctionFvPatchScalarField&
Foam::epsilonWallFunctionFvPatchScalarField::epsilonPatch(const label patchi)
{
const volScalarField& epsilon =
static_cast<const volScalarField&>(this->internalField());
const volScalarField::Boundary& bf = epsilon.boundaryField();
const epsilonWallFunctionFvPatchScalarField& epf =
tmp<Field<Type> > pointPatchField<Type>::patchInternalField() const
{
return patchInternalField(internalField());
}
tmp<Field<Type> >
PointPatchField<PatchField, Mesh, PointPatch, MatrixType, Type>::
patchInternalField() const
{
return patchInternalField(internalField());
}
