tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
noConvectionScheme<Type>::interpolate
(
const surfaceScalarField&,
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
return tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
(
new GeometricField<Type, fvsPatchField, surfaceMesh>
(
IOobject
(
"interpolate("+vf.name()+')',
vf.instance(),
vf.db()
),
vf.mesh(),
dimensioned<Type>
(
"0",
vf.dimensions(),
pTraits<Type>::zero
)
)
);
}
tmp<GeometricField<Type, PatchField, GeoMesh> > transform
(
const GeometricField<tensor, PatchField, GeoMesh>& trf,
const GeometricField<Type, PatchField, GeoMesh>& tf
)
{
tmp<GeometricField<Type, PatchField, GeoMesh> > tranf
(
new GeometricField<Type, PatchField, GeoMesh>
(
IOobject
(
"transform(" + trf.name() + ',' + tf.name() + ')',
tf.instance(),
tf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
tf.mesh(),
tf.dimensions()
)
);
transform(tranf(), trf, tf);
return tranf;
}
Foam::tmp
<
Foam::GeometricField
<
typename Foam::outerProduct<Foam::vector, Type>::type,
Foam::fvPatchField,
Foam::volMesh
>
>
Foam::fv::gaussGrad<Type>::gradf
(
const GeometricField<Type, fvsPatchField, surfaceMesh>& ssf,
const word& name
)
{
typedef typename outerProduct<vector, Type>::type GradType;
const fvMesh& mesh = ssf.mesh();
tmp<GeometricField<GradType, fvPatchField, volMesh> > tgGrad
(
new GeometricField<GradType, fvPatchField, volMesh>
(
IOobject
(
name,
ssf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensioned<GradType>
(
"0",
ssf.dimensions()/dimLength,
pTraits<GradType>::zero
),
zeroGradientFvPatchField<GradType>::typeName
)
);
GeometricField<GradType, fvPatchField, volMesh>& gGrad = tgGrad();
const labelUList& owner = mesh.owner();
const labelUList& neighbour = mesh.neighbour();
const vectorField& Sf = mesh.Sf();
Field<GradType>& igGrad = gGrad;
const Field<Type>& issf = ssf;
forAll(owner, facei)
{
GradType Sfssf = Sf[facei]*issf[facei];
igGrad[owner[facei]] += Sfssf;
igGrad[neighbour[facei]] -= Sfssf;
}
tmp
<
GeometricField
<
typename outerProduct<vector,Type>::type, fvPatchField, volMesh
>
>
reconstruct
(
const GeometricField<Type, fvsPatchField, surfaceMesh>& ssf
)
{
typedef typename outerProduct<vector, Type>::type GradType;
const fvMesh& mesh = ssf.mesh();
const labelUList& owner = mesh.owner();
const labelUList& neighbour = mesh.neighbour();
const volVectorField& C = mesh.C();
const surfaceVectorField& Cf = mesh.Cf();
tmp<GeometricField<GradType, fvPatchField, volMesh>> treconField
(
new GeometricField<GradType, fvPatchField, volMesh>
(
IOobject
(
"reconstruct("+ssf.name()+')',
ssf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensioned<GradType>
(
"0",
ssf.dimensions()/dimArea,
Zero
),
extrapolatedCalculatedFvPatchField<GradType>::typeName
)
);
Field<GradType>& rf = treconField();
forAll(owner, facei)
{
label own = owner[facei];
label nei = neighbour[facei];
rf[own] += (Cf[facei] - C[own])*ssf[facei];
rf[nei] -= (Cf[facei] - C[nei])*ssf[facei];
}
tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
correctedSnGrad<Type>::correction
(
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
const fvMesh& mesh = this->mesh();
// construct GeometricField<Type, fvsPatchField, surfaceMesh>
tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > tssf
(
new GeometricField<Type, fvsPatchField, surfaceMesh>
(
IOobject
(
"snGradCorr("+vf.name()+')',
vf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
vf.dimensions()*mesh.deltaCoeffs().dimensions()
)
);
GeometricField<Type, fvsPatchField, surfaceMesh>& ssf = tssf();
for (direction cmpt = 0; cmpt < pTraits<Type>::nComponents; cmpt++)
{
ssf.replace
(
cmpt,
mesh.correctionVectors()
& linear
<
typename
outerProduct<vector, typename pTraits<Type>::cmptType>::type
>(mesh).interpolate
(
gradScheme<typename pTraits<Type>::cmptType>::New
(
mesh,
mesh.schemesDict().gradScheme(ssf.name())
)()
//gaussGrad<typename pTraits<Type>::cmptType>(mesh)
.grad(vf.component(cmpt))
)
);
}
return tssf;
}
tmp<GeometricField<Type, faePatchField, edgeMesh> >
correctedLnGrad<Type>::correction
(
const GeometricField<Type, faPatchField, areaMesh>& vf
) const
{
const faMesh& mesh = this->mesh();
// construct GeometricField<Type, faePatchField, edgeMesh>
tmp<GeometricField<Type, faePatchField, edgeMesh> > tssf
(
new GeometricField<Type, faePatchField, edgeMesh>
(
IOobject
(
"lnGradCorr("+vf.name()+')',
vf.instance(),
vf.db()
),
mesh,
vf.dimensions()*mesh.deltaCoeffs().dimensions()
)
);
GeometricField<Type, faePatchField, edgeMesh>& ssf = tssf();
for (direction cmpt = 0; cmpt < pTraits<Type>::nComponents; cmpt++)
{
ssf.replace
(
cmpt,
mesh.correctionVectors()
& linearEdgeInterpolation
<
typename
outerProduct<vector, typename pTraits<Type>::cmptType>::type
>(mesh).interpolate
(
gradScheme<typename pTraits<Type>::cmptType>::New
(
mesh,
mesh.gradScheme(ssf.name())
)()
// gaussGrad<typename pTraits<Type>::cmptType>(mesh)
.grad(vf.component(cmpt))
)
);
}
return tssf;
}
tmp<GeometricField<Type, fvPatchField, volMesh> >
average
(
const GeometricField<Type, fvsPatchField, surfaceMesh>& ssf
)
{
const fvMesh& mesh = ssf.mesh();
tmp<GeometricField<Type, fvPatchField, volMesh> > taverage
(
new GeometricField<Type, fvPatchField, volMesh>
(
IOobject
(
"average("+ssf.name()+')',
ssf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
ssf.dimensions()
)
);
GeometricField<Type, fvPatchField, volMesh>& av = taverage();
av.internalField() =
(
surfaceSum(mesh.magSf()*ssf)/surfaceSum(mesh.magSf())
)().internalField();
typename GeometricField<Type, fvPatchField, volMesh>::
GeometricBoundaryField& bav = av.boundaryField();
forAll(bav, patchi)
{
bav[patchi] = ssf.boundaryField()[patchi];
}
av.correctBoundaryConditions();
return taverage;
}
tmp<tetFemMatrix<Type> > tetFem::laplacianTrace
(
GeometricField<Type, tetPolyPatchField, tetPointMesh>& vf
)
{
elementScalarField Gamma
(
IOobject
(
"1",
vf.instance(),
vf.db(),
IOobject::NO_READ
),
vf.mesh(),
dimensionedScalar("1", dimless, 1.0)
);
return tetFem::laplacianTrace(Gamma, vf);
}
tmp<GeometricField<Type, faePatchField, edgeMesh> >
lnGradScheme<Type>::lnGrad
(
const GeometricField<Type, faPatchField, areaMesh>& vf,
const tmp<edgeScalarField>& tdeltaCoeffs,
const word& lnGradName
)
{
const faMesh& mesh = vf.mesh();
// construct GeometricField<Type, faePatchField, edgeMesh>
tmp<GeometricField<Type, faePatchField, edgeMesh> > tssf
(
new GeometricField<Type, faePatchField, edgeMesh>
(
IOobject
(
lnGradName + vf.name() + ')',
vf.instance(),
vf.db(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
vf.dimensions()*tdeltaCoeffs().dimensions()
)
);
GeometricField<Type, faePatchField, edgeMesh>& ssf = tssf();
// set reference to difference factors array
const scalarField& deltaCoeffs = tdeltaCoeffs().internalField();
// owner/neighbour addressing
const unallocLabelList& owner = mesh.owner();
const unallocLabelList& neighbour = mesh.neighbour();
forAll(owner, faceI)
{
ssf[faceI] =
deltaCoeffs[faceI]*(vf[neighbour[faceI]] - vf[owner[faceI]]);
}
tmp<GeometricField<Type, fvsPatchField, surfaceMesh>>
snGradScheme<Type>::snGrad
(
const GeometricField<Type, fvPatchField, volMesh>& vf,
const tmp<surfaceScalarField>& tdeltaCoeffs,
const word& snGradName
)
{
const fvMesh& mesh = vf.mesh();
// construct GeometricField<Type, fvsPatchField, surfaceMesh>
tmp<GeometricField<Type, fvsPatchField, surfaceMesh>> tsf
(
new GeometricField<Type, fvsPatchField, surfaceMesh>
(
IOobject
(
snGradName + "("+vf.name()+')',
vf.instance(),
vf.mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
vf.dimensions()*tdeltaCoeffs().dimensions()
)
);
GeometricField<Type, fvsPatchField, surfaceMesh>& ssf = tsf.ref();
// set reference to difference factors array
const scalarField& deltaCoeffs = tdeltaCoeffs().internalField();
// owner/neighbour addressing
const labelUList& owner = mesh.owner();
const labelUList& neighbour = mesh.neighbour();
forAll(owner, facei)
{
ssf[facei] =
deltaCoeffs[facei]*(vf[neighbour[facei]] - vf[owner[facei]]);
}
tmp<tetFemMatrix<Type> > tetFem::laplacianTrace
(
const dimensionedScalar& gamma,
GeometricField<Type, tetPolyPatchField, tetPointMesh>& vf
)
{
elementScalarField Gamma
(
IOobject
(
gamma.name(),
vf.instance(),
vf.db(),
IOobject::NO_READ
),
vf.mesh(),
gamma
);
return tetFem::laplacianTrace(Gamma, vf);
}
tmp<faMatrix<Type> >
laplacian
(
const dimensionedScalar& gamma,
GeometricField<Type, faPatchField, areaMesh>& vf
)
{
edgeScalarField Gamma
(
IOobject
(
gamma.name(),
vf.instance(),
vf.db(),
IOobject::NO_READ
),
vf.mesh(),
gamma
);
return fam::laplacian(Gamma, vf);
}
Foam::tmp<Foam::GeometricField<Type, Foam::fvsPatchField, Foam::surfaceMesh>>
Foam::fv::correctedSnGrad<Type>::correction
(
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
const fvMesh& mesh = this->mesh();
// construct GeometricField<Type, fvsPatchField, surfaceMesh>
tmp<GeometricField<Type, fvsPatchField, surfaceMesh>> tssf
(
new GeometricField<Type, fvsPatchField, surfaceMesh>
(
IOobject
(
"snGradCorr("+vf.name()+')',
vf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
vf.dimensions()*mesh.nonOrthDeltaCoeffs().dimensions()
)
);
GeometricField<Type, fvsPatchField, surfaceMesh>& ssf = tssf.ref();
for (direction cmpt = 0; cmpt < pTraits<Type>::nComponents; cmpt++)
{
ssf.replace
(
cmpt,
correctedSnGrad<typename pTraits<Type>::cmptType>(mesh)
.fullGradCorrection(vf.component(cmpt))
);
}
return tssf;
}
tmp<fvMatrix<Type> >
laplacian
(
const dimensioned<GType>& gamma,
GeometricField<Type, fvPatchField, volMesh>& vf
)
{
GeometricField<GType, fvsPatchField, surfaceMesh> Gamma
(
IOobject
(
gamma.name(),
vf.instance(),
vf.mesh(),
IOobject::NO_READ
),
vf.mesh(),
gamma
);
return fvm::laplacian(Gamma, vf);
}
tmp
<
GeometricField
<
typename outerProduct<vector,Type>::type, fvPatchField, volMesh
>
>
reconstruct
(
const GeometricField<Type, fvsPatchField, surfaceMesh>& ssf
)
{
typedef typename outerProduct<vector, Type>::type GradType;
const fvMesh& mesh = ssf.mesh();
tmp<GeometricField<GradType, fvPatchField, volMesh> > treconField
(
new GeometricField<GradType, fvPatchField, volMesh>
(
IOobject
(
"volIntegrate("+ssf.name()+')',
ssf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
inv(surfaceSum(sqr(mesh.Sf())/mesh.magSf()))
& surfaceSum((mesh.Sf()/mesh.magSf())*ssf),
zeroGradientFvPatchField<GradType>::typeName
)
);
treconField().correctBoundaryConditions();
return treconField;
}
tmp<GeometricField<Type, fvPatchField, volMesh> > cellReduce
(
const GeometricField<Type, fvsPatchField, surfaceMesh>& ssf,
const CombineOp& cop
)
{
typedef GeometricField<Type, fvPatchField, volMesh> volFieldType;
const fvMesh& mesh = ssf.mesh();
tmp<volFieldType> tresult
(
new volFieldType
(
IOobject
(
"cellReduce(" + ssf.name() + ')',
ssf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensioned<Type>("0", ssf.dimensions(), pTraits<Type>::zero),
zeroGradientFvPatchField<Type>::typeName
)
);
volFieldType& result = tresult();
const labelUList& own = mesh.owner();
const labelUList& nbr = mesh.neighbour();
forAll(own, i)
{
label cellI = own[i];
cop(result[cellI], ssf[i]);
}
tmp<GeometricField<Type, fvPatchField, volMesh> >
laplacian
(
const dimensioned<GType>& gamma,
const GeometricField<Type, fvPatchField, volMesh>& vf,
const word& name
)
{
GeometricField<GType, fvsPatchField, surfaceMesh> Gamma
(
IOobject
(
gamma.name(),
vf.instance(),
vf.mesh(),
IOobject::NO_READ
),
vf.mesh(),
gamma
);
return fvc::laplacian(Gamma, vf, name);
}
Foam::tmp<Foam::GeometricField<Type, Foam::fvsPatchField, Foam::surfaceMesh>>
Foam::fv::faceCorrectedSnGrad<Type>::fullGradCorrection
(
const GeometricField<Type, fvPatchField, volMesh>& vf
) const
{
const fvMesh& mesh = this->mesh();
GeometricField<Type, pointPatchField, pointMesh> pvf
(
volPointInterpolation::New(mesh).interpolate(vf)
);
// construct GeometricField<Type, fvsPatchField, surfaceMesh>
tmp<GeometricField<Type, fvsPatchField, surfaceMesh>> tsfCorr
(
new GeometricField<Type, fvsPatchField, surfaceMesh>
(
IOobject
(
"snGradCorr("+vf.name()+')',
vf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
vf.dimensions()*mesh.nonOrthDeltaCoeffs().dimensions()
)
);
Field<Type>& sfCorr = tsfCorr.ref().internalField();
const pointField& points = mesh.points();
const faceList& faces = mesh.faces();
const vectorField& Sf = mesh.Sf().internalField();
const vectorField& C = mesh.C().internalField();
const scalarField& magSf = mesh.magSf().internalField();
const labelList& owner = mesh.owner();
const labelList& neighbour = mesh.neighbour();
forAll(sfCorr, facei)
{
typename outerProduct<vector, Type>::type fgrad
(
outerProduct<vector, Type>::type::zero
);
const face& fi = faces[facei];
vector nf(Sf[facei]/magSf[facei]);
for (label pi=0; pi<fi.size(); pi++)
{
// Next point index
label pj = (pi+1)%fi.size();
// Edge normal in plane of face
vector edgen(nf^(points[fi[pj]] - points[fi[pi]]));
// Edge centre field value
Type pvfe(0.5*(pvf[fi[pj]] + pvf[fi[pi]]));
// Integrate face gradient
fgrad += edgen*pvfe;
}
// Finalize face-gradient by dividing by face area
fgrad /= magSf[facei];
// Calculate correction vector
vector dCorr(C[neighbour[facei]] - C[owner[facei]]);
dCorr /= (nf & dCorr);
// if (mag(dCorr) > 2) dCorr *= 2/mag(dCorr);
sfCorr[facei] = dCorr&fgrad;
}
tmp
<
GeometricField
<
typename outerProduct<vector, Type>::type, fvPatchField, volMesh
>
>
leastSquaresSolidInterfaceGrad<Type>::calcGrad
(
const GeometricField<Type, fvPatchField, volMesh>& vsf,
const word& name
) const
{
typedef typename outerProduct<vector, Type>::type GradType;
const fvMesh& mesh = vsf.mesh();
tmp<GeometricField<GradType, fvPatchField, volMesh> > tlsGrad
(
new GeometricField<GradType, fvPatchField, volMesh>
(
IOobject
(
name,
vsf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensioned<GradType>
(
"zero",
vsf.dimensions()/dimLength,
pTraits<GradType>::zero
),
zeroGradientFvPatchField<GradType>::typeName
)
);
GeometricField<GradType, fvPatchField, volMesh>& lsGrad = tlsGrad();
// Get reference to least square vectors
const leastSquaresSolidInterfaceVectors& lsv =
leastSquaresSolidInterfaceVectors::New(mesh);
const surfaceVectorField& ownLs = lsv.pVectors();
const surfaceVectorField& neiLs = lsv.nVectors();
const unallocLabelList& own = mesh.owner();
const unallocLabelList& nei = mesh.neighbour();
// interface fields
const solidInterface& solInt =
mesh.objectRegistry::lookupObject<IOReferencer<solidInterface> >
("solidInterface")();
const labelList& interfaceFacesMap = solInt.indicatorFieldMap();
const labelList& interfaceProcPatchMap = solInt.processorPatchMap();
const labelListList& interfaceProcPatchFacesMap =
solInt.processorPatchFacesMap();
const vectorField& interfaceDispVec = solInt.interfaceDisplacement();
const List<vectorField>& procInterDispVec =
solInt.processorInterfaceDisplacement();
// interface disp must be vector so
// this is a quick hack
Field<Type> interfaceDisp(interfaceDispVec.size(), pTraits<Type>::zero);
if (pTraits<Type>::typeName != vector::typeName)
{
FatalError
<< "leastSquaresSolidInterface::grad() may only be used "
"with a volVectorField" << exit(FatalError);
}
for (direction cmpt = 0; cmpt < pTraits<vector>::nComponents; cmpt++)
{
interfaceDisp.replace
(
cmpt,
interfaceDispVec.component(cmpt)
);
}
List<Field<Type> > procInterDisp
(procInterDispVec.size(), Field<Type>(0, pTraits<Type>::zero));
forAll(procInterDisp, patchi)
{
procInterDisp[patchi].setSize
(procInterDispVec[patchi].size(), pTraits<Type>::zero);
for (direction cmpt = 0; cmpt < pTraits<vector>::nComponents; cmpt++)
{
procInterDisp[patchi].replace
(
cmpt,
procInterDispVec[patchi].component(cmpt)
);
}
}
Foam::tmp
<
Foam::GeometricField
<
typename Foam::outerProduct<Foam::vector, Type>::type,
Foam::fvPatchField,
Foam::volMesh
>
>
Foam::fv::fourthGrad<Type>::calcGrad
(
const GeometricField<Type, fvPatchField, volMesh>& vsf,
const word& name
) const
{
// The fourth-order gradient is calculated in two passes. First,
// the standard least-square gradient is assembled. Then, the
// fourth-order correction is added to the second-order accurate
// gradient to complete the accuracy.
typedef typename outerProduct<vector, Type>::type GradType;
const fvMesh& mesh = vsf.mesh();
// Assemble the second-order least-square gradient
// Calculate the second-order least-square gradient
tmp<GeometricField<GradType, fvPatchField, volMesh> > tsecondfGrad
= leastSquaresGrad<Type>(mesh).grad(vsf);
const GeometricField<GradType, fvPatchField, volMesh>& secondfGrad =
tsecondfGrad();
tmp<GeometricField<GradType, fvPatchField, volMesh> > tfGrad
(
new GeometricField<GradType, fvPatchField, volMesh>
(
IOobject
(
name,
vsf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
secondfGrad
)
);
GeometricField<GradType, fvPatchField, volMesh>& fGrad = tfGrad();
const vectorField& C = mesh.C();
const surfaceScalarField& lambda = mesh.weights();
// Get reference to least square vectors
const leastSquaresVectors& lsv = leastSquaresVectors::New(mesh);
const surfaceVectorField& ownLs = lsv.pVectors();
const surfaceVectorField& neiLs = lsv.nVectors();
// owner/neighbour addressing
const labelUList& own = mesh.owner();
const labelUList& nei = mesh.neighbour();
// Assemble the fourth-order gradient
// Internal faces
forAll(own, facei)
{
Type dDotGradDelta = 0.5*
(
(C[nei[facei]] - C[own[facei]])
& (secondfGrad[nei[facei]] - secondfGrad[own[facei]])
);
fGrad[own[facei]] -= lambda[facei]*ownLs[facei]*dDotGradDelta;
fGrad[nei[facei]] -= (1.0 - lambda[facei])*neiLs[facei]*dDotGradDelta;
}
tmp
<
GeometricField
<
typename outerProduct<vector, Type>::type,
tetPolyPatchField,
tetPointMesh
>
>
tetFec::grad
(
const GeometricField<Type, tetPolyPatchField, tetPointMesh>& psi
)
{
typedef typename outerProduct<vector, Type>::type GradType;
const tetPolyMesh& tetMesh = psi.mesh();
tmp<GeometricField<GradType, tetPolyPatchField, tetPointMesh> > tFemGrad
(
new GeometricField<GradType, tetPolyPatchField, tetPointMesh>
(
IOobject
(
"grad("+psi.name()+')',
psi.instance(),
tetMesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
tetMesh,
dimensioned<GradType>
(
"zero",
psi.dimensions()/dimLength,
pTraits<GradType>::zero
)
)
);
GeometricField<GradType, tetPolyPatchField, tetPointMesh>& femGrad =
tFemGrad();
pointField points = tetMesh.points();
cellShapeList tetCellShapes = tetMesh.tetCells();
scalarField weights (points.size(), 0.0);
forAll (tetCellShapes, tetI)
{
cellShape& curShape = tetCellShapes[tetI];
tetPointRef curTetrahedron
(
points[curShape[0]],
points[curShape[1]],
points[curShape[2]],
points[curShape[3]]
);
GradType tetGrad =
- (1.0/3.0)*
(
curTetrahedron.Sa()*psi.internalField()[curShape[0]]
+ curTetrahedron.Sb()*psi.internalField()[curShape[1]]
+ curTetrahedron.Sc()*psi.internalField()[curShape[2]]
+ curTetrahedron.Sd()*psi.internalField()[curShape[3]]
)/curTetrahedron.mag();
forAll (curShape, pointI)
{
scalar weight =
curTetrahedron.mag()/
mag
(
points[curShape[pointI]]
- curShape.centre(points)
);
femGrad.internalField()[curShape[pointI]] += weight*tetGrad;
weights[curShape[pointI]] += weight;
}
Foam::tmp<Foam::SlicedGeometricField
<
Type,
Foam::fvPatchField,
Foam::slicedFvPatchField,
Foam::volMesh
>>
Foam::isoSurface::adaptPatchFields
(
const GeometricField<Type, fvPatchField, volMesh>& fld
) const
{
typedef SlicedGeometricField
<
Type,
fvPatchField,
slicedFvPatchField,
volMesh
> FieldType;
tmp<FieldType> tsliceFld
(
new FieldType
(
IOobject
(
fld.name(),
fld.instance(),
fld.db(),
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
fld, // internal field
true // preserveCouples
)
);
FieldType& sliceFld = tsliceFld.ref();
const fvMesh& mesh = fld.mesh();
const polyBoundaryMesh& patches = mesh.boundaryMesh();
forAll(patches, patchI)
{
const polyPatch& pp = patches[patchI];
if
(
isA<emptyPolyPatch>(pp)
&& pp.size() != sliceFld.boundaryField()[patchI].size()
)
{
// Clear old value. Cannot resize it since is a slice.
sliceFld.boundaryField().set(patchI, NULL);
// Set new value we can change
sliceFld.boundaryField().set
(
patchI,
new calculatedFvPatchField<Type>
(
mesh.boundary()[patchI],
sliceFld
)
);
// Note: cannot use patchInternalField since uses emptyFvPatch::size
// Do our own internalField instead.
const labelUList& faceCells =
mesh.boundary()[patchI].patch().faceCells();
Field<Type>& pfld = sliceFld.boundaryField()[patchI];
pfld.setSize(faceCells.size());
forAll(faceCells, i)
{
pfld[i] = sliceFld[faceCells[i]];
}
}
else if (isA<cyclicPolyPatch>(pp))
tmp
<
GeometricField
<
typename outerProduct<vector, Type>::type, fvPatchField, volMesh
>
>
extendedLeastSquaresGrad<Type>::grad
(
const GeometricField<Type, fvPatchField, volMesh>& vsf
) const
{
typedef typename outerProduct<vector, Type>::type GradType;
const fvMesh& mesh = vsf.mesh();
tmp<GeometricField<GradType, fvPatchField, volMesh> > tlsGrad
(
new GeometricField<GradType, fvPatchField, volMesh>
(
IOobject
(
"grad("+vsf.name()+')',
vsf.instance(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensioned<GradType>
(
"zero",
vsf.dimensions()/dimLength,
pTraits<GradType>::zero
),
zeroGradientFvPatchField<GradType>::typeName
)
);
GeometricField<GradType, fvPatchField, volMesh>& lsGrad = tlsGrad();
// Get reference to least square vectors
const extendedLeastSquaresVectors& lsv = extendedLeastSquaresVectors::New
(
mesh,
minDet_
);
const surfaceVectorField& ownLs = lsv.pVectors();
const surfaceVectorField& neiLs = lsv.nVectors();
const unallocLabelList& owner = mesh.owner();
const unallocLabelList& neighbour = mesh.neighbour();
forAll(owner, facei)
{
label own = owner[facei];
label nei = neighbour[facei];
Type deltaVsf = vsf[nei] - vsf[own];
lsGrad[own] += ownLs[facei]*deltaVsf;
lsGrad[nei] -= neiLs[facei]*deltaVsf;
}
