src/dynamicMesh/meshCut/cellLooper/cellLooper.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 Description
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "cellLooper.H"
  30 #include <OpenFOAM/polyMesh.H>
  31 #include <OpenFOAM/ListOps.H>
  32 #include <meshTools/meshTools.H>
  33
  34
  35
  36 namespace Foam
  37 {
  38
  39 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  40
  41 defineTypeNameAndDebug(cellLooper, 0);
  42 defineRunTimeSelectionTable(cellLooper, word);
  43
  44
  45
  46 // Construct named object from given arguments
  47 autoPtr<cellLooper> cellLooper::New
  48 (
  49     const word& type,
  50     const polyMesh& mesh
  51 )
  52 {
  53     wordConstructorTable::iterator cstrIter =
  54         wordConstructorTablePtr_
  55             ->find(type);
  56
  57     if (cstrIter == wordConstructorTablePtr_->end())
  58     {
  59         FatalErrorIn
  60         (
  61             "cellLooper::New(const word&, const polyMesh&)"
  62         )   << "Unknown set type " << type
  63             << endl << endl
  64             << "Valid cellLooper types : " << endl
  65             << wordConstructorTablePtr_->toc()
  66             << exit(FatalError);
  67     }
  68
  69     return autoPtr<cellLooper>(cstrIter()(mesh));
  70 }
  71
  72 }
  73
  74 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  75
  76 // Get faces (on cell) connected to vertI which are not using edgeI
  77 Foam::labelList Foam::cellLooper::getVertFacesNonEdge
  78 (
  79     const label cellI,
  80     const label edgeI,
  81     const label vertI
  82 ) const
  83 {
  84     // Get faces connected to startEdge
  85     label face0, face1;
  86     meshTools::getEdgeFaces(mesh(), cellI, edgeI, face0, face1);
  87
  88     const labelList& pFaces = mesh().pointFaces()[vertI];
  89
  90     labelList vertFaces(pFaces.size());
  91     label vertFaceI = 0;
  92
  93     forAll(pFaces, pFaceI)
  94     {
  95         label faceI = pFaces[pFaceI];
  96
  97         if
  98         (
  99             (faceI != face0)
 100          && (faceI != face1)
 101          && (meshTools::faceOnCell(mesh(), cellI, faceI))
 102         )
 103         {
 104             vertFaces[vertFaceI++] = faceI;
 105         }
 106     }
 107     vertFaces.setSize(vertFaceI);
 108
 109     return vertFaces;
 110 }
 111
 112
 113 // Get first edge connected to vertI and on faceI
 114 Foam::label Foam::cellLooper::getFirstVertEdge
 115 (
 116     const label faceI,
 117     const label vertI
 118 ) const
 119 {
 120     const labelList& fEdges = mesh().faceEdges()[faceI];
 121
 122     forAll(fEdges, fEdgeI)
 123     {
 124         label edgeI = fEdges[fEdgeI];
 125
 126         const edge& e = mesh().edges()[edgeI];
 127
 128         if ((e.start() == vertI) || (e.end() == vertI))
 129         {
 130             return edgeI;
 131         }
 132     }
 133
 134     FatalErrorIn
 135     (
 136         "getFirstVertEdge(const label, const label)"
 137     )   << "Can not find edge on face " << faceI
 138         << " using vertex " << vertI
 139         << abort(FatalError);
 140
 141     return -1;
 142 }
 143
 144
 145 // Get edges (on cell) connected to vertI which are not on faceI
 146 Foam::labelList Foam::cellLooper::getVertEdgesNonFace
 147 (
 148     const label cellI,
 149     const label faceI,
 150     const label vertI
 151 ) const
 152 {
 153     const labelList& exclEdges = mesh().faceEdges()[faceI];
 154
 155     const labelList& pEdges = mesh().pointEdges()[vertI];
 156
 157     labelList vertEdges(pEdges.size());
 158     label vertEdgeI = 0;
 159
 160     forAll(pEdges, pEdgeI)
 161     {
 162         label edgeI = pEdges[pEdgeI];
 163
 164         if
 165         (
 166             (findIndex(exclEdges, edgeI) == -1)
 167          && meshTools::edgeOnCell(mesh(), cellI, edgeI)
 168         )
 169         {
 170             vertEdges[vertEdgeI++] = edgeI;
 171         }
 172     }
 173
 174     vertEdges.setSize(vertEdgeI);
 175
 176     return vertEdges;
 177 }
 178
 179
 180 // Return edge from cellEdges that is most perpendicular
 181 // to refinement direction.
 182 Foam::label Foam::cellLooper::getMisAlignedEdge
 183 (
 184     const vector& refDir,
 185     const label cellI
 186 ) const
 187 {
 188     const labelList& cEdges = mesh().cellEdges()[cellI];
 189
 190     label cutEdgeI = -1;
 191     scalar maxCos = -GREAT;
 192
 193     forAll(cEdges, cEdgeI)
 194     {
 195         label edgeI = cEdges[cEdgeI];
 196
 197         scalar cosAngle = mag(refDir & meshTools::normEdgeVec(mesh(), edgeI));
 198
 199         if (cosAngle > maxCos)
 200         {
 201             maxCos = cosAngle;
 202
 203             cutEdgeI = edgeI;
 204         }
 205     }
 206
 207     return cutEdgeI;
 208 }
 209
 210
 211 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 212
 213 // Construct from components
 214 Foam::cellLooper::cellLooper(const polyMesh& mesh)
 215 :
 216     edgeVertex(mesh)
 217 {}
 218
 219
 220 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 221
 222 Foam::cellLooper::~cellLooper()
 223 {}
 224
 225
 226 // ************************ vim: set sw=4 sts=4 et: ************************ //