コード例 #1
0
// Return delta (P to N) vectors across coupled patch
tmp<vectorField> cyclicFvPatch::delta() const
{
    vectorField patchD = fvPatch::delta();
    label sizeby2 = patchD.size()/2;

    tmp<vectorField> tpdv(new vectorField(patchD.size()));
    vectorField& pdv = tpdv();

    // To the transformation if necessary
    if (parallel())
    {
        for (label facei = 0; facei < sizeby2; facei++)
        {
            vector ddi = patchD[facei];
            vector dni = patchD[facei + sizeby2];

            pdv[facei] = ddi - dni;
            pdv[facei + sizeby2] = -pdv[facei];
        }
    }
    else
    {
        for (label facei = 0; facei < sizeby2; facei++)
        {
            vector ddi = patchD[facei];
            vector dni = patchD[facei + sizeby2];

            pdv[facei] = ddi - transform(forwardT()[0], dni);
            pdv[facei + sizeby2] = -transform(reverseT()[0], pdv[facei]);
        }
    }

    return tpdv;
}
コード例 #2
0
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();
    }
}