[Jesper_Roland]

Hi,


I have for a while tried to understand how the coupled interfaces between the processor sub domains work without success.

Below I have posted the boundary loop from the class gaussLaplacianScheme, where it has been modified to only work with scalars. This class creates the discretisation for the laplacian term in our equations.


I believe that the treatment of the processor faces happens in the boundary loop below:

forAll(vf.boundaryField(), patchi)
    {
        const fvPatchField<scalar>& pvf = vf.boundaryField()[patchi];
        const fvsPatchScalarField& pGamma = gammaMagSf.boundaryField()[patchi];
        const fvsPatchScalarField& pDeltaCoeffs =
            deltaCoeffs.boundaryField()[patchi];

        // Boundary face cells in patch i:
        const polyPatch& pp = vf.mesh().boundaryMesh()[patchi];
        const UList<label>& bfaceCells = pp.faceCells();

        if (pvf.coupled())
        {
                forAll(bfaceCells,facei)
                {
// Does this contribution goes to fvMatrix diagonal?
                    fvm.internalCoeffs()[patchi][facei] =  pGamma[facei]*pvf.gradientInternalCoeffs(pDeltaCoeffs).ref()[facei];


 // Does this contribution goes to the fvMatrix source vector 

// or the upper() and lower() vectors for the off-diagonal terms?
 
                     fvm.boundaryCoeffs()[patchi][facei] = -pGamma[facei]*pvf.gradientBoundaryCoeffs(pDeltaCoeffs).ref()[facei];
                }
        }
        else
        {
            fvm.internalCoeffs()[patchi] = pGamma*pvf.gradientInternalCoeffs();
            fvm.boundaryCoeffs()[patchi] = -pGamma*pvf.gradientBoundaryCoeffs();
        }
    }

I am quite sure that fvm.internalCoeffs

                     fvm.internalCoeffs()[patchi][facei] =  pGamma[facei]*pvf.gradientInternalCoeffs(pDeltaCoeffs).ref()[facei];

goes to the matrix diagonal. Please correct me if I am wrong.

The term pvf.gradientInternalCoeffs(pDeltaCoeffs) for a coupled patch is defined in coupledFvPatchField.C as

template<class Type>
Foam::tmp<Foam::Field<Type>>
Foam::coupledFvPatchField<Type>::gradientInternalCoeffs
(
    const scalarField& deltaCoeffs
) const
{
    return -Type(pTraits<Type>::one)*deltaCoeffs;
}

I am not sure I understand what fvm.boundaryCoeffs() is. I know it relates to the neighbouring field, but is this added to the matrix as a source term or is it accounted for in the matrix off diagonal elements? If it is accounted for like matrix off-diagonal elements, how is this obtained in the code?

The coefficient pvf.gradientBoundaryCoeffs(pDeltaCoeffs) is also defined in coupledFvPatchField.C as

template<class Type>
Foam::tmp<Foam::Field<Type>>
Foam::coupledFvPatchField<Type>::gradientBoundaryCoeffs
(
    const scalarField& deltaCoeffs
) const
{
    return -this->gradientInternalCoeffs(deltaCoeffs);
}

I have read about ldu interfaces, but I do not understand how they are used for the coupled processor faces. Can anyone shed some light on this, or have a reference which explains this in detail?


Cheers,


Jesper.