applications/utilities/parallelProcessing/reconstructParMesh/tetPointFieldReconstructor.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 "tetPointFieldReconstructor.H"
  28
  29 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  30
  31 namespace Foam
  32 {
  33
  34 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  35
  36 // Calculate point addressing
  37 labelList tetPointFieldReconstructor::procAddressing
  38 (
  39     const label procNo
  40 ) const
  41 {
  42     // Allocate the addressing
  43     labelList addr(procMeshes_[procNo].nPoints(), -1);
  44
  45     const labelList& pointAddr = pointProcAddressing_[procNo];
  46     const labelList& cellAddr = cellProcAddressing_[procNo];
  47
  48     label nAddr = 0;
  49
  50     // Insert point addressing
  51
  52     // Use only live points.  HJ, 14/Apr/2009
  53     for (label pointI = 0; pointI < procMeshes_[procNo]().nPoints(); pointI++)
  54     {
  55         addr[nAddr] = pointAddr[pointI];
  56         nAddr++;
  57     }
  58
  59     // Insert face addressing.  Only for face decomposition
  60     const labelList& faceAddr = faceProcAddressing_[procNo];
  61
  62     const label faceOffset = mesh_.faceOffset();
  63
  64     // Use only live faces.  HJ, 14/Apr/2009
  65     for (label faceI = 0; faceI < procMeshes_[procNo]().nFaces(); faceI++)
  66     {
  67         // Remember to decrement the index by one (turning index)
  68         addr[nAddr] = faceOffset + mag(faceAddr[faceI]) - 1;
  69         nAddr++;
  70     }
  71
  72     // Insert cell addressing
  73     const label cellOffset = mesh_.cellOffset();
  74
  75     forAll (cellAddr, cellI)
  76     {
  77         addr[nAddr] = cellOffset + cellAddr[cellI];
  78         nAddr++;
  79     }
  80
  81     return addr;
  82 }
  83
  84
  85 labelList tetPointFieldReconstructor::procPatchAddressing
  86 (
  87     const labelList& procToGlobalAddr,
  88     const label procNo,
  89     const label patchNo
  90 ) const
  91 {
  92     labelList addr(procMeshes_[procNo].boundary()[patchNo].size(), -1);
  93
  94     // Algorithm:
  95     // Go to the global patch, create a lookup list the size of all
  96     // points in the mesh and then gather the points for the current
  97     // patch.
  98     labelList pointLookup(mesh_.nPoints(), -1);
  99
 100     const labelList& globalPatchPoints =
 101         mesh_.boundary()[boundaryProcAddressing_[procNo][patchNo]].meshPoints();
 102
 103     forAll (globalPatchPoints, pointI)
 104     {
 105         pointLookup[globalPatchPoints[pointI]] = pointI;
 106     }
 107
 108     // Gather the information
 109
 110     const labelList& procPatchPoints =
 111         procMeshes_[procNo].boundary()[patchNo].meshPoints();
 112
 113     forAll (procPatchPoints, pointI)
 114     {
 115         addr[pointI] =
 116             pointLookup[procToGlobalAddr[procPatchPoints[pointI]]];
 117     }
 118
 119     if (addr.size() && min(addr) < 0)
 120     {
 121         FatalErrorIn
 122         (
 123             "labelList tetPointFieldReconstructor::"
 124             "patchProcAddressing\n"
 125             "(\n"
 126             "    const labelList& procToGlobalAddr,\n"
 127             "    const label procNo,\n"
 128             "    const label patchNo\n"
 129             ") const"
 130         )   << "error in addressing"
 131             << abort(FatalError);
 132     }
 133
 134     return addr;
 135 }
 136
 137
 138 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 139
 140 // Construct from components
 141 tetPointFieldReconstructor::tetPointFieldReconstructor
 142 (
 143     tetPolyMesh& mesh,
 144     const PtrList<tetPolyMesh>& procMeshes,
 145     const PtrList<labelIOList>& pointProcAddressing,
 146     const PtrList<labelIOList>& faceProcAddressing,
 147     const PtrList<labelIOList>& cellProcAddressing,
 148     const PtrList<labelIOList>& boundaryProcAddressing
 149 )
 150 :
 151     mesh_(mesh),
 152     procMeshes_(procMeshes),
 153     pointProcAddressing_(pointProcAddressing),
 154     faceProcAddressing_(faceProcAddressing),
 155     cellProcAddressing_(cellProcAddressing),
 156     boundaryProcAddressing_(boundaryProcAddressing)
 157 {}
 158
 159
 160 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 161
 162 } // End namespace Foam
 163
 164 // ************************************************************************* //