diff --git a/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.H b/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.H
index b5f16857ac..c84796da41 100644
--- a/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.H
+++ b/src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,7 +25,7 @@ Class
     Foam::lduPrimitiveMesh
 
 Description
-    Simplest contrete lduMesh which stores the addressing needed bu lduMatrix.
+    Simplest contrete lduMesh which stores the addressing needed by lduMatrix.
 
 \*---------------------------------------------------------------------------*/
 
diff --git a/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processorCyclic/processorCyclicPointPatch.C b/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processorCyclic/processorCyclicPointPatch.C
index f16ce4085e..edf4fb4da8 100644
--- a/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processorCyclic/processorCyclicPointPatch.C
+++ b/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processorCyclic/processorCyclicPointPatch.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2010-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -26,11 +26,6 @@ License
 #include "processorCyclicPointPatch.H"
 #include "pointBoundaryMesh.H"
 #include "addToRunTimeSelectionTable.H"
-//#include "pointMesh.H"
-//#include "globalPointPatch.H"
-//#include "faceList.H"
-//#include "primitiveFacePatch.H"
-//#include "emptyPolyPatch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -49,344 +44,6 @@ addToRunTimeSelectionTable
 );
 
 
-// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
-
-//void Foam::processorCyclicPointPatch::initGeometry(PstreamBuffers& pBufs)
-//{
-//    // Algorithm:
-//    // Depending on whether the patch is a master or a slave, get the
-//    // primitive patch points and filter away the points from the
-//    // global patch.
-//
-//    if (isMaster())
-//    {
-//        meshPoints_ = procPolyPatch_.meshPoints();
-//    }
-//    else
-//    {
-//        // Slave side. Create the reversed patch and pick up its points
-//        // so that the order is correct
-//        const polyPatch& pp = patch();
-//
-//        faceList masterFaces(pp.size());
-//
-//        forAll(pp, faceI)
-//        {
-//            masterFaces[faceI] = pp[faceI].reverseFace();
-//        }
-//
-//        meshPoints_ = primitiveFacePatch
-//        (
-//            masterFaces,
-//            pp.points()
-//        ).meshPoints();
-//    }
-//
-//    if (Pstream::parRun())
-//    {
-//        initPatchPatchPoints(pBufs);
-//    }
-//}
-//
-//
-//void Foam::processorCyclicPointPatch::calcGeometry(PstreamBuffers& pBufs)
-//{
-//    if (Pstream::parRun())
-//    {
-//        calcPatchPatchPoints(pBufs);
-//    }
-//
-//    // If it is not runing parallel or there are no global points
-//    // create a 1->1 map
-//    if
-//    (
-//        !Pstream::parRun()
-//     || !boundaryMesh().mesh().globalData().nGlobalPoints()
-//    )
-//    {
-//        nonGlobalPatchPoints_.setSize(meshPoints_.size());
-//        forAll(nonGlobalPatchPoints_, i)
-//        {
-//            nonGlobalPatchPoints_[i] = i;
-//        }
-//    }
-//    else
-//    {
-//        // Get reference to shared points
-//        const labelList& sharedPoints =
-//            boundaryMesh().globalPatch().meshPoints();
-//
-//        nonGlobalPatchPoints_.setSize(meshPoints_.size());
-//
-//        label noFiltPoints = 0;
-//
-//        forAll(meshPoints_, pointI)
-//        {
-//            label curP = meshPoints_[pointI];
-//
-//            bool found = false;
-//
-//            forAll(sharedPoints, sharedI)
-//            {
-//                if (sharedPoints[sharedI] == curP)
-//                {
-//                    found = true;
-//                    break;
-//                }
-//            }
-//
-//            if (!found)
-//            {
-//                nonGlobalPatchPoints_[noFiltPoints] = pointI;
-//                meshPoints_[noFiltPoints] = curP;
-//                noFiltPoints++;
-//            }
-//        }
-//
-//        nonGlobalPatchPoints_.setSize(noFiltPoints);
-//        meshPoints_.setSize(noFiltPoints);
-//    }
-//}
-//
-//
-//void processorCyclicPointPatch::initPatchPatchPoints(PstreamBuffers& pBufs)
-//{
-//    if (debug)
-//    {
-//        Info<< "processorCyclicPointPatch::"
-//            << "initPatchPatchPoints(PstreamBuffers&) : "
-//            << "constructing patch-patch points"
-//            << endl;
-//    }
-//
-//    const polyBoundaryMesh& bm = boundaryMesh().mesh()().boundaryMesh();
-//
-//    // Get the mesh points for this patch corresponding to the faces
-//    const labelList& ppmp = meshPoints();
-//
-//    // Create a HashSet of the point labels for this patch
-//    Map<label> patchPointSet(2*ppmp.size());
-//
-//    forAll(ppmp, ppi)
-//    {
-//        patchPointSet.insert(ppmp[ppi], ppi);
-//    }
-//
-//
-//    // Create the lists of patch-patch points
-//    labelListList patchPatchPoints(bm.size());
-//
-//    // Create the lists of patch-patch point normals
-//    List<List<vector> > patchPatchPointNormals(bm.size());
-//
-//    // Loop over all patches looking for other patches that share points
-//    forAll(bm, patchi)
-//    {
-//        if
-//        (
-//            patchi != index()                 // Ignore self-self
-//         && !isA<emptyPolyPatch>(bm[patchi])  // Ignore empty
-//         && !bm[patchi].coupled()             // Ignore other couples
-//        )
-//        {
-//            // Get the meshPoints for the other patch
-//            const labelList& meshPoints = bm[patchi].meshPoints();
-//
-//            // Get the normals for the other patch
-//            const vectorField& normals = bm[patchi].pointNormals();
-//
-//            label pppi = 0;
-//            forAll(meshPoints, pointi)
-//            {
-//                label ppp = meshPoints[pointi];
-//
-//                // Check to see if the point of the other patch is shared with
-//                // this patch
-//                Map<label>::iterator iter = patchPointSet.find(ppp);
-//
-//                if (iter != patchPointSet.end())
-//                {
-//                    // If it is shared initialise the patchPatchPoints for
-//                    // this patch
-//                    if (!patchPatchPoints[patchi].size())
-//                    {
-//                        patchPatchPoints[patchi].setSize(ppmp.size());
-//                        patchPatchPointNormals[patchi].setSize(ppmp.size());
-//                    }
-//
-//                    // and add the entry
-//                    patchPatchPoints[patchi][pppi] = iter();
-//                    patchPatchPointNormals[patchi][pppi] = normals[pointi];
-//                    pppi++;
-//                }
-//            }
-//
-//            // Resise the list of shared points and normals for the patch
-//            // being considerd
-//            patchPatchPoints[patchi].setSize(pppi);
-//            patchPatchPointNormals[patchi].setSize(pppi);
-//        }
-//    }
-//
-//    // Send the patchPatchPoints to the neighbouring processor
-//
-//    UOPstream toNeighbProc(neighbProcNo(), pBufs);
-//
-//    toNeighbProc
-//        << ppmp.size()              // number of points for checking
-//        << patchPatchPoints
-//        << patchPatchPointNormals;
-//
-//    if (debug)
-//    {
-//        Info<< "processorCyclicPointPatch::initPatchPatchPoints() : "
-//            << "constructed patch-patch points"
-//            << endl;
-//    }
-//}
-//
-//
-//void Foam::processorCyclicPointPatch::calcPatchPatchPoints
-//(
-//    PstreamBuffers& pBufs
-//)
-//{
-//    // Get the patchPatchPoints from the neighbouring processor
-//    UIPstream fromNeighbProc(neighbProcNo(), pBufs);
-//
-//    label nbrNPoints(readLabel(fromNeighbProc));
-//    labelListList patchPatchPoints(fromNeighbProc);
-//    List<List<vector> > patchPatchPointNormals(fromNeighbProc);
-//
-//    pointBoundaryMesh& pbm = const_cast<pointBoundaryMesh&>(boundaryMesh());
-//    const labelList& ppmp = meshPoints();
-//
-//    // Simple check for the very rare situation when not the same number
-//    // of points on both sides. This can happen with decomposed cyclics.
-//    // If on one side the cyclic shares a point with proc faces coming from
-//    // internal faces it will have a different number of points from
-//    // the situation where the cyclic and the 'normal' proc faces are fully
-//    // separate.
-//    if (nbrNPoints != ppmp.size())
-//    {
-//        WarningIn
-//        (
-//            "processorCyclicPointPatch::calcPatchPatchPoints(PstreamBuffers&)"
-//        )
-//            << "Processor patch " << name()
-//            << " has " << ppmp.size() << " points; coupled patch has "
-//            << nbrNPoints << " points." << endl
-//            << "   (usually due to decomposed cyclics)."
-//            << " This might give problems" << endl
-//            << "    when using point fields (interpolation, mesh motion)."
-//            << endl;
-//    }
-//
-//
-//
-//    // Loop over the patches looking for other patches that share points
-//    forAll(patchPatchPoints, patchi)
-//    {
-//        const labelList& patchPoints = patchPatchPoints[patchi];
-//        const List<vector>& patchPointNormals =
-//            patchPatchPointNormals[patchi];
-//
-//        // If there are potentially shared points for the patch being
-//        // considered
-//        if (patchPoints.size())
-//        {
-//            // Get the current meshPoints list for the patch
-//            facePointPatch& fpp = refCast<facePointPatch>(pbm[patchi]);
-//            const labelList& fmp = fpp.meshPoints();
-//            labelList& mp = fpp.meshPoints_;
-//
-//            const vectorField& fnormals = fpp.pointNormals();
-//            vectorField& normals = fpp.pointNormals_;
-//
-//            // Create a HashSet of the point labels for the patch
-//            Map<label> patchPointSet(2*fmp.size());
-//
-//            forAll(fmp, ppi)
-//            {
-//                patchPointSet.insert(fmp[ppi], ppi);
-//            }
-//
-//            label nPoints = mp.size();
-//            label lpi = 0;
-//            bool resized = false;
-//
-//            // For each potentially shared point...
-//            forAll(patchPoints, ppi)
-//            {
-//                // Check if it is not already in the patch,
-//                // i.e. not part of a face of the patch
-//                if (!patchPointSet.found(ppmp[patchPoints[ppi]]))
-//                {
-//                    // If it isn't already in the patch check if the local
-//                    // meshPoints is already set and if not initialise the
-//                    // meshPoints_ and pointNormals_
-//                    if (!resized)
-//                    {
-//                        if (!mp.size() && fmp.size())
-//                        {
-//                            mp = fmp;
-//                            normals = fnormals;
-//
-//                            nPoints = mp.size();
-//                        }
-//
-//                        mp.setSize(nPoints + patchPoints.size());
-//                        loneMeshPoints_.setSize(patchPoints.size());
-//                        normals.setSize(nPoints + patchPoints.size());
-//                        resized = true;
-//                    }
-//
-//                    // Add the new point to the patch
-//                    mp[nPoints] = ppmp[patchPoints[ppi]];
-//                    loneMeshPoints_[lpi++] = ppmp[patchPoints[ppi]];
-//                    normals[nPoints++] = patchPointNormals[ppi];
-//                }
-//            }
-//
-//            // If the lists have been resized points have been added.
-//            // Shrink the lists to the current size.
-//            if (resized)
-//            {
-//                mp.setSize(nPoints);
-//                loneMeshPoints_.setSize(lpi);
-//                normals.setSize(nPoints);
-//            }
-//        }
-//    }
-//}
-
-
-//void processorCyclicPointPatch::initMovePoints
-//(
-//    PstreamBuffers&,
-//    const pointField&
-//)
-//{}
-//
-//
-//void processorCyclicPointPatch::movePoints(PstreamBuffers&, const pointField&)
-//{}
-//
-//
-//void processorCyclicPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
-//{
-//    facePointPatch::initUpdateMesh(pBufs);
-//    processorCyclicPointPatch::initGeometry(pBufs);
-//}
-//
-//
-//void processorCyclicPointPatch::updateMesh(PstreamBuffers& pBufs)
-//{
-//    facePointPatch::updateMesh(pBufs);
-//    processorCyclicPointPatch::calcGeometry(pBufs);
-//}
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 processorCyclicPointPatch::processorCyclicPointPatch
diff --git a/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processorCyclic/processorCyclicPointPatch.H b/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processorCyclic/processorCyclicPointPatch.H
index a89102fbb2..d29805e701 100644
--- a/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processorCyclic/processorCyclicPointPatch.H
+++ b/src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processorCyclic/processorCyclicPointPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2010-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -99,43 +99,6 @@ public:
             return procCycPolyPatch_.tag();
         }
 
-//        //- Return true if running parallel
-//        virtual bool coupled() const
-//        {
-//            if (Pstream::parRun())
-//            {
-//                return true;
-//            }
-//            else
-//            {
-//                return false;
-//            }
-//        }
-//
-//        //- Return processor number
-//        int myProcNo() const
-//        {
-//            return procPolyPatch_.myProcNo();
-//        }
-//
-//        //- Return neigbour processor number
-//        int neighbProcNo() const
-//        {
-//            return procPolyPatch_.neighbProcNo();
-//        }
-//
-//        //- Is this a master patch
-//        bool isMaster() const
-//        {
-//            return myProcNo() < neighbProcNo();
-//        }
-//
-//        //- Is this a slave patch
-//        bool isSlave() const
-//        {
-//            return !isMaster();
-//        }
-//
         //- Return the underlying processorCyclicPolyPatch
         const processorCyclicPolyPatch& procCyclicPolyPatch() const
         {
diff --git a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
index fdf4b8e03c..a4b929a5ba 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2010-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -73,19 +73,6 @@ protected:
         //- Initialise the calculation of the patch geometry
         void initGeometry(PstreamBuffers&);
 
-//        //- Initialise the calculation of the patch geometry with externally
-//        //  provided geometry
-//        virtual void initGeometry
-//        (
-//            const primitivePatch& referPatch,
-//            UList<point>&,
-//            UList<point>&,
-//            UList<point>&
-//        )
-//        {
-//            notImplemented("processorCyclicPolyPatch::initGeometry(..)");
-//        }
-
         //- Calculate the patch geometry
         void calcGeometry(PstreamBuffers&);
 
@@ -286,36 +273,6 @@ public:
             return referPatch().owner();
         }
 
-//        //- Transform a patch-based field from other side to this side.
-//        virtual bool doTransform() const
-//        {
-//            return referPatch().doTransform();
-//        }
-//        virtual void transform(scalarField& l) const
-//        {
-//            referPatch().transform(l);
-//        }
-//        virtual void transform(vectorField& l) const
-//        {
-//            referPatch().transform(l);
-//        }
-//        virtual void transform(sphericalTensorField& l) const
-//        {
-//            referPatch().transform(l);
-//        }
-//        virtual void transform(diagTensorField& l) const
-//        {
-//            referPatch().transform(l);
-//        }
-//        virtual void transform(symmTensorField& l) const
-//        {
-//            referPatch().transform(l);
-//        }
-//        virtual void transform(tensorField& l) const
-//        {
-//            referPatch().transform(l);
-//        }
-
         //- Transform a patch-based position from other side to this side
         virtual void transformPosition(pointField& l) const
         {
diff --git a/src/finiteVolume/fields/fvPatchFields/constraint/processorCyclic/processorCyclicFvPatchField.H b/src/finiteVolume/fields/fvPatchFields/constraint/processorCyclic/processorCyclicFvPatchField.H
index 6c7a632572..4a60dcb021 100644
--- a/src/finiteVolume/fields/fvPatchFields/constraint/processorCyclic/processorCyclicFvPatchField.H
+++ b/src/finiteVolume/fields/fvPatchFields/constraint/processorCyclic/processorCyclicFvPatchField.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2010-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -35,8 +35,6 @@ SourceFiles
 #ifndef processorCyclicFvPatchField_H
 #define processorCyclicFvPatchField_H
 
-//#include "coupledFvPatchField.H"
-//#include "processorLduInterfaceField.H"
 #include "processorCyclicFvPatch.H"
 #include "processorFvPatchField.H"
 
@@ -52,8 +50,6 @@ namespace Foam
 template<class Type>
 class processorCyclicFvPatchField
 :
-//    public processorLduInterfaceField,
-//    public coupledFvPatchField<Type>
     public processorFvPatchField<Type>
 {
     // Private data
@@ -61,14 +57,6 @@ class processorCyclicFvPatchField
         //- Local reference cast into the processor patch
         const processorCyclicFvPatch& procPatch_;
 
-    // Private Member Functions
-
-        // //- Get other patchfield
-        // const coupledFvPatchField<Type>& patchField
-        // (
-        //     const label patchID
-        // ) const;
-
 public:
 
     //- Runtime type information
@@ -151,70 +139,6 @@ public:
 
         // Access
 
-//            //- Return true if running parallel
-//            virtual bool coupled() const
-//            {
-//                if (Pstream::parRun())
-//                {
-//                    return true;
-//                }
-//                else
-//                {
-//                    return false;
-//                }
-//            }
-//
-//            //- Return neighbour field given internal field
-//            tmp<Field<Type> > patchNeighbourField() const;
-//
-//
-//        // Evaluation functions
-//
-//            //- Initialise the evaluation of the patch field
-//            virtual void initEvaluate(const Pstream::commsTypes commsType);
-//
-//            //- Evaluate the patch field
-//            virtual void evaluate(const Pstream::commsTypes commsType);
-//
-//            //- Return patch-normal gradient
-//            virtual tmp<Field<Type> > snGrad() const;
-//
-//            //- Initialise neighbour matrix update
-//            virtual void initInterfaceMatrixUpdate
-//            (
-//                const scalarField& psiInternal,
-//                scalarField& result,
-//                const lduMatrix& m,
-//                const scalarField& coeffs,
-//                const direction cmpt,
-//                const Pstream::commsTypes commsType
-//            ) const;
-//
-//            //- Update result field based on interface functionality
-//            virtual void updateInterfaceMatrix
-//            (
-//                const scalarField& psiInternal,
-//                scalarField& result,
-//                const lduMatrix& m,
-//                const scalarField& coeffs,
-//                const direction cmpt,
-//                const Pstream::commsTypes commsType
-//            ) const;
-//
-//        //- Processor coupled interface functions
-//
-//            //- Return processor number
-//            virtual int myProcNo() const
-//            {
-//                return procPatch_.myProcNo();
-//            }
-//
-//            //- Return neigbour processor number
-//            virtual int neighbProcNo() const
-//            {
-//                return procPatch_.neighbProcNo();
-//            }
-
             //- Does the patch field perform the transfromation
             virtual bool doTransform() const
             {
@@ -227,103 +151,6 @@ public:
                 return procPatch_.forwardT();
             }
 
-//            //- Return rank of component for transform
-//            virtual int rank() const
-//            {
-//                return pTraits<Type>::rank;
-//            }
-
-//            //- Transform given patch component field
-//            void transformCoupleField
-//            (
-//                scalarField& f,
-//                const direction cmpt
-//            ) const;
-
-//        // Referred-patch functionality. Get called with a slice (size, start)
-//        // of a patch that supplies fields and geometry/topology.
-//
-//            //- Get patch-normal gradient
-//            virtual void snGrad
-//            (
-//                Field<Type>& exchangeBuf,
-//                const Field<Type>& subFld,
-//                const coupledFvPatch& referringPatch,
-//                const label size,
-//                const label start
-//            ) const
-//            {
-//                notImplemented("processorCyclicFvPatchField::snGrad(..)");
-//            }
-//
-//            //- Initialise the evaluation of the patch field.
-//            virtual void initEvaluate
-//            (
-//                Field<Type>& exchangeBuf,
-//                const coupledFvPatch& referringPatch,
-//                const label size,
-//                const label start
-//            ) const
-//            {
-//                notImplemented
-//                (
-//                    "processorCyclicFvPatchField::initEvaluate(..)"
-//                );
-//            }
-//
-//            //- Evaluate the patch field.
-//            virtual void evaluate
-//            (
-//                Field<Type>& exchangeBuf,
-//                const coupledFvPatch& referringPatch,
-//                const label size,
-//                const label start
-//            ) const
-//            {
-//                notImplemented("processorCyclicFvPatchField::evaluate(..)");
-//            }
-//
-//            //- Initialise neighbour matrix update
-//            virtual void initInterfaceMatrixUpdate
-//            (
-//                const scalarField& psiInternal,
-//                scalarField& result,
-//                const lduMatrix& m,
-//                const scalarField& coeffs,
-//                const direction cmpt,
-//                const coupledFvPatch& referringPatch,
-//                const label size,
-//                const label start,
-//                scalarField& exchangeBuf
-//            ) const
-//            {
-//                notImplemented
-//                (
-//                    "processorCyclicFvPatchField::"
-//                    "initInterfaceMatrixUpdate(..)"
-//                );
-//            }
-//
-//            //- Update result field based on interface functionality
-//            virtual void updateInterfaceMatrix
-//            (
-//                const scalarField& psiInternal,
-//                scalarField& result,
-//                const lduMatrix&,
-//                const scalarField& coeffs,
-//                const direction,
-//                const coupledFvPatch& referringPatch,
-//                const label size,
-//                const label start,
-//                scalarField& exchangeBuf
-//            ) const
-//            {
-//                notImplemented
-//                (
-//                    "processorCyclicFvPatchField::updateInterfaceMatrix(..)"
-//                );
-//            }
-
 
 };