boundaryField() -> boundaryFieldRef()
This commit is contained in:
@ -219,7 +219,7 @@ void LamBremhorstKE::correct()
|
||||
tgradU.clear();
|
||||
|
||||
// Update epsilon and G at the wall
|
||||
epsilon_.boundaryField().updateCoeffs();
|
||||
epsilon_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
const volScalarField Rt(this->Rt());
|
||||
const volScalarField fMu(this->fMu(Rt));
|
||||
@ -236,7 +236,7 @@ void LamBremhorstKE::correct()
|
||||
);
|
||||
|
||||
epsEqn.ref().relax();
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
bound(epsilon_, epsilonMin_);
|
||||
|
||||
|
||||
@ -388,7 +388,7 @@ void LienCubicKE::correct()
|
||||
|
||||
|
||||
// Update epsilon and G at the wall
|
||||
epsilon_.boundaryField().updateCoeffs();
|
||||
epsilon_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
const volScalarField f2(this->f2());
|
||||
|
||||
@ -405,7 +405,7 @@ void LienCubicKE::correct()
|
||||
);
|
||||
|
||||
epsEqn.ref().relax();
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
bound(epsilon_, epsilonMin_);
|
||||
|
||||
|
||||
@ -272,7 +272,7 @@ void LienLeschziner::correct()
|
||||
tgradU.clear();
|
||||
|
||||
// Update epsilon and G at the wall
|
||||
epsilon_.boundaryField().updateCoeffs();
|
||||
epsilon_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
const volScalarField f2(this->f2());
|
||||
|
||||
@ -289,7 +289,7 @@ void LienLeschziner::correct()
|
||||
);
|
||||
|
||||
epsEqn.ref().relax();
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
bound(epsilon_, epsilonMin_);
|
||||
|
||||
|
||||
@ -273,7 +273,7 @@ void ShihQuadraticKE::correct()
|
||||
|
||||
|
||||
// Update epsilon and G at the wall
|
||||
epsilon_.boundaryField().updateCoeffs();
|
||||
epsilon_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
// Dissipation equation
|
||||
tmp<fvScalarMatrix> epsEqn
|
||||
@ -287,7 +287,7 @@ void ShihQuadraticKE::correct()
|
||||
);
|
||||
|
||||
epsEqn.ref().relax();
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
bound(epsilon_, epsilonMin_);
|
||||
|
||||
|
||||
@ -677,7 +677,7 @@ void kkLOmega::correct()
|
||||
);
|
||||
|
||||
|
||||
omega_.boundaryField().updateCoeffs();
|
||||
omega_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
// Turbulence specific dissipation rate equation
|
||||
tmp<fvScalarMatrix> omegaEqn
|
||||
@ -699,7 +699,7 @@ void kkLOmega::correct()
|
||||
);
|
||||
|
||||
omegaEqn.ref().relax();
|
||||
omegaEqn.ref().boundaryManipulate(omega_.boundaryField());
|
||||
omegaEqn.ref().boundaryManipulate(omega_.boundaryFieldRef());
|
||||
|
||||
solve(omegaEqn);
|
||||
bound(omega_, omegaMin_);
|
||||
@ -719,7 +719,7 @@ void kkLOmega::correct()
|
||||
);
|
||||
|
||||
klEqn.ref().relax();
|
||||
klEqn.ref().boundaryManipulate(kl_.boundaryField());
|
||||
klEqn.ref().boundaryManipulate(kl_.boundaryFieldRef());
|
||||
|
||||
solve(klEqn);
|
||||
bound(kl_, kMin_);
|
||||
@ -740,7 +740,7 @@ void kkLOmega::correct()
|
||||
);
|
||||
|
||||
ktEqn.ref().relax();
|
||||
ktEqn.ref().boundaryManipulate(kt_.boundaryField());
|
||||
ktEqn.ref().boundaryManipulate(kt_.boundaryFieldRef());
|
||||
|
||||
solve(ktEqn);
|
||||
bound(kt_, kMin_);
|
||||
|
||||
@ -612,8 +612,8 @@ void mixtureKEpsilon<BasicTurbulenceModel>::correct()
|
||||
tgradUl.clear();
|
||||
|
||||
// Update k, epsilon and G at the wall
|
||||
kl.boundaryField().updateCoeffs();
|
||||
epsilonl.boundaryField().updateCoeffs();
|
||||
kl.boundaryFieldRef().updateCoeffs();
|
||||
epsilonl.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
Gc.ref().checkOut();
|
||||
}
|
||||
@ -632,8 +632,8 @@ void mixtureKEpsilon<BasicTurbulenceModel>::correct()
|
||||
tgradUg.clear();
|
||||
|
||||
// Update k, epsilon and G at the wall
|
||||
kg.boundaryField().updateCoeffs();
|
||||
epsilong.boundaryField().updateCoeffs();
|
||||
kg.boundaryFieldRef().updateCoeffs();
|
||||
epsilong.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
Gd.ref().checkOut();
|
||||
}
|
||||
@ -667,7 +667,7 @@ void mixtureKEpsilon<BasicTurbulenceModel>::correct()
|
||||
|
||||
epsEqn.ref().relax();
|
||||
fvOptions.constrain(epsEqn.ref());
|
||||
epsEqn.ref().boundaryManipulate(epsilonm.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilonm.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
fvOptions.correct(epsilonm);
|
||||
bound(epsilonm, this->epsilonMin_);
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
|
||||
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
@ -64,6 +64,8 @@ void Foam::LESModels::vanDriestDelta::calcDelta()
|
||||
);
|
||||
|
||||
const fvPatchList& patches = mesh.boundary();
|
||||
volScalarField::GeometricBoundaryField& ystarBf = ystar.boundaryFieldRef();
|
||||
|
||||
forAll(patches, patchi)
|
||||
{
|
||||
if (isA<wallFvPatch>(patches[patchi]))
|
||||
@ -72,7 +74,7 @@ void Foam::LESModels::vanDriestDelta::calcDelta()
|
||||
const scalarField& nuw = nu.boundaryField()[patchi];
|
||||
const scalarField& nuSgsw = nuSgs().boundaryField()[patchi];
|
||||
|
||||
ystar.boundaryField()[patchi] =
|
||||
ystarBf[patchi] =
|
||||
nuw/sqrt((nuw + nuSgsw)*mag(Uw.snGrad()) + VSMALL);
|
||||
}
|
||||
}
|
||||
|
||||
@ -56,7 +56,7 @@ tmp<volScalarField> SpalartAllmarasDDES<BasicTurbulenceModel>::rd
|
||||
scalar(10)
|
||||
)
|
||||
);
|
||||
tr.ref().boundaryField() == 0.0;
|
||||
tr.ref().boundaryFieldRef() == 0.0;
|
||||
|
||||
return tr;
|
||||
}
|
||||
|
||||
@ -129,7 +129,7 @@ tmp<volScalarField> SpalartAllmarasDES<BasicTurbulenceModel>::r
|
||||
scalar(10)
|
||||
)
|
||||
);
|
||||
tr.ref().boundaryField() == 0.0;
|
||||
tr.ref().boundaryFieldRef() == 0.0;
|
||||
|
||||
return tr;
|
||||
}
|
||||
|
||||
@ -293,7 +293,7 @@ void LRR<BasicTurbulenceModel>::correct()
|
||||
volScalarField G(this->GName(), 0.5*mag(tr(P)));
|
||||
|
||||
// Update epsilon and G at the wall
|
||||
epsilon_.boundaryField().updateCoeffs();
|
||||
epsilon_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
// Dissipation equation
|
||||
tmp<fvScalarMatrix> epsEqn
|
||||
@ -309,7 +309,7 @@ void LRR<BasicTurbulenceModel>::correct()
|
||||
|
||||
epsEqn.ref().relax();
|
||||
fvOptions.constrain(epsEqn.ref());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
fvOptions.correct(epsilon_);
|
||||
bound(epsilon_, this->epsilonMin_);
|
||||
|
||||
@ -282,7 +282,7 @@ void LaunderSharmaKE<BasicTurbulenceModel>::correct()
|
||||
|
||||
epsEqn.ref().relax();
|
||||
fvOptions.constrain(epsEqn.ref());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
fvOptions.correct(epsilon_);
|
||||
bound(epsilon_, this->epsilonMin_);
|
||||
|
||||
@ -272,7 +272,7 @@ void RNGkEpsilon<BasicTurbulenceModel>::correct()
|
||||
);
|
||||
|
||||
// Update epsilon and G at the wall
|
||||
epsilon_.boundaryField().updateCoeffs();
|
||||
epsilon_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
// Dissipation equation
|
||||
tmp<fvScalarMatrix> epsEqn
|
||||
@ -290,7 +290,7 @@ void RNGkEpsilon<BasicTurbulenceModel>::correct()
|
||||
|
||||
epsEqn.ref().relax();
|
||||
fvOptions.constrain(epsEqn.ref());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
fvOptions.correct(epsilon_);
|
||||
bound(epsilon_, this->epsilonMin_);
|
||||
|
||||
@ -303,7 +303,7 @@ void SSG<BasicTurbulenceModel>::correct()
|
||||
volScalarField G(this->GName(), 0.5*mag(tr(P)));
|
||||
|
||||
// Update epsilon and G at the wall
|
||||
epsilon_.boundaryField().updateCoeffs();
|
||||
epsilon_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
// Dissipation equation
|
||||
tmp<fvScalarMatrix> epsEqn
|
||||
@ -319,7 +319,7 @@ void SSG<BasicTurbulenceModel>::correct()
|
||||
|
||||
epsEqn.ref().relax();
|
||||
fvOptions.constrain(epsEqn.ref());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
fvOptions.correct(epsilon_);
|
||||
bound(epsilon_, this->epsilonMin_);
|
||||
|
||||
@ -109,7 +109,7 @@ tmp<volScalarField> SpalartAllmaras<BasicTurbulenceModel>::fw
|
||||
scalar(10.0)
|
||||
)
|
||||
);
|
||||
r.boundaryField() == 0.0;
|
||||
r.boundaryFieldRef() == 0.0;
|
||||
|
||||
const volScalarField g(r + Cw2_*(pow6(r) - r));
|
||||
|
||||
|
||||
@ -242,7 +242,7 @@ void kEpsilon<BasicTurbulenceModel>::correct()
|
||||
tgradU.clear();
|
||||
|
||||
// Update epsilon and G at the wall
|
||||
epsilon_.boundaryField().updateCoeffs();
|
||||
epsilon_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
// Dissipation equation
|
||||
tmp<fvScalarMatrix> epsEqn
|
||||
@ -260,7 +260,7 @@ void kEpsilon<BasicTurbulenceModel>::correct()
|
||||
|
||||
epsEqn.ref().relax();
|
||||
fvOptions.constrain(epsEqn.ref());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
fvOptions.correct(epsilon_);
|
||||
bound(epsilon_, this->epsilonMin_);
|
||||
|
||||
@ -206,7 +206,7 @@ void kOmega<BasicTurbulenceModel>::correct()
|
||||
tgradU.clear();
|
||||
|
||||
// Update omega and G at the wall
|
||||
omega_.boundaryField().updateCoeffs();
|
||||
omega_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
// Turbulence specific dissipation rate equation
|
||||
tmp<fvScalarMatrix> omegaEqn
|
||||
@ -223,7 +223,7 @@ void kOmega<BasicTurbulenceModel>::correct()
|
||||
|
||||
omegaEqn.ref().relax();
|
||||
fvOptions.constrain(omegaEqn.ref());
|
||||
omegaEqn.ref().boundaryManipulate(omega_.boundaryField());
|
||||
omegaEqn.ref().boundaryManipulate(omega_.boundaryFieldRef());
|
||||
solve(omegaEqn);
|
||||
fvOptions.correct(omega_);
|
||||
bound(omega_, this->omegaMin_);
|
||||
|
||||
@ -414,7 +414,7 @@ void kOmegaSST<BasicTurbulenceModel>::correct()
|
||||
tgradU.clear();
|
||||
|
||||
// Update omega and G at the wall
|
||||
omega_.boundaryField().updateCoeffs();
|
||||
omega_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
volScalarField CDkOmega
|
||||
(
|
||||
@ -454,7 +454,7 @@ void kOmegaSST<BasicTurbulenceModel>::correct()
|
||||
|
||||
omegaEqn.ref().relax();
|
||||
fvOptions.constrain(omegaEqn.ref());
|
||||
omegaEqn.ref().boundaryManipulate(omega_.boundaryField());
|
||||
omegaEqn.ref().boundaryManipulate(omega_.boundaryFieldRef());
|
||||
solve(omegaEqn);
|
||||
fvOptions.correct(omega_);
|
||||
bound(omega_, this->omegaMin_);
|
||||
|
||||
@ -285,7 +285,7 @@ void realizableKE<BasicTurbulenceModel>::correct()
|
||||
volScalarField G(this->GName(), nut*(tgradU() && dev(twoSymm(tgradU()))));
|
||||
|
||||
// Update epsilon and G at the wall
|
||||
epsilon_.boundaryField().updateCoeffs();
|
||||
epsilon_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
// Dissipation equation
|
||||
tmp<fvScalarMatrix> epsEqn
|
||||
@ -306,7 +306,7 @@ void realizableKE<BasicTurbulenceModel>::correct()
|
||||
|
||||
epsEqn.ref().relax();
|
||||
fvOptions.constrain(epsEqn.ref());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
fvOptions.correct(epsilon_);
|
||||
bound(epsilon_, this->epsilonMin_);
|
||||
|
||||
@ -314,7 +314,7 @@ void v2f<BasicTurbulenceModel>::correct()
|
||||
);
|
||||
|
||||
// Update epsilon (and possibly G) at the wall
|
||||
epsilon_.boundaryField().updateCoeffs();
|
||||
epsilon_.boundaryFieldRef().updateCoeffs();
|
||||
|
||||
// Dissipation equation
|
||||
tmp<fvScalarMatrix> epsEqn
|
||||
@ -331,7 +331,7 @@ void v2f<BasicTurbulenceModel>::correct()
|
||||
|
||||
epsEqn.ref().relax();
|
||||
fvOptions.constrain(epsEqn.ref());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryField());
|
||||
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
|
||||
solve(epsEqn);
|
||||
fvOptions.correct(epsilon_);
|
||||
bound(epsilon_, this->epsilonMin_);
|
||||
|
||||
@ -63,13 +63,15 @@ void Foam::ReynoldsStress<BasicTurbulenceModel>::correctWallShearStress
|
||||
{
|
||||
const fvPatchList& patches = this->mesh_.boundary();
|
||||
|
||||
volSymmTensorField::GeometricBoundaryField& RBf = R.boundaryFieldRef();
|
||||
|
||||
forAll(patches, patchi)
|
||||
{
|
||||
const fvPatch& curPatch = patches[patchi];
|
||||
|
||||
if (isA<wallFvPatch>(curPatch))
|
||||
{
|
||||
symmTensorField& Rw = R.boundaryField()[patchi];
|
||||
symmTensorField& Rw = RBf[patchi];
|
||||
|
||||
const scalarField& nutw = this->nut_.boundaryField()[patchi];
|
||||
|
||||
|
||||
@ -84,7 +84,7 @@ tmp<GeometricField<Type, fvPatchField, volMesh>> singleCellFvMesh::interpolate
|
||||
// constructor (with reference to the now correct internal field)
|
||||
|
||||
typename GeometricField<Type, fvPatchField, volMesh>::
|
||||
GeometricBoundaryField& bf = resF.boundaryField();
|
||||
GeometricBoundaryField& bf = resF.boundaryFieldRef();
|
||||
|
||||
if (agglomerate())
|
||||
{
|
||||
|
||||
@ -82,9 +82,12 @@ void Foam::wallDistData<TransferType>::correct()
|
||||
// Collect pointers to data on patches
|
||||
UPtrList<Field<Type>> patchData(mesh.boundaryMesh().size());
|
||||
|
||||
forAll(field_.boundaryField(), patchI)
|
||||
typename GeometricField<Type, fvPatchField, volMesh>::
|
||||
GeometricBoundaryField& fieldBf = field_.boundaryFieldRef();
|
||||
|
||||
forAll(fieldBf, patchi)
|
||||
{
|
||||
patchData.set(patchI, &field_.boundaryField()[patchI]);
|
||||
patchData.set(patchi, &fieldBf[patchi]);
|
||||
}
|
||||
|
||||
// Do mesh wave
|
||||
@ -101,18 +104,19 @@ void Foam::wallDistData<TransferType>::correct()
|
||||
|
||||
field_.transfer(wave.cellData());
|
||||
|
||||
typename GeometricField<Type, fvPatchField, volMesh>::
|
||||
GeometricBoundaryField& bf = boundaryFieldRef();
|
||||
|
||||
// Transfer values on patches into boundaryField of *this and field_
|
||||
forAll(boundaryField(), patchI)
|
||||
forAll(bf, patchi)
|
||||
{
|
||||
scalarField& waveFld = wave.patchDistance()[patchI];
|
||||
scalarField& waveFld = wave.patchDistance()[patchi];
|
||||
|
||||
if (!isA<emptyFvPatchScalarField>(boundaryField()[patchI]))
|
||||
if (!isA<emptyFvPatchScalarField>(boundaryField()[patchi]))
|
||||
{
|
||||
boundaryField()[patchI].transfer(waveFld);
|
||||
|
||||
Field<Type>& wavePatchData = wave.patchData()[patchI];
|
||||
|
||||
field_.boundaryField()[patchI].transfer(wavePatchData);
|
||||
bf[patchi].transfer(waveFld);
|
||||
Field<Type>& wavePatchData = wave.patchData()[patchi];
|
||||
fieldBf[patchi].transfer(wavePatchData);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -128,7 +128,7 @@ template<class ParcelType>
|
||||
inline Foam::volScalarField::GeometricBoundaryField&
|
||||
Foam::DSMCCloud<ParcelType>::qBF()
|
||||
{
|
||||
return q_.boundaryField();
|
||||
return q_.boundaryFieldRef();
|
||||
}
|
||||
|
||||
|
||||
@ -136,7 +136,7 @@ template<class ParcelType>
|
||||
inline Foam::volVectorField::GeometricBoundaryField&
|
||||
Foam::DSMCCloud<ParcelType>::fDBF()
|
||||
{
|
||||
return fD_.boundaryField();
|
||||
return fD_.boundaryFieldRef();
|
||||
}
|
||||
|
||||
|
||||
@ -144,7 +144,7 @@ template<class ParcelType>
|
||||
inline Foam::volScalarField::GeometricBoundaryField&
|
||||
Foam::DSMCCloud<ParcelType>::rhoNBF()
|
||||
{
|
||||
return rhoN_.boundaryField();
|
||||
return rhoN_.boundaryFieldRef();
|
||||
}
|
||||
|
||||
|
||||
@ -152,7 +152,7 @@ template<class ParcelType>
|
||||
inline Foam::volScalarField::GeometricBoundaryField&
|
||||
Foam::DSMCCloud<ParcelType>::rhoMBF()
|
||||
{
|
||||
return rhoM_.boundaryField();
|
||||
return rhoM_.boundaryFieldRef();
|
||||
}
|
||||
|
||||
|
||||
@ -160,7 +160,7 @@ template<class ParcelType>
|
||||
inline Foam::volScalarField::GeometricBoundaryField&
|
||||
Foam::DSMCCloud<ParcelType>::linearKEBF()
|
||||
{
|
||||
return linearKE_.boundaryField();
|
||||
return linearKE_.boundaryFieldRef();
|
||||
}
|
||||
|
||||
|
||||
@ -168,7 +168,7 @@ template<class ParcelType>
|
||||
inline Foam::volScalarField::GeometricBoundaryField&
|
||||
Foam::DSMCCloud<ParcelType>::internalEBF()
|
||||
{
|
||||
return internalE_.boundaryField();
|
||||
return internalE_.boundaryFieldRef();
|
||||
}
|
||||
|
||||
|
||||
@ -176,7 +176,7 @@ template<class ParcelType>
|
||||
inline Foam::volScalarField::GeometricBoundaryField&
|
||||
Foam::DSMCCloud<ParcelType>::iDofBF()
|
||||
{
|
||||
return iDof_.boundaryField();
|
||||
return iDof_.boundaryFieldRef();
|
||||
}
|
||||
|
||||
|
||||
@ -184,7 +184,7 @@ template<class ParcelType>
|
||||
inline Foam::volVectorField::GeometricBoundaryField&
|
||||
Foam::DSMCCloud<ParcelType>::momentumBF()
|
||||
{
|
||||
return momentum_.boundaryField();
|
||||
return momentum_.boundaryFieldRef();
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -83,7 +83,7 @@ Foam::fvFieldDecomposer::decomposeField
|
||||
// constructor (with reference to the now correct internal field)
|
||||
|
||||
typename GeometricField<Type, fvPatchField, volMesh>::
|
||||
GeometricBoundaryField& bf = resF.boundaryField();
|
||||
GeometricBoundaryField& bf = resF.boundaryFieldRef();
|
||||
|
||||
forAll(bf, patchi)
|
||||
{
|
||||
@ -253,7 +253,7 @@ Foam::fvFieldDecomposer::decomposeField
|
||||
// constructor (with reference to the now correct internal field)
|
||||
|
||||
typename GeometricField<Type, fvsPatchField, surfaceMesh>::
|
||||
GeometricBoundaryField& bf = resF.boundaryField();
|
||||
GeometricBoundaryField& bf = resF.boundaryFieldRef();
|
||||
|
||||
forAll(boundaryAddressing_, patchi)
|
||||
{
|
||||
|
||||
@ -116,16 +116,28 @@ void kinematicSingleLayer::transferPrimaryRegionSourceFields()
|
||||
InfoInFunction << endl;
|
||||
}
|
||||
|
||||
volScalarField::GeometricBoundaryField& rhoSpPrimaryBf =
|
||||
rhoSpPrimary_.boundaryFieldRef();
|
||||
|
||||
volVectorField::GeometricBoundaryField& USpPrimaryBf =
|
||||
USpPrimary_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& pSpPrimaryBf =
|
||||
pSpPrimary_.boundaryFieldRef();
|
||||
|
||||
// Convert accummulated source terms into per unit area per unit time
|
||||
const scalar deltaT = time_.deltaTValue();
|
||||
forAll(rhoSpPrimary_.boundaryField(), patchI)
|
||||
forAll(rhoSpPrimary_.boundaryField(), patchi)
|
||||
{
|
||||
const scalarField& priMagSf =
|
||||
primaryMesh().magSf().boundaryField()[patchI];
|
||||
scalarField rpriMagSfdeltaT
|
||||
(
|
||||
(1.0/deltaT)
|
||||
/primaryMesh().magSf().boundaryField()[patchi]
|
||||
);
|
||||
|
||||
rhoSpPrimary_.boundaryField()[patchI] /= priMagSf*deltaT;
|
||||
USpPrimary_.boundaryField()[patchI] /= priMagSf*deltaT;
|
||||
pSpPrimary_.boundaryField()[patchI] /= priMagSf*deltaT;
|
||||
rhoSpPrimaryBf[patchi] *= rpriMagSfdeltaT;
|
||||
USpPrimaryBf[patchi] *= rpriMagSfdeltaT;
|
||||
pSpPrimaryBf[patchi] *= rpriMagSfdeltaT;
|
||||
}
|
||||
|
||||
// Retrieve the source fields from the primary region via direct mapped
|
||||
@ -270,10 +282,10 @@ 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];
|
||||
label patchi = intCoupledPatchIDs_[i];
|
||||
const polyPatch& pp = regionMesh().boundaryMesh()[patchi];
|
||||
UIndirectList<vector>(Uw_, pp.faceCells()) =
|
||||
U_.boundaryField()[patchI];
|
||||
U_.boundaryField()[patchi];
|
||||
}
|
||||
Uw_ -= nHat()*(Uw_ & nHat());
|
||||
Uw_.correctBoundaryConditions();
|
||||
@ -825,7 +837,7 @@ kinematicSingleLayer::~kinematicSingleLayer()
|
||||
|
||||
void kinematicSingleLayer::addSources
|
||||
(
|
||||
const label patchI,
|
||||
const label patchi,
|
||||
const label faceI,
|
||||
const scalar massSource,
|
||||
const vector& momentumSource,
|
||||
@ -842,9 +854,9 @@ void kinematicSingleLayer::addSources
|
||||
<< " pressure = " << pressureSource << endl;
|
||||
}
|
||||
|
||||
rhoSpPrimary_.boundaryField()[patchI][faceI] -= massSource;
|
||||
USpPrimary_.boundaryField()[patchI][faceI] -= momentumSource;
|
||||
pSpPrimary_.boundaryField()[patchI][faceI] -= pressureSource;
|
||||
rhoSpPrimary_.boundaryFieldRef()[patchi][faceI] -= massSource;
|
||||
USpPrimary_.boundaryFieldRef()[patchi][faceI] -= momentumSource;
|
||||
pSpPrimary_.boundaryFieldRef()[patchi][faceI] -= pressureSource;
|
||||
|
||||
addedMassTotal_ += massSource;
|
||||
}
|
||||
@ -866,7 +878,7 @@ void kinematicSingleLayer::preEvolveRegion()
|
||||
transferPrimaryRegionSourceFields();
|
||||
|
||||
// Reset transfer fields
|
||||
// availableMass_ = mass();
|
||||
//availableMass_ = mass();
|
||||
availableMass_ = netMass();
|
||||
cloudMassTrans_ == dimensionedScalar("zero", dimMass, 0.0);
|
||||
cloudDiameterTrans_ == dimensionedScalar("zero", dimLength, 0.0);
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
|
||||
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
@ -43,25 +43,28 @@ void kinematicSingleLayer::constrainFilmField
|
||||
const typename Type::cmptType& value
|
||||
)
|
||||
{
|
||||
typename Type::GeometricBoundaryField& fieldBf = field.boundaryFieldRef();
|
||||
|
||||
forAll(intCoupledPatchIDs_, i)
|
||||
{
|
||||
label patchI = intCoupledPatchIDs_[i];
|
||||
field.boundaryField()[patchI] = value;
|
||||
label patchi = intCoupledPatchIDs_[i];
|
||||
fieldBf[patchi] = value;
|
||||
if (debug)
|
||||
{
|
||||
Info<< "Constraining " << field.name()
|
||||
<< " boundary " << field.boundaryField()[patchI].patch().name()
|
||||
<< " boundary " << field.boundaryField()[patchi].patch().name()
|
||||
<< " to " << value << endl;
|
||||
}
|
||||
}
|
||||
|
||||
forAll(passivePatchIDs_, i)
|
||||
{
|
||||
label patchI = passivePatchIDs_[i];
|
||||
field.boundaryField()[patchI] = value;
|
||||
label patchi = passivePatchIDs_[i];
|
||||
fieldBf[patchi] = value;
|
||||
if (debug)
|
||||
{
|
||||
Info<< "Constraining " << field.name()
|
||||
<< " boundary " << field.boundaryField()[patchI].patch().name()
|
||||
<< " boundary " << field.boundaryField()[patchi].patch().name()
|
||||
<< " to " << value << endl;
|
||||
}
|
||||
}
|
||||
|
||||
@ -61,15 +61,15 @@ addToRunTimeSelectionTable(surfaceFilmModel, thermoSingleLayer, mesh);
|
||||
wordList thermoSingleLayer::hsBoundaryTypes()
|
||||
{
|
||||
wordList bTypes(T_.boundaryField().types());
|
||||
forAll(bTypes, patchI)
|
||||
forAll(bTypes, patchi)
|
||||
{
|
||||
if
|
||||
(
|
||||
T_.boundaryField()[patchI].fixesValue()
|
||||
|| bTypes[patchI] == mappedFieldFvPatchField<scalar>::typeName
|
||||
T_.boundaryField()[patchi].fixesValue()
|
||||
|| bTypes[patchi] == mappedFieldFvPatchField<scalar>::typeName
|
||||
)
|
||||
{
|
||||
bTypes[patchI] = fixedValueFvPatchField<scalar>::typeName;
|
||||
bTypes[patchi] = fixedValueFvPatchField<scalar>::typeName;
|
||||
}
|
||||
}
|
||||
|
||||
@ -112,12 +112,14 @@ void thermoSingleLayer::correctHsForMappedT()
|
||||
{
|
||||
T_.correctBoundaryConditions();
|
||||
|
||||
forAll(T_.boundaryField(), patchI)
|
||||
volScalarField::GeometricBoundaryField& hsBf = hs_.boundaryFieldRef();
|
||||
|
||||
forAll(hsBf, patchi)
|
||||
{
|
||||
const fvPatchField<scalar>& Tp = T_.boundaryField()[patchI];
|
||||
const fvPatchField<scalar>& Tp = T_.boundaryField()[patchi];
|
||||
if (isA<mappedFieldFvPatchField<scalar>>(Tp))
|
||||
{
|
||||
hs_.boundaryField()[patchI] == hs(Tp, patchI);
|
||||
hsBf[patchi] == hs(Tp, patchi);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -130,10 +132,10 @@ void thermoSingleLayer::updateSurfaceTemperatures()
|
||||
// Push boundary film temperature into wall temperature internal field
|
||||
for (label i=0; i<intCoupledPatchIDs_.size(); i++)
|
||||
{
|
||||
label patchI = intCoupledPatchIDs_[i];
|
||||
const polyPatch& pp = regionMesh().boundaryMesh()[patchI];
|
||||
label patchi = intCoupledPatchIDs_[i];
|
||||
const polyPatch& pp = regionMesh().boundaryMesh()[patchi];
|
||||
UIndirectList<scalar>(Tw_, pp.faceCells()) =
|
||||
T_.boundaryField()[patchI];
|
||||
T_.boundaryField()[patchi];
|
||||
}
|
||||
Tw_.correctBoundaryConditions();
|
||||
|
||||
@ -171,14 +173,17 @@ void thermoSingleLayer::transferPrimaryRegionSourceFields()
|
||||
|
||||
kinematicSingleLayer::transferPrimaryRegionSourceFields();
|
||||
|
||||
volScalarField::GeometricBoundaryField& hsSpPrimaryBf =
|
||||
hsSpPrimary_.boundaryFieldRef();
|
||||
|
||||
// Convert accummulated source terms into per unit area per unit time
|
||||
const scalar deltaT = time_.deltaTValue();
|
||||
forAll(hsSpPrimary_.boundaryField(), patchI)
|
||||
forAll(hsSpPrimaryBf, patchi)
|
||||
{
|
||||
const scalarField& priMagSf =
|
||||
primaryMesh().magSf().boundaryField()[patchI];
|
||||
primaryMesh().magSf().boundaryField()[patchi];
|
||||
|
||||
hsSpPrimary_.boundaryField()[patchI] /= priMagSf*deltaT;
|
||||
hsSpPrimaryBf[patchi] /= priMagSf*deltaT;
|
||||
}
|
||||
|
||||
// Retrieve the source fields from the primary region via direct mapped
|
||||
@ -579,7 +584,7 @@ thermoSingleLayer::~thermoSingleLayer()
|
||||
|
||||
void thermoSingleLayer::addSources
|
||||
(
|
||||
const label patchI,
|
||||
const label patchi,
|
||||
const label faceI,
|
||||
const scalar massSource,
|
||||
const vector& momentumSource,
|
||||
@ -589,7 +594,7 @@ void thermoSingleLayer::addSources
|
||||
{
|
||||
kinematicSingleLayer::addSources
|
||||
(
|
||||
patchI,
|
||||
patchi,
|
||||
faceI,
|
||||
massSource,
|
||||
momentumSource,
|
||||
@ -602,7 +607,7 @@ void thermoSingleLayer::addSources
|
||||
Info<< " energy = " << energySource << nl << endl;
|
||||
}
|
||||
|
||||
hsSpPrimary_.boundaryField()[patchI][faceI] -= energySource;
|
||||
hsSpPrimary_.boundaryFieldRef()[patchi][faceI] -= energySource;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -329,13 +329,16 @@ void Foam::meshToMesh::mapSrcToTgt
|
||||
|
||||
const PtrList<AMIPatchToPatchInterpolation>& AMIList = patchAMIs();
|
||||
|
||||
typename GeometricField<Type, fvPatchField, volMesh>::
|
||||
GeometricBoundaryField& resultBf = result.boundaryFieldRef();
|
||||
|
||||
forAll(AMIList, i)
|
||||
{
|
||||
label srcPatchI = srcPatchID_[i];
|
||||
label tgtPatchI = tgtPatchID_[i];
|
||||
label srcPatchi = srcPatchID_[i];
|
||||
label tgtPatchi = tgtPatchID_[i];
|
||||
|
||||
const fvPatchField<Type>& srcField = field.boundaryField()[srcPatchI];
|
||||
fvPatchField<Type>& tgtField = result.boundaryField()[tgtPatchI];
|
||||
const fvPatchField<Type>& srcField = field.boundaryField()[srcPatchi];
|
||||
fvPatchField<Type>& tgtField = resultBf[tgtPatchi];
|
||||
|
||||
// 2.3 does not do distributed mapping yet so only do if
|
||||
// running on single processor
|
||||
@ -375,8 +378,8 @@ void Foam::meshToMesh::mapSrcToTgt
|
||||
|
||||
forAll(cuttingPatches_, i)
|
||||
{
|
||||
label patchI = cuttingPatches_[i];
|
||||
fvPatchField<Type>& pf = result.boundaryField()[patchI];
|
||||
label patchi = cuttingPatches_[i];
|
||||
fvPatchField<Type>& pf = resultBf[patchi];
|
||||
pf == pf.patchInternalField();
|
||||
}
|
||||
}
|
||||
@ -405,22 +408,22 @@ Foam::meshToMesh::mapSrcToTgt
|
||||
// entries, but these values will need to be reset
|
||||
forAll(tgtPatchID_, i)
|
||||
{
|
||||
label srcPatchI = srcPatchID_[i];
|
||||
label tgtPatchI = tgtPatchID_[i];
|
||||
label srcPatchi = srcPatchID_[i];
|
||||
label tgtPatchi = tgtPatchID_[i];
|
||||
|
||||
if (!tgtPatchFields.set(tgtPatchI))
|
||||
if (!tgtPatchFields.set(tgtPatchi))
|
||||
{
|
||||
tgtPatchFields.set
|
||||
(
|
||||
tgtPatchI,
|
||||
tgtPatchi,
|
||||
fvPatchField<Type>::New
|
||||
(
|
||||
srcBfld[srcPatchI],
|
||||
tgtMesh.boundary()[tgtPatchI],
|
||||
srcBfld[srcPatchi],
|
||||
tgtMesh.boundary()[tgtPatchi],
|
||||
DimensionedField<Type, volMesh>::null(),
|
||||
directFvPatchFieldMapper
|
||||
(
|
||||
labelList(tgtMesh.boundary()[tgtPatchI].size(), -1)
|
||||
labelList(tgtMesh.boundary()[tgtPatchi].size(), -1)
|
||||
)
|
||||
)
|
||||
);
|
||||
@ -428,19 +431,19 @@ Foam::meshToMesh::mapSrcToTgt
|
||||
}
|
||||
|
||||
// Any unset tgtPatchFields become calculated
|
||||
forAll(tgtPatchFields, tgtPatchI)
|
||||
forAll(tgtPatchFields, tgtPatchi)
|
||||
{
|
||||
if (!tgtPatchFields.set(tgtPatchI))
|
||||
if (!tgtPatchFields.set(tgtPatchi))
|
||||
{
|
||||
// Note: use factory New method instead of direct generation of
|
||||
// calculated so we keep constraints
|
||||
tgtPatchFields.set
|
||||
(
|
||||
tgtPatchI,
|
||||
tgtPatchi,
|
||||
fvPatchField<Type>::New
|
||||
(
|
||||
calculatedFvPatchField<Type>::typeName,
|
||||
tgtMesh.boundary()[tgtPatchI],
|
||||
tgtMesh.boundary()[tgtPatchi],
|
||||
DimensionedField<Type, volMesh>::null()
|
||||
)
|
||||
);
|
||||
@ -520,11 +523,11 @@ void Foam::meshToMesh::mapTgtToSrc
|
||||
|
||||
forAll(AMIList, i)
|
||||
{
|
||||
label srcPatchI = srcPatchID_[i];
|
||||
label tgtPatchI = tgtPatchID_[i];
|
||||
label srcPatchi = srcPatchID_[i];
|
||||
label tgtPatchi = tgtPatchID_[i];
|
||||
|
||||
fvPatchField<Type>& srcField = result.boundaryField()[srcPatchI];
|
||||
const fvPatchField<Type>& tgtField = field.boundaryField()[tgtPatchI];
|
||||
fvPatchField<Type>& srcField = result.boundaryField()[srcPatchi];
|
||||
const fvPatchField<Type>& tgtField = field.boundaryField()[tgtPatchi];
|
||||
|
||||
// 2.3 does not do distributed mapping yet so only do if
|
||||
// running on single processor
|
||||
@ -564,8 +567,8 @@ void Foam::meshToMesh::mapTgtToSrc
|
||||
|
||||
forAll(cuttingPatches_, i)
|
||||
{
|
||||
label patchI = cuttingPatches_[i];
|
||||
fvPatchField<Type>& pf = result.boundaryField()[patchI];
|
||||
label patchi = cuttingPatches_[i];
|
||||
fvPatchField<Type>& pf = result.boundaryField()[patchi];
|
||||
pf == pf.patchInternalField();
|
||||
}
|
||||
}
|
||||
@ -594,22 +597,22 @@ Foam::meshToMesh::mapTgtToSrc
|
||||
// entries, but these values will need to be reset
|
||||
forAll(srcPatchID_, i)
|
||||
{
|
||||
label srcPatchI = srcPatchID_[i];
|
||||
label tgtPatchI = tgtPatchID_[i];
|
||||
label srcPatchi = srcPatchID_[i];
|
||||
label tgtPatchi = tgtPatchID_[i];
|
||||
|
||||
if (!srcPatchFields.set(tgtPatchI))
|
||||
if (!srcPatchFields.set(tgtPatchi))
|
||||
{
|
||||
srcPatchFields.set
|
||||
(
|
||||
srcPatchI,
|
||||
srcPatchi,
|
||||
fvPatchField<Type>::New
|
||||
(
|
||||
tgtBfld[srcPatchI],
|
||||
srcMesh.boundary()[tgtPatchI],
|
||||
tgtBfld[srcPatchi],
|
||||
srcMesh.boundary()[tgtPatchi],
|
||||
DimensionedField<Type, volMesh>::null(),
|
||||
directFvPatchFieldMapper
|
||||
(
|
||||
labelList(srcMesh.boundary()[srcPatchI].size(), -1)
|
||||
labelList(srcMesh.boundary()[srcPatchi].size(), -1)
|
||||
)
|
||||
)
|
||||
);
|
||||
@ -617,19 +620,19 @@ Foam::meshToMesh::mapTgtToSrc
|
||||
}
|
||||
|
||||
// Any unset srcPatchFields become calculated
|
||||
forAll(srcPatchFields, srcPatchI)
|
||||
forAll(srcPatchFields, srcPatchi)
|
||||
{
|
||||
if (!srcPatchFields.set(srcPatchI))
|
||||
if (!srcPatchFields.set(srcPatchi))
|
||||
{
|
||||
// Note: use factory New method instead of direct generation of
|
||||
// calculated so we keep constraints
|
||||
srcPatchFields.set
|
||||
(
|
||||
srcPatchI,
|
||||
srcPatchi,
|
||||
fvPatchField<Type>::New
|
||||
(
|
||||
calculatedFvPatchField<Type>::typeName,
|
||||
srcMesh.boundary()[srcPatchI],
|
||||
srcMesh.boundary()[srcPatchi],
|
||||
DimensionedField<Type, volMesh>::null()
|
||||
)
|
||||
);
|
||||
|
||||
@ -253,6 +253,9 @@ void Foam::meshToMesh0::interpolate
|
||||
{
|
||||
interpolateInternalField(toVf, fromVf, ord, cop);
|
||||
|
||||
typename GeometricField<Type, fvPatchField, volMesh>::
|
||||
GeometricBoundaryField& toVfBf = toVf.boundaryFieldRef();
|
||||
|
||||
forAll(toMesh_.boundaryMesh(), patchi)
|
||||
{
|
||||
const fvPatch& toPatch = toMesh_.boundary()[patchi];
|
||||
@ -265,7 +268,7 @@ void Foam::meshToMesh0::interpolate
|
||||
{
|
||||
mapField
|
||||
(
|
||||
toVf.boundaryField()[patchi],
|
||||
toVfBf[patchi],
|
||||
fromVf,
|
||||
boundaryAddressing_[patchi],
|
||||
cop
|
||||
@ -277,7 +280,7 @@ void Foam::meshToMesh0::interpolate
|
||||
{
|
||||
interpolateField
|
||||
(
|
||||
toVf.boundaryField()[patchi],
|
||||
toVfBf[patchi],
|
||||
fromVf,
|
||||
boundaryAddressing_[patchi],
|
||||
toPatch.Cf(),
|
||||
@ -290,7 +293,7 @@ void Foam::meshToMesh0::interpolate
|
||||
{
|
||||
interpolateField
|
||||
(
|
||||
toVf.boundaryField()[patchi],
|
||||
toVfBf[patchi],
|
||||
fromVf,
|
||||
boundaryAddressing_[patchi],
|
||||
toPatch.Cf(),
|
||||
@ -310,12 +313,12 @@ void Foam::meshToMesh0::interpolate
|
||||
<< exit(FatalError);
|
||||
}
|
||||
|
||||
if (isA<mixedFvPatchField<Type>>(toVf.boundaryField()[patchi]))
|
||||
if (isA<mixedFvPatchField<Type>>(toVfBf[patchi]))
|
||||
{
|
||||
refCast<mixedFvPatchField<Type>>
|
||||
(
|
||||
toVf.boundaryField()[patchi]
|
||||
).refValue() = toVf.boundaryField()[patchi];
|
||||
toVfBf[patchi]
|
||||
).refValue() = toVfBf[patchi];
|
||||
}
|
||||
}
|
||||
else if
|
||||
@ -324,20 +327,9 @@ void Foam::meshToMesh0::interpolate
|
||||
&& fromMeshPatches_.found(patchMap_.find(toPatch.name())())
|
||||
)
|
||||
{
|
||||
/*
|
||||
toVf.boundaryField()[patchi].map
|
||||
(
|
||||
fromVf.boundaryField()
|
||||
[
|
||||
fromMeshPatches_.find(patchMap_.find(toPatch.name())())()
|
||||
],
|
||||
boundaryAddressing_[patchi]
|
||||
);
|
||||
*/
|
||||
|
||||
mapField
|
||||
(
|
||||
toVf.boundaryField()[patchi],
|
||||
toVfBf[patchi],
|
||||
fromVf.boundaryField()
|
||||
[
|
||||
fromMeshPatches_.find(patchMap_.find(toPatch.name())())()
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
|
||||
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
@ -128,12 +128,15 @@ void Foam::distanceSurface::createGeometry()
|
||||
}
|
||||
}
|
||||
|
||||
volScalarField::GeometricBoundaryField& cellDistanceBf =
|
||||
cellDistance.boundaryFieldRef();
|
||||
|
||||
// Patch fields
|
||||
{
|
||||
forAll(fvm.C().boundaryField(), patchI)
|
||||
forAll(fvm.C().boundaryField(), patchi)
|
||||
{
|
||||
const pointField& cc = fvm.C().boundaryField()[patchI];
|
||||
fvPatchScalarField& fld = cellDistance.boundaryField()[patchI];
|
||||
const pointField& cc = fvm.C().boundaryField()[patchi];
|
||||
fvPatchScalarField& fld = cellDistanceBf[patchi];
|
||||
|
||||
List<pointIndexHit> nearest;
|
||||
surfPtr_().findNearest
|
||||
|
||||
@ -76,26 +76,29 @@ Foam::isoSurface::adaptPatchFields
|
||||
|
||||
const polyBoundaryMesh& patches = mesh.boundaryMesh();
|
||||
|
||||
forAll(patches, patchI)
|
||||
typename FieldType::GeometricBoundaryField& sliceFldBf =
|
||||
sliceFld.boundaryFieldRef();
|
||||
|
||||
forAll(patches, patchi)
|
||||
{
|
||||
const polyPatch& pp = patches[patchI];
|
||||
const polyPatch& pp = patches[patchi];
|
||||
|
||||
if
|
||||
(
|
||||
isA<emptyPolyPatch>(pp)
|
||||
&& pp.size() != sliceFld.boundaryField()[patchI].size()
|
||||
&& pp.size() != sliceFldBf[patchi].size()
|
||||
)
|
||||
{
|
||||
// Clear old value. Cannot resize it since is a slice.
|
||||
sliceFld.boundaryField().set(patchI, NULL);
|
||||
sliceFldBf.set(patchi, NULL);
|
||||
|
||||
// Set new value we can change
|
||||
sliceFld.boundaryField().set
|
||||
sliceFldBf.set
|
||||
(
|
||||
patchI,
|
||||
patchi,
|
||||
new calculatedFvPatchField<Type>
|
||||
(
|
||||
mesh.boundary()[patchI],
|
||||
mesh.boundary()[patchi],
|
||||
sliceFld
|
||||
)
|
||||
);
|
||||
@ -103,9 +106,9 @@ Foam::isoSurface::adaptPatchFields
|
||||
// Note: cannot use patchInternalField since uses emptyFvPatch::size
|
||||
// Do our own internalField instead.
|
||||
const labelUList& faceCells =
|
||||
mesh.boundary()[patchI].patch().faceCells();
|
||||
mesh.boundary()[patchi].patch().faceCells();
|
||||
|
||||
Field<Type>& pfld = sliceFld.boundaryField()[patchI];
|
||||
Field<Type>& pfld = sliceFldBf[patchi];
|
||||
pfld.setSize(faceCells.size());
|
||||
forAll(faceCells, i)
|
||||
{
|
||||
@ -120,10 +123,10 @@ Foam::isoSurface::adaptPatchFields
|
||||
{
|
||||
fvPatchField<Type>& pfld = const_cast<fvPatchField<Type>&>
|
||||
(
|
||||
sliceFld.boundaryField()[patchI]
|
||||
sliceFldBf[patchi]
|
||||
);
|
||||
|
||||
const scalarField& w = mesh.weights().boundaryField()[patchI];
|
||||
const scalarField& w = mesh.weights().boundaryField()[patchi];
|
||||
|
||||
tmp<Field<Type>> f =
|
||||
w*pfld.patchInternalField()
|
||||
@ -595,9 +598,9 @@ void Foam::isoSurface::generateTriPoints
|
||||
// Determine neighbouring snap status
|
||||
boolList neiSnapped(mesh_.nFaces()-mesh_.nInternalFaces(), false);
|
||||
List<Type> neiSnappedPoint(neiSnapped.size(), Type(Zero));
|
||||
forAll(patches, patchI)
|
||||
forAll(patches, patchi)
|
||||
{
|
||||
const polyPatch& pp = patches[patchI];
|
||||
const polyPatch& pp = patches[patchi];
|
||||
|
||||
if (pp.coupled())
|
||||
{
|
||||
@ -621,9 +624,9 @@ void Foam::isoSurface::generateTriPoints
|
||||
|
||||
|
||||
|
||||
forAll(patches, patchI)
|
||||
forAll(patches, patchi)
|
||||
{
|
||||
const polyPatch& pp = patches[patchI];
|
||||
const polyPatch& pp = patches[patchi];
|
||||
|
||||
if (isA<processorPolyPatch>(pp))
|
||||
{
|
||||
@ -653,8 +656,8 @@ void Foam::isoSurface::generateTriPoints
|
||||
snappedPoint,
|
||||
faceI,
|
||||
|
||||
cVals.boundaryField()[patchI][i],
|
||||
cCoords.boundaryField()[patchI][i],
|
||||
cVals.boundaryField()[patchi][i],
|
||||
cCoords.boundaryField()[patchi][i],
|
||||
neiSnapped[faceI-mesh_.nInternalFaces()],
|
||||
neiSnappedPoint[faceI-mesh_.nInternalFaces()],
|
||||
|
||||
@ -677,8 +680,8 @@ void Foam::isoSurface::generateTriPoints
|
||||
snappedPoint,
|
||||
faceI,
|
||||
|
||||
cVals.boundaryField()[patchI][i],
|
||||
cCoords.boundaryField()[patchI][i],
|
||||
cVals.boundaryField()[patchi][i],
|
||||
cCoords.boundaryField()[patchi][i],
|
||||
false,
|
||||
Type(Zero),
|
||||
|
||||
@ -710,8 +713,8 @@ void Foam::isoSurface::generateTriPoints
|
||||
snappedPoint,
|
||||
faceI,
|
||||
|
||||
cVals.boundaryField()[patchI][i],
|
||||
cCoords.boundaryField()[patchI][i],
|
||||
cVals.boundaryField()[patchi][i],
|
||||
cCoords.boundaryField()[patchi][i],
|
||||
false, // fc not snapped
|
||||
Type(Zero),
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
|
||||
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
@ -134,32 +134,35 @@ void Foam::sampledCuttingPlane::createGeometry()
|
||||
}
|
||||
}
|
||||
|
||||
volScalarField::GeometricBoundaryField& cellDistanceBf =
|
||||
cellDistance.boundaryFieldRef();
|
||||
|
||||
// Patch fields
|
||||
{
|
||||
forAll(cellDistance.boundaryField(), patchI)
|
||||
forAll(cellDistanceBf, patchi)
|
||||
{
|
||||
if
|
||||
(
|
||||
isA<emptyFvPatchScalarField>
|
||||
(
|
||||
cellDistance.boundaryField()[patchI]
|
||||
cellDistanceBf[patchi]
|
||||
)
|
||||
)
|
||||
{
|
||||
cellDistance.boundaryField().set
|
||||
cellDistanceBf.set
|
||||
(
|
||||
patchI,
|
||||
patchi,
|
||||
new calculatedFvPatchScalarField
|
||||
(
|
||||
fvm.boundary()[patchI],
|
||||
fvm.boundary()[patchi],
|
||||
cellDistance
|
||||
)
|
||||
);
|
||||
|
||||
const polyPatch& pp = fvm.boundary()[patchI].patch();
|
||||
const polyPatch& pp = fvm.boundary()[patchi].patch();
|
||||
pointField::subField cc = pp.patchSlice(fvm.faceCentres());
|
||||
|
||||
fvPatchScalarField& fld = cellDistance.boundaryField()[patchI];
|
||||
fvPatchScalarField& fld = cellDistanceBf[patchi];
|
||||
fld.setSize(pp.size());
|
||||
forAll(fld, i)
|
||||
{
|
||||
@ -168,8 +171,8 @@ void Foam::sampledCuttingPlane::createGeometry()
|
||||
}
|
||||
else
|
||||
{
|
||||
const pointField& cc = fvm.C().boundaryField()[patchI];
|
||||
fvPatchScalarField& fld = cellDistance.boundaryField()[patchI];
|
||||
const pointField& cc = fvm.C().boundaryField()[patchi];
|
||||
fvPatchScalarField& fld = cellDistanceBf[patchi];
|
||||
|
||||
forAll(fld, i)
|
||||
{
|
||||
|
||||
@ -33,19 +33,19 @@ template<class BasicThermo, class MixtureType>
|
||||
void Foam::heThermo<BasicThermo, MixtureType>::
|
||||
heBoundaryCorrection(volScalarField& h)
|
||||
{
|
||||
volScalarField::GeometricBoundaryField& hbf = h.boundaryField();
|
||||
volScalarField::GeometricBoundaryField& hBf = h.boundaryFieldRef();
|
||||
|
||||
forAll(hbf, patchi)
|
||||
forAll(hBf, patchi)
|
||||
{
|
||||
if (isA<gradientEnergyFvPatchScalarField>(hbf[patchi]))
|
||||
if (isA<gradientEnergyFvPatchScalarField>(hBf[patchi]))
|
||||
{
|
||||
refCast<gradientEnergyFvPatchScalarField>(hbf[patchi]).gradient()
|
||||
= hbf[patchi].fvPatchField::snGrad();
|
||||
refCast<gradientEnergyFvPatchScalarField>(hBf[patchi]).gradient()
|
||||
= hBf[patchi].fvPatchField::snGrad();
|
||||
}
|
||||
else if (isA<mixedEnergyFvPatchScalarField>(hbf[patchi]))
|
||||
else if (isA<mixedEnergyFvPatchScalarField>(hBf[patchi]))
|
||||
{
|
||||
refCast<mixedEnergyFvPatchScalarField>(hbf[patchi]).refGrad()
|
||||
= hbf[patchi].fvPatchField::snGrad();
|
||||
refCast<mixedEnergyFvPatchScalarField>(hBf[patchi]).refGrad()
|
||||
= hBf[patchi].fvPatchField::snGrad();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -64,9 +64,11 @@ void Foam::heThermo<BasicThermo, MixtureType>::init()
|
||||
this->cellMixture(celli).HE(pCells[celli], TCells[celli]);
|
||||
}
|
||||
|
||||
forAll(he_.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& heBf = he_.boundaryFieldRef();
|
||||
|
||||
forAll(heBf, patchi)
|
||||
{
|
||||
he_.boundaryField()[patchi] == he
|
||||
heBf[patchi] == he
|
||||
(
|
||||
this->p_.boundaryField()[patchi],
|
||||
this->T_.boundaryField()[patchi],
|
||||
@ -195,9 +197,11 @@ Foam::tmp<Foam::volScalarField> Foam::heThermo<BasicThermo, MixtureType>::he
|
||||
this->cellMixture(celli).HE(pCells[celli], TCells[celli]);
|
||||
}
|
||||
|
||||
forAll(he.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& heBf = he.boundaryFieldRef();
|
||||
|
||||
forAll(heBf, patchi)
|
||||
{
|
||||
scalarField& hep = he.boundaryField()[patchi];
|
||||
scalarField& hep = heBf[patchi];
|
||||
const scalarField& pp = p.boundaryField()[patchi];
|
||||
const scalarField& Tp = T.boundaryField()[patchi];
|
||||
|
||||
@ -285,9 +289,11 @@ Foam::heThermo<BasicThermo, MixtureType>::hc() const
|
||||
hcCells[celli] = this->cellMixture(celli).Hc();
|
||||
}
|
||||
|
||||
forAll(hcf.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& hcfBf = hcf.boundaryFieldRef();
|
||||
|
||||
forAll(hcfBf, patchi)
|
||||
{
|
||||
scalarField& hcp = hcf.boundaryField()[patchi];
|
||||
scalarField& hcp = hcfBf[patchi];
|
||||
|
||||
forAll(hcp, facei)
|
||||
{
|
||||
@ -352,11 +358,13 @@ Foam::heThermo<BasicThermo, MixtureType>::Cp() const
|
||||
this->cellMixture(celli).Cp(this->p_[celli], this->T_[celli]);
|
||||
}
|
||||
|
||||
forAll(this->T_.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& cpBf = cp.boundaryFieldRef();
|
||||
|
||||
forAll(cpBf, patchi)
|
||||
{
|
||||
const fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
const fvPatchScalarField& pT = this->T_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pCp = cp.boundaryField()[patchi];
|
||||
fvPatchScalarField& pCp = cpBf[patchi];
|
||||
|
||||
forAll(pT, facei)
|
||||
{
|
||||
@ -423,9 +431,11 @@ Foam::heThermo<BasicThermo, MixtureType>::Cv() const
|
||||
this->cellMixture(celli).Cv(this->p_[celli], this->T_[celli]);
|
||||
}
|
||||
|
||||
forAll(this->T_.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& cvBf = cv.boundaryFieldRef();
|
||||
|
||||
forAll(cvBf, patchi)
|
||||
{
|
||||
cv.boundaryField()[patchi] = Cv
|
||||
cvBf[patchi] = Cv
|
||||
(
|
||||
this->p_.boundaryField()[patchi],
|
||||
this->T_.boundaryField()[patchi],
|
||||
@ -482,19 +492,21 @@ Foam::heThermo<BasicThermo, MixtureType>::gamma() const
|
||||
)
|
||||
);
|
||||
|
||||
volScalarField& cpv = tgamma.ref();
|
||||
volScalarField& gamma = tgamma.ref();
|
||||
|
||||
forAll(this->T_, celli)
|
||||
{
|
||||
cpv[celli] =
|
||||
gamma[celli] =
|
||||
this->cellMixture(celli).gamma(this->p_[celli], this->T_[celli]);
|
||||
}
|
||||
|
||||
forAll(this->T_.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& gammaBf = gamma.boundaryFieldRef();
|
||||
|
||||
forAll(gammaBf, patchi)
|
||||
{
|
||||
const fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
const fvPatchScalarField& pT = this->T_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pgamma = cpv.boundaryField()[patchi];
|
||||
fvPatchScalarField& pgamma = gammaBf[patchi];
|
||||
|
||||
forAll(pT, facei)
|
||||
{
|
||||
@ -563,11 +575,13 @@ Foam::heThermo<BasicThermo, MixtureType>::Cpv() const
|
||||
this->cellMixture(celli).Cpv(this->p_[celli], this->T_[celli]);
|
||||
}
|
||||
|
||||
forAll(this->T_.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& cpvBf = cpv.boundaryFieldRef();
|
||||
|
||||
forAll(cpvBf, patchi)
|
||||
{
|
||||
const fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
const fvPatchScalarField& pT = this->T_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pCpv = cpv.boundaryField()[patchi];
|
||||
fvPatchScalarField& pCpv = cpvBf[patchi];
|
||||
|
||||
forAll(pT, facei)
|
||||
{
|
||||
@ -636,11 +650,14 @@ Foam::heThermo<BasicThermo, MixtureType>::CpByCpv() const
|
||||
);
|
||||
}
|
||||
|
||||
forAll(this->T_.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& cpByCpvBf =
|
||||
cpByCpv.boundaryFieldRef();
|
||||
|
||||
forAll(cpByCpvBf, patchi)
|
||||
{
|
||||
const fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
const fvPatchScalarField& pT = this->T_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pCpByCpv = cpByCpv.boundaryField()[patchi];
|
||||
fvPatchScalarField& pCpByCpv = cpByCpvBf[patchi];
|
||||
|
||||
forAll(pT, facei)
|
||||
{
|
||||
|
||||
@ -56,16 +56,32 @@ void Foam::hePsiThermo<BasicPsiThermo, MixtureType>::calculate()
|
||||
alphaCells[celli] = mixture_.alphah(pCells[celli], TCells[celli]);
|
||||
}
|
||||
|
||||
volScalarField::GeometricBoundaryField& pBf =
|
||||
this->p_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& TBf =
|
||||
this->T_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& psiBf =
|
||||
this->psi_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& heBf =
|
||||
this->he().boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& muBf =
|
||||
this->mu_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& alphaBf =
|
||||
this->alpha_.boundaryFieldRef();
|
||||
|
||||
forAll(this->T_.boundaryField(), patchi)
|
||||
{
|
||||
fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pT = this->T_.boundaryField()[patchi];
|
||||
fvPatchScalarField& ppsi = this->psi_.boundaryField()[patchi];
|
||||
|
||||
fvPatchScalarField& ph = this->he_.boundaryField()[patchi];
|
||||
|
||||
fvPatchScalarField& pmu = this->mu_.boundaryField()[patchi];
|
||||
fvPatchScalarField& palpha = this->alpha_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pp = pBf[patchi];
|
||||
fvPatchScalarField& pT = TBf[patchi];
|
||||
fvPatchScalarField& ppsi = psiBf[patchi];
|
||||
fvPatchScalarField& phe = heBf[patchi];
|
||||
fvPatchScalarField& pmu = muBf[patchi];
|
||||
fvPatchScalarField& palpha = alphaBf[patchi];
|
||||
|
||||
if (pT.fixesValue())
|
||||
{
|
||||
@ -74,7 +90,7 @@ void Foam::hePsiThermo<BasicPsiThermo, MixtureType>::calculate()
|
||||
const typename MixtureType::thermoType& mixture_ =
|
||||
this->patchFaceMixture(patchi, facei);
|
||||
|
||||
ph[facei] = mixture_.HE(pp[facei], pT[facei]);
|
||||
phe[facei] = mixture_.HE(pp[facei], pT[facei]);
|
||||
|
||||
ppsi[facei] = mixture_.psi(pp[facei], pT[facei]);
|
||||
pmu[facei] = mixture_.mu(pp[facei], pT[facei]);
|
||||
@ -88,7 +104,7 @@ void Foam::hePsiThermo<BasicPsiThermo, MixtureType>::calculate()
|
||||
const typename MixtureType::thermoType& mixture_ =
|
||||
this->patchFaceMixture(patchi, facei);
|
||||
|
||||
pT[facei] = mixture_.THE(ph[facei], pp[facei], pT[facei]);
|
||||
pT[facei] = mixture_.THE(phe[facei], pp[facei], pT[facei]);
|
||||
|
||||
ppsi[facei] = mixture_.psi(pp[facei], pT[facei]);
|
||||
pmu[facei] = mixture_.mu(pp[facei], pT[facei]);
|
||||
|
||||
@ -58,17 +58,36 @@ void Foam::heRhoThermo<BasicPsiThermo, MixtureType>::calculate()
|
||||
alphaCells[celli] = mixture_.alphah(pCells[celli], TCells[celli]);
|
||||
}
|
||||
|
||||
volScalarField::GeometricBoundaryField& pBf =
|
||||
this->p_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& TBf =
|
||||
this->T_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& psiBf =
|
||||
this->psi_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& rhoBf =
|
||||
this->rho_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& heBf =
|
||||
this->he().boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& muBf =
|
||||
this->mu_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& alphaBf =
|
||||
this->alpha_.boundaryFieldRef();
|
||||
|
||||
forAll(this->T_.boundaryField(), patchi)
|
||||
{
|
||||
fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pT = this->T_.boundaryField()[patchi];
|
||||
fvPatchScalarField& ppsi = this->psi_.boundaryField()[patchi];
|
||||
fvPatchScalarField& prho = this->rho_.boundaryField()[patchi];
|
||||
|
||||
fvPatchScalarField& ph = this->he().boundaryField()[patchi];
|
||||
|
||||
fvPatchScalarField& pmu = this->mu_.boundaryField()[patchi];
|
||||
fvPatchScalarField& palpha = this->alpha_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pp = pBf[patchi];
|
||||
fvPatchScalarField& pT = TBf[patchi];
|
||||
fvPatchScalarField& ppsi = psiBf[patchi];
|
||||
fvPatchScalarField& prho = rhoBf[patchi];
|
||||
fvPatchScalarField& phe = heBf[patchi];
|
||||
fvPatchScalarField& pmu = muBf[patchi];
|
||||
fvPatchScalarField& palpha = alphaBf[patchi];
|
||||
|
||||
if (pT.fixesValue())
|
||||
{
|
||||
@ -77,7 +96,7 @@ void Foam::heRhoThermo<BasicPsiThermo, MixtureType>::calculate()
|
||||
const typename MixtureType::thermoType& mixture_ =
|
||||
this->patchFaceMixture(patchi, facei);
|
||||
|
||||
ph[facei] = mixture_.HE(pp[facei], pT[facei]);
|
||||
phe[facei] = mixture_.HE(pp[facei], pT[facei]);
|
||||
|
||||
ppsi[facei] = mixture_.psi(pp[facei], pT[facei]);
|
||||
prho[facei] = mixture_.rho(pp[facei], pT[facei]);
|
||||
@ -92,7 +111,7 @@ void Foam::heRhoThermo<BasicPsiThermo, MixtureType>::calculate()
|
||||
const typename MixtureType::thermoType& mixture_ =
|
||||
this->patchFaceMixture(patchi, facei);
|
||||
|
||||
pT[facei] = mixture_.THE(ph[facei], pp[facei], pT[facei]);
|
||||
pT[facei] = mixture_.THE(phe[facei], pp[facei], pT[facei]);
|
||||
|
||||
ppsi[facei] = mixture_.psi(pp[facei], pT[facei]);
|
||||
prho[facei] = mixture_.rho(pp[facei], pT[facei]);
|
||||
|
||||
@ -135,11 +135,13 @@ Foam::tmp<Foam::volScalarField> Foam::laminarFlameSpeedModels::Gulders::Su0pTphi
|
||||
Su0[celli] = Su0pTphi(p[celli], Tu[celli], phi, 0.0);
|
||||
}
|
||||
|
||||
forAll(Su0.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& Su0Bf = Su0.boundaryFieldRef();
|
||||
|
||||
forAll(Su0Bf, patchi)
|
||||
{
|
||||
forAll(Su0.boundaryField()[patchi], facei)
|
||||
forAll(Su0Bf[patchi], facei)
|
||||
{
|
||||
Su0.boundaryField()[patchi][facei] =
|
||||
Su0Bf[patchi][facei] =
|
||||
Su0pTphi
|
||||
(
|
||||
p.boundaryField()[patchi][facei],
|
||||
@ -186,11 +188,13 @@ Foam::tmp<Foam::volScalarField> Foam::laminarFlameSpeedModels::Gulders::Su0pTphi
|
||||
Su0[celli] = Su0pTphi(p[celli], Tu[celli], phi[celli], 0.0);
|
||||
}
|
||||
|
||||
forAll(Su0.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& Su0Bf = Su0.boundaryFieldRef();
|
||||
|
||||
forAll(Su0Bf, patchi)
|
||||
{
|
||||
forAll(Su0.boundaryField()[patchi], facei)
|
||||
forAll(Su0Bf[patchi], facei)
|
||||
{
|
||||
Su0.boundaryField()[patchi][facei] =
|
||||
Su0Bf[patchi][facei] =
|
||||
Su0pTphi
|
||||
(
|
||||
p.boundaryField()[patchi][facei],
|
||||
|
||||
@ -135,11 +135,13 @@ Foam::laminarFlameSpeedModels::GuldersEGR::Su0pTphi
|
||||
Su0[celli] = Su0pTphi(p[celli], Tu[celli], phi, 0.0);
|
||||
}
|
||||
|
||||
forAll(Su0.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& Su0Bf = Su0.boundaryFieldRef();
|
||||
|
||||
forAll(Su0Bf, patchi)
|
||||
{
|
||||
forAll(Su0.boundaryField()[patchi], facei)
|
||||
forAll(Su0Bf[patchi], facei)
|
||||
{
|
||||
Su0.boundaryField()[patchi][facei] =
|
||||
Su0Bf[patchi][facei] =
|
||||
Su0pTphi
|
||||
(
|
||||
p.boundaryField()[patchi][facei],
|
||||
@ -188,11 +190,13 @@ Foam::laminarFlameSpeedModels::GuldersEGR::Su0pTphi
|
||||
Su0[celli] = Su0pTphi(p[celli], Tu[celli], phi[celli], egr[celli]);
|
||||
}
|
||||
|
||||
forAll(Su0.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& Su0Bf = Su0.boundaryFieldRef();
|
||||
|
||||
forAll(Su0Bf, patchi)
|
||||
{
|
||||
forAll(Su0.boundaryField()[patchi], facei)
|
||||
forAll(Su0Bf[patchi], facei)
|
||||
{
|
||||
Su0.boundaryField()[patchi][facei] =
|
||||
Su0Bf[patchi][facei] =
|
||||
Su0pTphi
|
||||
(
|
||||
p.boundaryField()[patchi][facei],
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
|
||||
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
@ -185,12 +185,12 @@ updateCoeffs()
|
||||
|
||||
const scalarField nAve(n & ray.dAve());
|
||||
|
||||
ray.Qr().boundaryField()[patchI] += Iw*nAve;
|
||||
ray.Qr().boundaryFieldRef()[patchI] += Iw*nAve;
|
||||
|
||||
const scalarField temissivity = emissivity();
|
||||
|
||||
scalarField& Qem = ray.Qem().boundaryField()[patchI];
|
||||
scalarField& Qin = ray.Qin().boundaryField()[patchI];
|
||||
scalarField& Qem = ray.Qem().boundaryFieldRef()[patchI];
|
||||
scalarField& Qin = ray.Qin().boundaryFieldRef()[patchI];
|
||||
|
||||
const vector& myRayId = dom.IRay(rayId).d();
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
|
||||
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
@ -186,7 +186,7 @@ updateCoeffs()
|
||||
|
||||
const scalarField nAve(n & ray.dAve());
|
||||
|
||||
ray.Qr().boundaryField()[patchI] += Iw*nAve;
|
||||
ray.Qr().boundaryFieldRef()[patchI] += Iw*nAve;
|
||||
|
||||
const scalarField Eb
|
||||
(
|
||||
@ -195,8 +195,8 @@ updateCoeffs()
|
||||
|
||||
scalarField temissivity = emissivity();
|
||||
|
||||
scalarField& Qem = ray.Qem().boundaryField()[patchI];
|
||||
scalarField& Qin = ray.Qin().boundaryField()[patchI];
|
||||
scalarField& Qem = ray.Qem().boundaryFieldRef()[patchI];
|
||||
scalarField& Qin = ray.Qin().boundaryFieldRef()[patchI];
|
||||
|
||||
// Use updated Ir while iterating over rays
|
||||
// avoids to used lagged Qin
|
||||
|
||||
@ -242,12 +242,14 @@ void Foam::radiation::P1::calculate()
|
||||
- 4.0*(e_*physicoChemical::sigma*pow4(T_) ) - E_
|
||||
);
|
||||
|
||||
volScalarField::GeometricBoundaryField& QrBf = Qr_.boundaryFieldRef();
|
||||
|
||||
// Calculate radiative heat flux on boundaries.
|
||||
forAll(mesh_.boundaryMesh(), patchi)
|
||||
{
|
||||
if (!G_.boundaryField()[patchi].coupled())
|
||||
{
|
||||
Qr_.boundaryField()[patchi] =
|
||||
QrBf[patchi] =
|
||||
-gamma.boundaryField()[patchi]
|
||||
*G_.boundaryField()[patchi].snGrad();
|
||||
}
|
||||
|
||||
@ -527,9 +527,9 @@ void Foam::radiation::fvDOM::updateG()
|
||||
{
|
||||
IRay_[rayI].addIntensity();
|
||||
G_ += IRay_[rayI].I()*IRay_[rayI].omega();
|
||||
Qr_.boundaryField() += IRay_[rayI].Qr().boundaryField();
|
||||
Qem_.boundaryField() += IRay_[rayI].Qem().boundaryField();
|
||||
Qin_.boundaryField() += IRay_[rayI].Qin().boundaryField();
|
||||
Qr_.boundaryFieldRef() += IRay_[rayI].Qr().boundaryField();
|
||||
Qem_.boundaryFieldRef() += IRay_[rayI].Qem().boundaryField();
|
||||
Qin_.boundaryFieldRef() += IRay_[rayI].Qin().boundaryField();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -206,7 +206,7 @@ Foam::radiation::radiativeIntensityRay::~radiativeIntensityRay()
|
||||
Foam::scalar Foam::radiation::radiativeIntensityRay::correct()
|
||||
{
|
||||
// Reset boundary heat flux to zero
|
||||
Qr_.boundaryField() = 0.0;
|
||||
Qr_.boundaryFieldRef() = 0.0;
|
||||
|
||||
scalar maxResidual = -GREAT;
|
||||
|
||||
|
||||
@ -407,6 +407,8 @@ void Foam::radiation::viewFactor::calculate()
|
||||
DynamicList<scalar> localCoarseEave(nLocalCoarseFaces_);
|
||||
DynamicList<scalar> localCoarseHoave(nLocalCoarseFaces_);
|
||||
|
||||
volScalarField::GeometricBoundaryField& QrBf = Qr_.boundaryFieldRef();
|
||||
|
||||
forAll(selectedPatches_, i)
|
||||
{
|
||||
label patchID = selectedPatches_[i];
|
||||
@ -414,7 +416,7 @@ void Foam::radiation::viewFactor::calculate()
|
||||
const scalarField& Tp = T_.boundaryField()[patchID];
|
||||
const scalarField& sf = mesh_.magSf().boundaryField()[patchID];
|
||||
|
||||
fvPatchScalarField& QrPatch = Qr_.boundaryField()[patchID];
|
||||
fvPatchScalarField& QrPatch = QrBf[patchID];
|
||||
|
||||
greyDiffusiveViewFactorFixedValueFvPatchScalarField& Qrp =
|
||||
refCast
|
||||
@ -616,7 +618,6 @@ void Foam::radiation::viewFactor::calculate()
|
||||
Pstream::listCombineScatter(q);
|
||||
Pstream::listCombineGather(q, maxEqOp<scalar>());
|
||||
|
||||
|
||||
label globCoarseId = 0;
|
||||
forAll(selectedPatches_, i)
|
||||
{
|
||||
@ -624,7 +625,7 @@ void Foam::radiation::viewFactor::calculate()
|
||||
const polyPatch& pp = mesh_.boundaryMesh()[patchID];
|
||||
if (pp.size() > 0)
|
||||
{
|
||||
scalarField& Qrp = Qr_.boundaryField()[patchID];
|
||||
scalarField& Qrp = QrBf[patchID];
|
||||
const scalarField& sf = mesh_.magSf().boundaryField()[patchID];
|
||||
const labelList& agglom = finalAgglom_[patchID];
|
||||
label nAgglom = max(agglom)+1;
|
||||
@ -655,9 +656,9 @@ void Foam::radiation::viewFactor::calculate()
|
||||
|
||||
if (debug)
|
||||
{
|
||||
forAll(Qr_.boundaryField(), patchID)
|
||||
forAll(QrBf, patchID)
|
||||
{
|
||||
const scalarField& Qrp = Qr_.boundaryField()[patchID];
|
||||
const scalarField& Qrp = QrBf[patchID];
|
||||
const scalarField& magSf = mesh_.magSf().boundaryField()[patchID];
|
||||
scalar heatFlux = gSum(Qrp*magSf);
|
||||
|
||||
|
||||
@ -67,18 +67,40 @@ void Foam::heheuPsiThermo<BasicPsiThermo, MixtureType>::calculate()
|
||||
);
|
||||
}
|
||||
|
||||
volScalarField::GeometricBoundaryField& pBf =
|
||||
this->p_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& TBf =
|
||||
this->T_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& TuBf =
|
||||
this->Tu_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& psiBf =
|
||||
this->psi_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& heBf =
|
||||
this->he().boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& heuBf =
|
||||
this->heu().boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& muBf =
|
||||
this->mu_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& alphaBf =
|
||||
this->alpha_.boundaryFieldRef();
|
||||
|
||||
forAll(this->T_.boundaryField(), patchi)
|
||||
{
|
||||
fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pT = this->T_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pTu = this->Tu_.boundaryField()[patchi];
|
||||
fvPatchScalarField& ppsi = this->psi_.boundaryField()[patchi];
|
||||
|
||||
fvPatchScalarField& ph = this->he_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pheu = this->heu_.boundaryField()[patchi];
|
||||
|
||||
fvPatchScalarField& pmu_ = this->mu_.boundaryField()[patchi];
|
||||
fvPatchScalarField& palpha_ = this->alpha_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pp = pBf[patchi];
|
||||
fvPatchScalarField& pT = TBf[patchi];
|
||||
fvPatchScalarField& pTu = TuBf[patchi];
|
||||
fvPatchScalarField& ppsi = psiBf[patchi];
|
||||
fvPatchScalarField& phe = heBf[patchi];
|
||||
fvPatchScalarField& pheu = heuBf[patchi];
|
||||
fvPatchScalarField& pmu = muBf[patchi];
|
||||
fvPatchScalarField& palpha = alphaBf[patchi];
|
||||
|
||||
if (pT.fixesValue())
|
||||
{
|
||||
@ -87,11 +109,11 @@ void Foam::heheuPsiThermo<BasicPsiThermo, MixtureType>::calculate()
|
||||
const typename MixtureType::thermoType& mixture_ =
|
||||
this->patchFaceMixture(patchi, facei);
|
||||
|
||||
ph[facei] = mixture_.HE(pp[facei], pT[facei]);
|
||||
phe[facei] = mixture_.HE(pp[facei], pT[facei]);
|
||||
|
||||
ppsi[facei] = mixture_.psi(pp[facei], pT[facei]);
|
||||
pmu_[facei] = mixture_.mu(pp[facei], pT[facei]);
|
||||
palpha_[facei] = mixture_.alphah(pp[facei], pT[facei]);
|
||||
pmu[facei] = mixture_.mu(pp[facei], pT[facei]);
|
||||
palpha[facei] = mixture_.alphah(pp[facei], pT[facei]);
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -101,11 +123,11 @@ void Foam::heheuPsiThermo<BasicPsiThermo, MixtureType>::calculate()
|
||||
const typename MixtureType::thermoType& mixture_ =
|
||||
this->patchFaceMixture(patchi, facei);
|
||||
|
||||
pT[facei] = mixture_.THE(ph[facei], pp[facei], pT[facei]);
|
||||
pT[facei] = mixture_.THE(phe[facei], pp[facei], pT[facei]);
|
||||
|
||||
ppsi[facei] = mixture_.psi(pp[facei], pT[facei]);
|
||||
pmu_[facei] = mixture_.mu(pp[facei], pT[facei]);
|
||||
palpha_[facei] = mixture_.alphah(pp[facei], pT[facei]);
|
||||
pmu[facei] = mixture_.mu(pp[facei], pT[facei]);
|
||||
palpha[facei] = mixture_.alphah(pp[facei], pT[facei]);
|
||||
|
||||
pTu[facei] =
|
||||
this->patchFaceReactants(patchi, facei)
|
||||
@ -167,9 +189,11 @@ Foam::heheuPsiThermo<BasicPsiThermo, MixtureType>::heheuPsiThermo
|
||||
);
|
||||
}
|
||||
|
||||
forAll(this->heu_.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& heuBf = heu_.boundaryFieldRef();
|
||||
|
||||
forAll(heuBf, patchi)
|
||||
{
|
||||
fvPatchScalarField& pheu = this->heu_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pheu = heuBf[patchi];
|
||||
const fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
const fvPatchScalarField& pTu = this->Tu_.boundaryField()[patchi];
|
||||
|
||||
@ -299,9 +323,11 @@ Foam::heheuPsiThermo<BasicPsiThermo, MixtureType>::Tb() const
|
||||
);
|
||||
}
|
||||
|
||||
forAll(Tb_.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& TbBf = Tb_.boundaryFieldRef();
|
||||
|
||||
forAll(TbBf, patchi)
|
||||
{
|
||||
fvPatchScalarField& pTb = Tb_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pTb = TbBf[patchi];
|
||||
|
||||
const fvPatchScalarField& ph = this->he_.boundaryField()[patchi];
|
||||
const fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
@ -352,9 +378,11 @@ Foam::heheuPsiThermo<BasicPsiThermo, MixtureType>::psiu() const
|
||||
this->cellReactants(celli).psi(pCells[celli], TuCells[celli]);
|
||||
}
|
||||
|
||||
forAll(psiu.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& psiuBf = psiu.boundaryFieldRef();
|
||||
|
||||
forAll(psiuBf, patchi)
|
||||
{
|
||||
fvPatchScalarField& ppsiu = psiu.boundaryField()[patchi];
|
||||
fvPatchScalarField& ppsiu = psiuBf[patchi];
|
||||
|
||||
const fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
const fvPatchScalarField& pTu = this->Tu_.boundaryField()[patchi];
|
||||
@ -405,9 +433,11 @@ Foam::heheuPsiThermo<BasicPsiThermo, MixtureType>::psib() const
|
||||
this->cellReactants(celli).psi(pCells[celli], TbCells[celli]);
|
||||
}
|
||||
|
||||
forAll(psib.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& psibBf = psib.boundaryFieldRef();
|
||||
|
||||
forAll(psibBf, patchi)
|
||||
{
|
||||
fvPatchScalarField& ppsib = psib.boundaryField()[patchi];
|
||||
fvPatchScalarField& ppsib = psibBf[patchi];
|
||||
|
||||
const fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
const fvPatchScalarField& pTb = Tb_.boundaryField()[patchi];
|
||||
@ -460,9 +490,11 @@ Foam::heheuPsiThermo<BasicPsiThermo, MixtureType>::muu() const
|
||||
);
|
||||
}
|
||||
|
||||
forAll(muu_.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& muuBf = muu_.boundaryFieldRef();
|
||||
|
||||
forAll(muuBf, patchi)
|
||||
{
|
||||
fvPatchScalarField& pMuu = muu_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pMuu = muuBf[patchi];
|
||||
const fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
const fvPatchScalarField& pTu = this->Tu_.boundaryField()[patchi];
|
||||
|
||||
@ -517,9 +549,11 @@ Foam::heheuPsiThermo<BasicPsiThermo, MixtureType>::mub() const
|
||||
);
|
||||
}
|
||||
|
||||
forAll(mub_.boundaryField(), patchi)
|
||||
volScalarField::GeometricBoundaryField& mubBf = mub_.boundaryFieldRef();
|
||||
|
||||
forAll(mubBf, patchi)
|
||||
{
|
||||
fvPatchScalarField& pMub = mub_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pMub = mubBf[patchi];
|
||||
const fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
const fvPatchScalarField& pTb = Tb_.boundaryField()[patchi];
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
|
||||
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
@ -74,7 +74,7 @@ wordList psiuReactionThermo::heuBoundaryTypes()
|
||||
|
||||
void psiuReactionThermo::heuBoundaryCorrection(volScalarField& heu)
|
||||
{
|
||||
volScalarField::GeometricBoundaryField& hbf = heu.boundaryField();
|
||||
volScalarField::GeometricBoundaryField& hbf = heu.boundaryFieldRef();
|
||||
|
||||
forAll(hbf, patchi)
|
||||
{
|
||||
|
||||
@ -61,14 +61,28 @@ void Foam::heSolidThermo<BasicSolidThermo, MixtureType>::calculate()
|
||||
mixture_.Cpv(pCells[celli], TCells[celli]);
|
||||
}
|
||||
|
||||
volScalarField::GeometricBoundaryField& pBf =
|
||||
this->p_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& TBf =
|
||||
this->T_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& rhoBf =
|
||||
this->rho_.boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& heBf =
|
||||
this->he().boundaryFieldRef();
|
||||
|
||||
volScalarField::GeometricBoundaryField& alphaBf =
|
||||
this->alpha_.boundaryFieldRef();
|
||||
|
||||
forAll(this->T_.boundaryField(), patchi)
|
||||
{
|
||||
fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pT = this->T_.boundaryField()[patchi];
|
||||
fvPatchScalarField& prho = this->rho_.boundaryField()[patchi];
|
||||
fvPatchScalarField& palpha = this->alpha_.boundaryField()[patchi];
|
||||
|
||||
fvPatchScalarField& ph = this->he_.boundaryField()[patchi];
|
||||
fvPatchScalarField& pp = pBf[patchi];
|
||||
fvPatchScalarField& pT = TBf[patchi];
|
||||
fvPatchScalarField& prho = rhoBf[patchi];
|
||||
fvPatchScalarField& phe = heBf[patchi];
|
||||
fvPatchScalarField& palpha = alphaBf[patchi];
|
||||
|
||||
if (pT.fixesValue())
|
||||
{
|
||||
@ -87,7 +101,7 @@ void Foam::heSolidThermo<BasicSolidThermo, MixtureType>::calculate()
|
||||
);
|
||||
|
||||
|
||||
ph[facei] = mixture_.HE(pp[facei], pT[facei]);
|
||||
phe[facei] = mixture_.HE(pp[facei], pT[facei]);
|
||||
prho[facei] = volMixture_.rho(pp[facei], pT[facei]);
|
||||
|
||||
palpha[facei] =
|
||||
@ -111,7 +125,7 @@ void Foam::heSolidThermo<BasicSolidThermo, MixtureType>::calculate()
|
||||
facei
|
||||
);
|
||||
|
||||
pT[facei] = mixture_.THE(ph[facei], pp[facei] ,pT[facei]);
|
||||
pT[facei] = mixture_.THE(phe[facei], pp[facei] ,pT[facei]);
|
||||
prho[facei] = volMixture_.rho(pp[facei], pT[facei]);
|
||||
|
||||
palpha[facei] =
|
||||
@ -219,9 +233,11 @@ Foam::heSolidThermo<BasicSolidThermo, MixtureType>::Kappa() const
|
||||
).Kappa(pCells[celli], TCells[celli]);
|
||||
}
|
||||
|
||||
forAll(Kappa.boundaryField(), patchi)
|
||||
volVectorField::GeometricBoundaryField& KappaBf = Kappa.boundaryFieldRef();
|
||||
|
||||
forAll(KappaBf, patchi)
|
||||
{
|
||||
vectorField& Kappap = Kappa.boundaryField()[patchi];
|
||||
vectorField& Kappap = KappaBf[patchi];
|
||||
const scalarField& pT = this->T_.boundaryField()[patchi];
|
||||
const scalarField& pp = this->p_.boundaryField()[patchi];
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
|
||||
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
@ -48,7 +48,7 @@ const Foam::scalar Foam::interfaceProperties::convertToRad =
|
||||
void Foam::interfaceProperties::correctContactAngle
|
||||
(
|
||||
surfaceVectorField::GeometricBoundaryField& nHatb,
|
||||
surfaceVectorField::GeometricBoundaryField& gradAlphaf
|
||||
const surfaceVectorField::GeometricBoundaryField& gradAlphaf
|
||||
) const
|
||||
{
|
||||
const fvMesh& mesh = alpha1_.mesh();
|
||||
@ -128,7 +128,7 @@ void Foam::interfaceProperties::calculateK()
|
||||
// (gradAlphaf + deltaN_*vector(0, 0, 1)
|
||||
// *sign(gradAlphaf.component(vector::Z)))/(mag(gradAlphaf) + deltaN_)
|
||||
// );
|
||||
correctContactAngle(nHatfv.boundaryField(), gradAlphaf.boundaryField());
|
||||
correctContactAngle(nHatfv.boundaryFieldRef(), gradAlphaf.boundaryField());
|
||||
|
||||
// Face unit interface normal flux
|
||||
nHatf_ = nHatfv & Sf;
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
|
||||
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
|
||||
\\/ M anipulation |
|
||||
-------------------------------------------------------------------------------
|
||||
License
|
||||
@ -86,7 +86,7 @@ class interfaceProperties
|
||||
void correctContactAngle
|
||||
(
|
||||
surfaceVectorField::GeometricBoundaryField& nHat,
|
||||
surfaceVectorField::GeometricBoundaryField& gradAlphaf
|
||||
const surfaceVectorField::GeometricBoundaryField& gradAlphaf
|
||||
) const;
|
||||
|
||||
//- Re-calculate the interface curvature
|
||||
|
||||
Reference in New Issue
Block a user