src/OpenFOAM/fields/pointPatchFields/constraint/processor/processorPointPatchField.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "processorPointPatchField.H"
  28 #include "transformField.H"
  29 #include "processorPolyPatch.H"
  30
  31 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  32
  33 namespace Foam
  34 {
  35
  36 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
  37
  38 template<class Type>
  39 processorPointPatchField<Type>::processorPointPatchField
  40 (
  41     const pointPatch& p,
  42     const DimensionedField<Type, pointMesh>& iF
  43 )
  44 :
  45     coupledPointPatchField<Type>(p, iF),
  46     procPatch_(refCast<const processorPointPatch>(p))
  47 {}
  48
  49
  50 template<class Type>
  51 processorPointPatchField<Type>::processorPointPatchField
  52 (
  53     const pointPatch& p,
  54     const DimensionedField<Type, pointMesh>& iF,
  55     const dictionary& dict
  56 )
  57 :
  58     coupledPointPatchField<Type>(p, iF, dict),
  59     procPatch_(refCast<const processorPointPatch>(p))
  60 {}
  61
  62
  63 template<class Type>
  64 processorPointPatchField<Type>::processorPointPatchField
  65 (
  66     const processorPointPatchField<Type>& ptf,
  67     const pointPatch& p,
  68     const DimensionedField<Type, pointMesh>& iF,
  69     const pointPatchFieldMapper& mapper
  70 )
  71 :
  72     coupledPointPatchField<Type>(ptf, p, iF, mapper),
  73     procPatch_(refCast<const processorPointPatch>(ptf.patch()))
  74 {}
  75
  76
  77 template<class Type>
  78 processorPointPatchField<Type>::processorPointPatchField
  79 (
  80     const processorPointPatchField<Type>& ptf,
  81     const DimensionedField<Type, pointMesh>& iF
  82 )
  83 :
  84     coupledPointPatchField<Type>(ptf, iF),
  85     procPatch_(refCast<const processorPointPatch>(ptf.patch()))
  86 {}
  87
  88
  89 // * * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * //
  90
  91 template<class Type>
  92 processorPointPatchField<Type>::~processorPointPatchField()
  93 {}
  94
  95
  96 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  97
  98 template<class Type>
  99 void processorPointPatchField<Type>::initSwapAdd(Field<Type>& pField) const
 100 {
 101     if (Pstream::parRun())
 102     {
 103         // Get internal field into my point order
 104         Field<Type> pf(this->patchInternalField(pField));
 105
 106         OPstream::write
 107         (
 108             Pstream::blocking,
 109             procPatch_.neighbProcNo(),
 110             reinterpret_cast<const char*>(pf.begin()),
 111             pf.byteSize()
 112         );
 113     }
 114 }
 115
 116
 117 template<class Type>
 118 void processorPointPatchField<Type>::swapAdd(Field<Type>& pField) const
 119 {
 120     if (Pstream::parRun())
 121     {
 122         Field<Type> pnf(this->size());
 123
 124         IPstream::read
 125         (
 126             Pstream::blocking,
 127             procPatch_.neighbProcNo(),
 128             reinterpret_cast<char*>(pnf.begin()),
 129             pnf.byteSize()
 130         );
 131
 132         if (doTransform())
 133         {
 134             const processorPolyPatch& ppp = procPatch_.procPolyPatch();
 135             const tensorField& forwardT = ppp.forwardT();
 136
 137             if (forwardT.size() == 1)
 138             {
 139                 transform(pnf, forwardT[0], pnf);
 140             }
 141             else
 142             {
 143                 const labelList& nonGlobalPatchPoints =
 144                     procPatch_.nonGlobalPatchPoints();
 145                 const labelListList& pointFaces = ppp.pointFaces();
 146
 147                 forAll(nonGlobalPatchPoints, pfi)
 148                 {
 149                     pnf[pfi] = transform
 150                     (
 151                         forwardT[pointFaces[nonGlobalPatchPoints[pfi]][0]],
 152                         pnf[pfi]
 153                     );
 154                 }
 155             }
 156         }
 157
 158         addToInternalField(pField, pnf);
 159     }
 160 }
 161
 162
 163 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 164
 165 } // End namespace Foam
 166
 167 // ************************************************************************* //