void Foam::cyclicAMIFvPatchField<Type>::updateInterfaceMatrix
(
scalarField& result,
const scalarField& psiInternal,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes
) const
{
const labelUList& nbrFaceCells =
cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().faceCells();
scalarField pnf(psiInternal, nbrFaceCells);
// Transform according to the transformation tensors
transformCoupleField(pnf, cmpt);
if (cyclicAMIPatch_.applyLowWeightCorrection())
{
scalarField pif(psiInternal, cyclicAMIPatch_.faceCells());
pnf = cyclicAMIPatch_.interpolate(pnf, pif);
}
else
{
pnf = cyclicAMIPatch_.interpolate(pnf);
}
// Multiply the field by coefficients and add into the result
const labelUList& faceCells = cyclicAMIPatch_.faceCells();
forAll(faceCells, elemI)
{
result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
}
void Foam::cyclicACMIFvPatchField<Type>::updateInterfaceMatrix
(
gpuField<Type>& result,
const gpuField<Type>& psiInternal,
const scalargpuField& coeffs,
const Pstream::commsTypes
) const
{
// note: only applying coupled contribution
const labelgpuList& nbrFaceCellsCoupled =
cyclicACMIPatch_.cyclicACMIPatch().neighbPatch().getFaceCells();
gpuField<Type> pnf(psiInternal, nbrFaceCellsCoupled);
// Transform according to the transformation tensors
transformCoupleField(pnf);
pnf = cyclicACMIPatch_.interpolate(pnf);
matrixPatchOperation
(
this->patch().index(),
result,
this->patch().boundaryMesh().mesh().lduAddr(),
matrixInterfaceFunctor<Type>
(
coeffs.data(),
pnf.data()
)
);
}
void cyclicFvPatchField<Type>::updateInterfaceMatrix
(
const scalarField& psiInternal,
scalarField& result,
const lduMatrix&,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes
) const
{
scalarField pnf(this->size());
label sizeby2 = this->size()/2;
const unallocLabelList& faceCells = cyclicPatch_.faceCells();
for (label facei=0; facei<sizeby2; facei++)
{
pnf[facei] = psiInternal[faceCells[facei + sizeby2]];
pnf[facei + sizeby2] = psiInternal[faceCells[facei]];
}
// Transform according to the transformation tensors
transformCoupleField(pnf, cmpt);
// Multiply the field by coefficients and add into the result
forAll(faceCells, elemI)
{
result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
}
Foam::tmp<Foam::Field<Type>>
Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
{
const Field<Type>& iField = this->primitiveField();
const labelUList& nbrFaceCells =
cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().faceCells();
Field<Type> pnf(iField, nbrFaceCells);
tmp<Field<Type>> tpnf;
if (cyclicAMIPatch_.applyLowWeightCorrection())
{
tpnf = cyclicAMIPatch_.interpolate(pnf, this->patchInternalField()());
}
else
{
tpnf = cyclicAMIPatch_.interpolate(pnf);
}
if (doTransform())
{
tpnf.ref() = transform(forwardT(), tpnf());
}
return tpnf;
}
void Foam::processorGAMGInterfaceField::updateInterfaceMatrix
(
const scalarField&,
scalarField& result,
const lduMatrix&,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes commsType,
const bool switchToLhs
) const
{
scalarField pnf
(
procInterface_.compressedReceive<scalar>(commsType, coeffs.size())
);
transformCoupleField(pnf, cmpt);
const unallocLabelList& faceCells = procInterface_.faceCells();
if (switchToLhs)
{
forAll(faceCells, elemI)
{
result[faceCells[elemI]] += coeffs[elemI]*pnf[elemI];
}
}
void processorFvPatchField<Type>::updateInterfaceMatrix
(
const scalarField&,
scalarField& result,
const lduMatrix&,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes commsType,
const bool switchToLhs
) const
{
scalarField pnf
(
procPatch_.compressedReceive<scalar>(commsType, this->size())()
);
// Transform according to the transformation tensor
transformCoupleField(pnf, cmpt);
// Multiply the field by coefficients and add into the result
const unallocLabelList& faceCells = this->patch().faceCells();
if (switchToLhs)
{
forAll(faceCells, elemI)
{
result[faceCells[elemI]] += coeffs[elemI]*pnf[elemI];
}
}
void Foam::cyclicGAMGInterfaceField::updateInterfaceMatrix
(
const scalarField& psiInternal,
scalarField& result,
const lduMatrix&,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes
) const
{
scalarField pnf(size());
label sizeby2 = size()/2;
const unallocLabelList& faceCells = cyclicInterface_.faceCells();
for (label facei=0; facei<sizeby2; facei++)
{
pnf[facei] = psiInternal[faceCells[facei + sizeby2]];
pnf[facei + sizeby2] = psiInternal[faceCells[facei]];
}
transformCoupleField(pnf, cmpt);
forAll(faceCells, elemI)
{
result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
}
void Foam::cyclicACMIGAMGInterfaceField::updateInterfaceMatrix
(
scalarField& result,
const scalarField& psiInternal,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes
) const
{
// Get neighbouring field
scalarField pnf
(
cyclicACMIInterface_.neighbPatch().interfaceInternalField(psiInternal)
);
// Transform according to the transformation tensors
transformCoupleField(pnf, cmpt);
if (cyclicACMIInterface_.owner())
{
pnf = cyclicACMIInterface_.AMI().interpolateToSource(pnf);
}
else
{
pnf = cyclicACMIInterface_.neighbPatch().AMI().interpolateToTarget(pnf);
}
const labelUList& faceCells = cyclicACMIInterface_.faceCells();
forAll(faceCells, elemI)
{
result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
}
void Foam::processorCyclicPointPatchField<Type>::swapAddSeparated
(
const Pstream::commsTypes commsType,
Field<Type>& pField
) const
{
if (Pstream::parRun())
{
Field<Type> pnf(this->size());
IPstream::read
(
commsType,
procPatch_.neighbProcNo(),
reinterpret_cast<char*>(pnf.begin()),
pnf.byteSize(),
procPatch_.tag()
);
if (doTransform())
{
const processorCyclicPolyPatch& ppp =
procPatch_.procCyclicPolyPatch();
const tensor& forwardT = ppp.forwardT()[0];
transform(pnf, forwardT, pnf);
}
// All points are separated
this->addToInternalField(pField, pnf);
}
}
void Foam::cyclicACMIGAMGInterfaceField::updateInterfaceMatrix
(
scalargpuField& result,
const scalargpuField& psiInternal,
const scalargpuField& coeffs,
const direction cmpt,
const Pstream::commsTypes
) const
{
// Get neighbouring field
scalargpuField pnf
(
cyclicACMIInterface_.neighbPatch().interfaceInternalField(psiInternal)
);
// Transform according to the transformation tensors
transformCoupleField(pnf, cmpt);
if (cyclicACMIInterface_.owner())
{
pnf = cyclicACMIInterface_.AMI().interpolateToSource(pnf);
}
else
{
pnf = cyclicACMIInterface_.neighbPatch().AMI().interpolateToTarget(pnf);
}
GAMGUpdateInterfaceMatrix
(
result,
coeffs,
pnf,
cyclicACMIInterface_
);
}
void Foam::processorGAMGInterfaceField::updateInterfaceMatrix
(
solveScalarField& result,
const bool add,
const solveScalarField&,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes commsType
) const
{
if (updatedMatrix())
{
return;
}
if
(
commsType == Pstream::commsTypes::nonBlocking
&& !Pstream::floatTransfer
)
{
// Fast path.
if
(
outstandingRecvRequest_ >= 0
&& outstandingRecvRequest_ < Pstream::nRequests()
)
{
UPstream::waitRequest(outstandingRecvRequest_);
}
// Recv finished so assume sending finished as well.
outstandingSendRequest_ = -1;
outstandingRecvRequest_ = -1;
// Consume straight from scalarReceiveBuf_
// Transform according to the transformation tensor
transformCoupleField(scalarReceiveBuf_, cmpt);
// Multiply the field by coefficients and add into the result
addToInternalField(result, !add, coeffs, scalarReceiveBuf_);
}
else
{
solveScalarField pnf
(
procInterface_.compressedReceive<solveScalar>
(
commsType,
coeffs.size()
)
);
transformCoupleField(pnf, cmpt);
addToInternalField(result, !add, coeffs, pnf);
}
const_cast<processorGAMGInterfaceField&>(*this).updatedMatrix() = true;
}
void Foam::jumpCyclicAMIFvPatchField<Type>::updateInterfaceMatrix
(
gpuField<Type>& result,
const gpuField<Type>& psiInternal,
const scalargpuField& coeffs,
const Pstream::commsTypes
) const
{
const labelgpuList& nbrFaceCells =
this->cyclicAMIPatch().cyclicAMIPatch().neighbPatch().getFaceCells();
gpuField<Type> pnf(psiInternal, nbrFaceCells);
if (this->cyclicAMIPatch().applyLowWeightCorrection())
{
pnf =
this->cyclicAMIPatch().interpolate
(
pnf,
this->patchInternalField()()
);
}
else
{
pnf = this->cyclicAMIPatch().interpolate(pnf);
}
// only apply jump to original field
if (&psiInternal == &this->internalField())
{
gpuField<Type> jf(this->jump());
if (!this->cyclicAMIPatch().owner())
{
jf *= -1.0;
}
pnf -= jf;
}
// Transform according to the transformation tensors
this->transformCoupleField(pnf);
// Multiply the field by coefficients and add into the result
matrixPatchOperation
(
this->patch().index(),
result,
this->patch().boundaryMesh().mesh().lduAddr(),
matrixInterfaceFunctor<Type>
(
coeffs.data(),
pnf.data()
)
);
}
void Foam::jumpCyclicAMIFvPatchField<Type>::updateInterfaceMatrix
(
Field<Type>& result,
const Field<Type>& psiInternal,
const scalarField& coeffs,
const Pstream::commsTypes
) const
{
const labelUList& nbrFaceCells =
this->cyclicAMIPatch().cyclicAMIPatch().neighbPatch().faceCells();
Field<Type> pnf(psiInternal, nbrFaceCells);
if (this->cyclicAMIPatch().applyLowWeightCorrection())
{
pnf =
this->cyclicAMIPatch().interpolate
(
pnf,
this->patchInternalField()()
);
}
else
{
pnf = this->cyclicAMIPatch().interpolate(pnf);
}
// only apply jump to original field
if (&psiInternal == &this->internalField())
{
Field<Type> jf(this->jump());
if (!this->cyclicAMIPatch().owner())
{
jf *= -1.0;
}
pnf -= jf;
}
// Transform according to the transformation tensors
this->transformCoupleField(pnf);
// Multiply the field by coefficients and add into the result
const labelUList& faceCells = this->cyclicAMIPatch().faceCells();
forAll(faceCells, elemI)
{
result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
}
void
ProcessorPointPatchField
<PatchField, Mesh, PointPatch, ProcessorPointPatch, MatrixType, Type>::
swapAdd(Field<Type>& pField) const
{
Field<Type> pnf(this->size());
IPstream::read
(
Pstream::blocking,
procPatch_.neighbProcNo(),
reinterpret_cast<char*>(pnf.begin()),
pnf.byteSize()
);
if (doTransform())
{
const labelList& nonGlobalPatchPoints =
procPatch_.nonGlobalPatchPoints();
const processorPolyPatch& ppp = procPatch_.procPolyPatch();
const labelListList& pointFaces = ppp.pointFaces();
const tensorField& forwardT = ppp.forwardT();
if (forwardT.size() == 1)
{
transform(pnf, forwardT[0], pnf);
}
else
{
forAll(nonGlobalPatchPoints, pfi)
{
pnf[pfi] = transform
(
forwardT[pointFaces[nonGlobalPatchPoints[pfi]][0]],
pnf[pfi]
);
}
}
}
void Foam::cyclicGAMGInterfaceField::updateInterfaceMatrix
(
scalarField& result,
const scalarField& psiInternal,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes
) const
{
// Get neighbouring field
scalarField pnf
(
cyclicInterface_.neighbPatch().interfaceInternalField(psiInternal)
);
transformCoupleField(pnf, cmpt);
const labelUList& faceCells = cyclicInterface_.faceCells();
forAll(faceCells, elemI)
{
result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
}
Foam::tmp<Foam::Field<Type> >
Foam::jumpCyclicAMIFvPatchField<Type>::patchNeighbourField() const
{
const Field<Type>& iField = this->internalField();
const labelUList& nbrFaceCells =
this->cyclicAMIPatch().cyclicAMIPatch().neighbPatch().faceCells();
Field<Type> pnf(iField, nbrFaceCells);
tmp<Field<Type> > tpnf;
if (this->cyclicAMIPatch().applyLowWeightCorrection())
{
tpnf =
this->cyclicAMIPatch().interpolate
(
pnf,
this->patchInternalField()()
);
}
else
{
tpnf = this->cyclicAMIPatch().interpolate(pnf);
}
if (this->doTransform())
{
tpnf = transform(this->forwardT(), tpnf);
}
tmp<Field<Type> > tjf = jump();
if (!this->cyclicAMIPatch().owner())
{
tjf = -tjf;
}
return tpnf - tjf;
}
void Foam::processorFvPatchField<Type>::updateInterfaceMatrix
(
gpuField<Type>& result,
const gpuField<Type>&,
const scalargpuField& coeffs,
const Pstream::commsTypes commsType
) const
{
if (this->updatedMatrix())
{
return;
}
if (commsType == Pstream::nonBlocking && !Pstream::floatTransfer)
{
// Fast path.
if
(
outstandingRecvRequest_ >= 0
&& outstandingRecvRequest_ < Pstream::nRequests()
)
{
UPstream::waitRequest(outstandingRecvRequest_);
}
// Recv finished so assume sending finished as well.
outstandingSendRequest_ = -1;
outstandingRecvRequest_ = -1;
// Consume straight from receiveBuf_
// Transform according to the transformation tensor
gpuReceiveBuf_ = receiveBuf_;
transformCoupleField(gpuReceiveBuf_);
// Multiply the field by coefficients and add into the result
matrixPatchOperation
(
this->patch().index(),
result,
this->patch().boundaryMesh().mesh().lduAddr(),
processorFvPatchFunctor<Type>
(
coeffs.data(),
gpuReceiveBuf_.data()
)
);
}
else
{
gpuField<Type> pnf
(
procPatch_.compressedReceive<Type>(commsType, this->size())()
);
// Transform according to the transformation tensor
transformCoupleField(pnf);
// Multiply the field by coefficients and add into the result
matrixPatchOperation
(
this->patch().index(),
result,
this->patch().boundaryMesh().mesh().lduAddr(),
processorFvPatchFunctor<Type>
(
coeffs.data(),
pnf.data()
)
);
}
const_cast<processorFvPatchField<Type>&>(*this).updatedMatrix() = true;
}
void processorFvPatchField<scalar>::updateInterfaceMatrix
(
scalargpuField& result,
const scalargpuField&,
const scalargpuField& coeffs,
const direction,
const Pstream::commsTypes commsType
) const
{
if (this->updatedMatrix())
{
return;
}
if (commsType == Pstream::nonBlocking && !Pstream::floatTransfer)
{
// Fast path.
if
(
outstandingRecvRequest_ >= 0
&& outstandingRecvRequest_ < Pstream::nRequests()
)
{
UPstream::waitRequest(outstandingRecvRequest_);
}
// Recv finished so assume sending finished as well.
outstandingSendRequest_ = -1;
outstandingRecvRequest_ = -1;
scalargpuReceiveBuf_ = scalarReceiveBuf_;
// Consume straight from scalarReceiveBuf_
/*
forAll(faceCells, elemI)
{
result[faceCells[elemI]] -= coeffs[elemI]*scalarReceiveBuf_[elemI];
}
*/
matrixPatchOperation(this->patch().index(),
result,
this->patch().boundaryMesh().mesh().lduAddr(),
processorFvPatchScalarFunctor(coeffs.data(),scalargpuReceiveBuf_.data()));
}
else
{
scalargpuField pnf
(
procPatch_.compressedReceive<scalar>(commsType, this->size())()
);
/*
forAll(faceCells, elemI)
{
result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
}
*/
matrixPatchOperation(this->patch().index(),
result,
this->patch().boundaryMesh().mesh().lduAddr(),
processorFvPatchScalarFunctor(coeffs.data(),pnf.data()));
}
const_cast<processorFvPatchField<scalar>&>(*this).updatedMatrix() = true;
}
