src/dynamicMesh/polyMeshModifiers/slidingInterface/enrichedPatch/enrichedPatch.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 Description
  26     Enriched patch
  27
  28 Author
  29     Hrvoje Jasak, Wikki Ltd.  All rights reserved.  Copyright Hrvoje Jasak.
  30
  31 \*---------------------------------------------------------------------------*/
  32
  33 #include "enrichedPatch.H"
  34 #include "demandDrivenData.H"
  35
  36 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  37
  38 namespace Foam
  39 {
  40     defineTypeNameAndDebug(enrichedPatch, 0);
  41 }
  42
  43
  44 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  45
  46 void Foam::enrichedPatch::calcMeshPoints() const
  47 {
  48     if (meshPointsPtr_)
  49     {
  50         FatalErrorIn("void enrichedPatch::calcMeshPoints() const")
  51             << "Mesh points already calculated."
  52             << abort(FatalError);
  53     }
  54
  55     meshPointsPtr_ = new labelList(pointMap().toc());
  56     labelList& mp = *meshPointsPtr_;
  57
  58     sort(mp);
  59 }
  60
  61
  62 void Foam::enrichedPatch::calcLocalFaces() const
  63 {
  64     if (localFacesPtr_)
  65     {
  66         FatalErrorIn("void enrichedPatch::calcLocalFaces() const")
  67             << "Local faces already calculated."
  68             << abort(FatalError);
  69     }
  70
  71     // Invert mesh points and renumber faces using it
  72     const labelList& mp = meshPoints();
  73
  74     Map<label> mpLookup(2*mp.size());
  75
  76     forAll (mp, mpI)
  77     {
  78         mpLookup.insert(mp[mpI], mpI);
  79     }
  80
  81     const faceList& faces = enrichedFaces();
  82
  83     localFacesPtr_ = new faceList(faces.size());
  84     faceList& lf = *localFacesPtr_;
  85
  86     forAll (faces, faceI)
  87     {
  88         const face& f = faces[faceI];
  89
  90         face& curlf = lf[faceI];
  91
  92         curlf.setSize(f.size());
  93
  94         forAll (f, pointI)
  95         {
  96             curlf[pointI] = mpLookup.find(f[pointI])();
  97         }
  98     }
  99 }
 100
 101
 102 void Foam::enrichedPatch::calcLocalPoints() const
 103 {
 104     if (localPointsPtr_)
 105     {
 106         FatalErrorIn("void enrichedPatch::calcLocalPoints() const")
 107             << "Local points already calculated."
 108             << abort(FatalError);
 109     }
 110
 111     const labelList& mp = meshPoints();
 112
 113     localPointsPtr_ = new pointField(mp.size());
 114     pointField& lp = *localPointsPtr_;
 115
 116     forAll (lp, i)
 117     {
 118         lp[i] = pointMap().find(mp[i])();
 119     }
 120 }
 121
 122
 123 void Foam::enrichedPatch::clearOut()
 124 {
 125     deleteDemandDrivenData(enrichedFacesPtr_);
 126
 127     deleteDemandDrivenData(meshPointsPtr_);
 128     deleteDemandDrivenData(localFacesPtr_);
 129     deleteDemandDrivenData(localPointsPtr_);
 130     deleteDemandDrivenData(pointPointsPtr_);
 131     deleteDemandDrivenData(masterPointFacesPtr_);
 132
 133     clearCutFaces();
 134 }
 135
 136
 137 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 138
 139 // Construct from components
 140 Foam::enrichedPatch::enrichedPatch
 141 (
 142     const primitiveFacePatch& masterPatch,
 143     const primitiveFacePatch& slavePatch,
 144     const labelList& slavePointPointHits,
 145     const labelList& slavePointEdgeHits,
 146     const List<objectHit>& slavePointFaceHits
 147 )
 148 :
 149     masterPatch_(masterPatch),
 150     slavePatch_(slavePatch),
 151     pointMap_
 152     (
 153         masterPatch_.meshPoints().size()
 154       + slavePatch_.meshPoints().size()
 155     ),
 156     pointMapComplete_(false),
 157     pointMergeMap_(2*slavePatch_.meshPoints().size()),
 158     slavePointPointHits_(slavePointPointHits),
 159     slavePointEdgeHits_(slavePointEdgeHits),
 160     slavePointFaceHits_(slavePointFaceHits),
 161     enrichedFacesPtr_(NULL),
 162     meshPointsPtr_(NULL),
 163     localFacesPtr_(NULL),
 164     localPointsPtr_(NULL),
 165     pointPointsPtr_(NULL),
 166     masterPointFacesPtr_(NULL),
 167     cutFacesPtr_(NULL),
 168     cutFaceMasterPtr_(NULL),
 169     cutFaceSlavePtr_(NULL),
 170     localCutFacesPtr_(NULL)
 171 {}
 172
 173
 174 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 175
 176 Foam::enrichedPatch::~enrichedPatch()
 177 {
 178     clearOut();
 179 }
 180
 181
 182 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 183
 184 const Foam::labelList& Foam::enrichedPatch::meshPoints() const
 185 {
 186     if (!meshPointsPtr_)
 187     {
 188         calcMeshPoints();
 189     }
 190
 191     return *meshPointsPtr_;
 192 }
 193
 194
 195 const Foam::faceList& Foam::enrichedPatch::localFaces() const
 196 {
 197     if (!localFacesPtr_)
 198     {
 199         calcLocalFaces();
 200     }
 201
 202     return *localFacesPtr_;
 203 }
 204
 205
 206 const Foam::pointField& Foam::enrichedPatch::localPoints() const
 207 {
 208     if (!localPointsPtr_)
 209     {
 210         calcLocalPoints();
 211     }
 212
 213     return *localPointsPtr_;
 214 }
 215
 216
 217 const Foam::labelListList& Foam::enrichedPatch::pointPoints() const
 218 {
 219     if (!pointPointsPtr_)
 220     {
 221         calcPointPoints();
 222     }
 223
 224     return *pointPointsPtr_;
 225 }
 226
 227
 228 bool Foam::enrichedPatch::checkSupport() const
 229 {
 230     const faceList& faces = enrichedFaces();
 231
 232     bool error = false;
 233
 234     forAll (faces, faceI)
 235     {
 236         const face& curFace = faces[faceI];
 237
 238         forAll (curFace, pointI)
 239         {
 240             if (!pointMap().found(curFace[pointI]))
 241             {
 242                 WarningIn("void enrichedPatch::checkSupport()")
 243                     << "Point " << pointI << " of face " << faceI
 244                     << " global point index: " << curFace[pointI]
 245                     << " not supported in point map.  This is not allowed."
 246                     << endl;
 247
 248                 error = true;
 249             }
 250         }
 251     }
 252
 253     return error;
 254 }
 255
 256
 257 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 258
 259
 260 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
 261
 262
 263 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 264
 265
 266 // ************************************************************************* //