Foam::tmp<Foam::labelgpuField> Foam::regionCoupledFvPatch::internalFieldTransfer
(
const Pstream::commsTypes commsType,
const labelgpuList& iF
) const
{
if (neighbFvPatch().sameRegion())
{
return neighbFvPatch().patchInternalField(iF);
}
else
{
/*
WarningIn
(
"regionCoupledFvPatch::internalFieldTransfer"
"( const Pstream::commsTypes, const labelUList&)"
" the internal field can not be transfered "
" as the neighbFvPatch are in different meshes "
);
*/
return tmp<labelgpuField>(new labelgpuField(iF.size(), 0));
}
}
void Foam::cyclicAMIFvPatch::makeWeights(scalarField& w) const
{
if (coupled())
{
const cyclicAMIFvPatch& nbrPatch = neighbFvPatch();
const scalarField deltas(nf() & coupledFvPatch::delta());
tmp<scalarField> tnbrDeltas;
if (applyLowWeightCorrection())
{
tnbrDeltas =
interpolate
(
nbrPatch.nf() & nbrPatch.coupledFvPatch::delta(),
scalarField(this->size(), 1.0)
);
}
else
{
tnbrDeltas =
interpolate(nbrPatch.nf() & nbrPatch.coupledFvPatch::delta());
}
const scalarField& nbrDeltas = tnbrDeltas();
forAll(deltas, faceI)
{
scalar di = deltas[faceI];
scalar dni = nbrDeltas[faceI];
w[faceI] = dni/(di + dni);
}
}
void Foam::cyclicACMIFvPatch::makeWeights(scalargpuField& w) const
{
if (coupled())
{
const cyclicACMIFvPatch& nbrPatch = neighbFvPatch();
const fvPatch& nbrPatchNonOverlap = nonOverlapPatch();
const scalargpuField deltas(nf() & coupledFvPatch::delta());
const scalargpuField nbrDeltas
(
interpolate
(
nbrPatch.nf() & nbrPatch.coupledFvPatch::delta(),
nbrPatchNonOverlap.nf() & nbrPatchNonOverlap.delta()
)
);
thrust::transform
(
deltas.begin(),
deltas.end(),
nbrDeltas.begin(),
w.begin(),
cyclicACMIFvPatchMakeWeightsFunctor()
);
}
else
{
// Behave as uncoupled patch
fvPatch::makeWeights(w);
}
}
Foam::tmp<Foam::labelgpuField> Foam::regionCoupledWallFvPatch::
internalFieldTransfer
(
const Pstream::commsTypes commsType,
const labelgpuList& iF
) const
{
if (neighbFvPatch().sameRegion())
{
return neighbFvPatch().patchInternalField(iF);
}
else
{
return tmp<labelgpuField>(new labelgpuField(iF.size(), 0));
}
}
Foam::tmp<Foam::labelField> Foam::cyclicACMIFvPatch::internalFieldTransfer
(
const Pstream::commsTypes commsType,
const labelUList& iF
) const
{
return neighbFvPatch().patchInternalField(iF);
}
// Make patch weighting factors
void Foam::cyclicFvPatch::makeWeights(scalarField& w) const
{
const cyclicFvPatch& nbrPatch = neighbFvPatch();
const scalarField deltas(nf() & fvPatch::delta());
const scalarField nbrDeltas(nbrPatch.nf() & nbrPatch.fvPatch::delta());
forAll(deltas, facei)
{
scalar di = deltas[facei];
scalar dni = nbrDeltas[facei];
w[facei] = dni/(di + dni);
}
void Foam::cyclicACMIFvPatch::updateAreas() const
{
if (cyclicACMIPatch().updated())
{
if (debug)
{
Pout<< "cyclicACMIFvPatch::updateAreas() : updating fv areas for "
<< name() << " and " << nonOverlapFvPatch().name()
<< endl;
}
// owner couple
const_cast<vectorField&>(Sf()) = patch().faceAreas();
const_cast<scalarField&>(magSf()) = mag(patch().faceAreas());
// owner non-overlapping
const fvPatch& nonOverlapPatch = nonOverlapFvPatch();
const_cast<vectorField&>(nonOverlapPatch.Sf()) =
nonOverlapPatch.patch().faceAreas();
const_cast<scalarField&>(nonOverlapPatch.magSf()) =
mag(nonOverlapPatch.patch().faceAreas());
// neighbour couple
const cyclicACMIFvPatch& nbrACMI = neighbFvPatch();
const_cast<vectorField&>(nbrACMI.Sf()) =
nbrACMI.patch().faceAreas();
const_cast<scalarField&>(nbrACMI.magSf()) =
mag(nbrACMI.patch().faceAreas());
// neighbour non-overlapping
const fvPatch& nbrNonOverlapPatch = nbrACMI.nonOverlapFvPatch();
const_cast<vectorField&>(nbrNonOverlapPatch.Sf()) =
nbrNonOverlapPatch.patch().faceAreas();
const_cast<scalarField&>(nbrNonOverlapPatch.magSf()) =
mag(nbrNonOverlapPatch.patch().faceAreas());
// set the updated flag
cyclicACMIPatch().setUpdated(false);
}
}
void Foam::cyclicACMIFvPatch::makeWeights(scalarField& w) const
{
if (coupled())
{
const cyclicACMIFvPatch& nbrPatch = neighbFvPatch();
const scalarField deltas(nf() & coupledFvPatch::delta());
// These deltas are of the cyclic part alone - they are
// not affected by the amount of overlap with the nonOverlapPatch
scalarField nbrDeltas
(
interpolate
(
nbrPatch.nf() & nbrPatch.coupledFvPatch::delta()
)
);
scalar tol = cyclicACMIPolyPatch::tolerance();
forAll(deltas, facei)
{
scalar di = deltas[facei];
scalar dni = nbrDeltas[facei];
if (dni < tol)
{
// Avoid zero weights on disconnected faces. This value
// will be weighted with the (zero) face area so will not
// influence calculations.
w[facei] = 1.0;
}
else
{
w[facei] = dni/(di + dni);
}
}
}
bool Foam::cyclicAMIFvPatch::coupled() const
{
return Pstream::parRun() || (this->size() && neighbFvPatch().size());
}
Foam::tmp<Foam::vectorgpuField> Foam::cyclicACMIFvPatch::delta() const
{
if (coupled())
{
const cyclicACMIFvPatch& nbrPatchCoupled = neighbFvPatch();
const fvPatch& nbrPatchNonOverlap = nonOverlapPatch();
const vectorgpuField patchD(coupledFvPatch::delta());
vectorgpuField nbrPatchD
(
interpolate
(
nbrPatchCoupled.coupledFvPatch::delta(),
nbrPatchNonOverlap.delta()
)
);
const vectorgpuField nbrPatchD0
(
interpolate
(
vectorgpuField(nbrPatchCoupled.size(), vector::zero),
nbrPatchNonOverlap.delta()()
)
);
nbrPatchD -= nbrPatchD0;
tmp<vectorgpuField> tpdv(new vectorgpuField(patchD.size()));
vectorgpuField& pdv = tpdv();
// do the transformation if necessary
if (parallel())
{
thrust::transform
(
patchD.begin(),
patchD.end(),
nbrPatchD.begin(),
pdv.begin(),
subtractOperatorFunctor<vector,vector,vector>()
);
}
else
{
tensor t = forwardT()[0];
thrust::transform
(
patchD.begin(),
patchD.end(),
thrust::make_transform_iterator
(
nbrPatchD.begin(),
transformBinaryFunctionSFFunctor<tensor,vector,vector>(t)
),
pdv.begin(),
subtractOperatorFunctor<vector,vector,vector>()
);
}
return tpdv;
}
else
{
return coupledFvPatch::delta();
}
}