//void volPointInterpolation::makeBoundaryWeights() const
//{
// const labelList& ptc = boundaryPoints();

// Calculate the correction vectors and weighting factors
//pointBoundaryWeightsPtr_ = new FieldField<Field, scalar>(ptc.size());
//FieldField<Field, scalar>& w = *pointBoundaryWeightsPtr_;
FieldField<Field, scalar> w(ptc.size());

{
    const labelListList& pf = mesh.pointFaces();

    const volVectorField& centres = mesh.C();

    const fvBoundaryMesh& bm = mesh.boundary();

    pointScalarField volPointSumWeights
    (
         IOobject
         (
             "volPointSumWeights",
             mesh.polyMesh::instance(),
             mesh
         ),
         pMesh,
         dimensionedScalar("zero", dimless, 0)
    );

    forAll (ptc, pointI)
    {
        const label curPoint = ptc[pointI];

        const labelList& curFaces = pf[curPoint];

        //w.hook(new scalarField(curFaces.size())); //philipc no hook function
        w.set
        (
            pointI,
            new scalarField(curFaces.size())
        );

        scalarField& curWeights = w[pointI];

        label nFacesAroundPoint = 0;

        const vector& pointLoc = mesh.points()[curPoint];

        // Go through all the faces
        forAll (curFaces, faceI)
        {
            if (!mesh.isInternalFace(curFaces[faceI]))
            {
                // This is a boundary face.  If not in the empty patch
                // or coupled calculate the extrapolation vector
                label patchID =
                mesh.boundaryMesh().whichPatch(curFaces[faceI]);

                if
                (
                    !isA<emptyFvPatch>(bm[patchID])
                 && !(
                         bm[patchID].coupled()
                    //&& Pstream::parRun()
                    //&& !mesh.parallelData().cyclicParallel()
                     )
                )
                {
                    curWeights[nFacesAroundPoint] =
                        1.0/mag
                        (
                            pointLoc
                          - centres.boundaryField()[patchID]
                            [
                                bm[patchID].patch().whichFace(curFaces[faceI])
                            ]
                        );

                        nFacesAroundPoint++;
                }
            }
        }

        // Reset the sizes of the local weights
        curWeights.setSize(nFacesAroundPoint);

        // Collect the sum of weights for parallel correction
        volPointSumWeights[curPoint] += sum(curWeights);
    }

    // Do parallel correction of weights

    // Update coupled boundaries
    // Work-around for cyclic parallels.
/*
    if (Pstream::parRun() && !mesh.parallelData().cyclicParallel())
    {
        forAll (volPointSumWeights.boundaryField(), patchI)
        {
            if (volPointSumWeights.boundaryField()[patchI].coupled())
            {
                volPointSumWeights.boundaryField()[patchI].initAddField();
            }
        }

        forAll (volPointSumWeights.boundaryField(), patchI)
        {
            if (volPointSumWeights.boundaryField()[patchI].coupled())
            {
                volPointSumWeights.boundaryField()[patchI].addField
                (
                    volPointSumWeights.internalField()
                );
            }
        }
    }
*/

    // Re-scale the weights for the current point
    forAll (ptc, pointI)
    {
        w[pointI] /= volPointSumWeights[ptc[pointI]];
    }
}