src/OpenFOAM/meshes/meshShapes/cellShape/cellShapeEqual.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2010 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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, see <http://www.gnu.org/licenses/>.
  23
  24 Description
  25     Equality operator for cellShape class
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "cellShape.H"
  30
  31 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  32
  33 bool Foam::operator==(const cellShape& a, const cellShape& b)
  34 {
  35     // Basic rule: we assume that the sequence of labels in each list
  36     // will be circular in the same order (but not necessarily in the
  37     // same direction). The limitation of this method is that with 3D
  38     // topologies I cannot guarantee that a congruent but not
  39     // identical cellShape (i.e. one sharing the same points but in a
  40     // different order) will necessarily be matched.
  41
  42     const labelList& labsA = a;
  43     const labelList& labsB = b;
  44
  45     // Trivial reject: faces are different size
  46     label sizeA = labsA.size();
  47     label sizeB = labsB.size();
  48     if (sizeA != sizeB)
  49     {
  50         return false;
  51     }
  52
  53
  54     // First we look for the occurrence of the first label in A, in B
  55
  56     label Bptr = -1;
  57     label firstA = labsA[0];
  58     forAll(labsB, i)
  59     {
  60         if (labsB[i] == firstA)
  61         {
  62             Bptr = i;                // Denotes 'found match' at element 'i'
  63             break;
  64         }
  65     }
  66
  67     // If no match was found, exit false
  68     if (Bptr < 0)
  69     {
  70         return false;
  71     }
  72
  73     // Now we must look for the direction, if any
  74     label secondA = labsA[1];
  75     label dir = 0;
  76
  77     // Check whether at top of list
  78     Bptr++;
  79     if (Bptr == labsB.size())
  80     {
  81         Bptr = 0;
  82     }
  83
  84     // Test whether upward label matches second A label
  85     if (labsB[Bptr] == secondA)
  86     {
  87         // Yes - direction is 'up'
  88         dir = 1;
  89     }
  90     else
  91     {
  92         // No - so look downwards, checking whether at bottom of list
  93         Bptr -= 2;
  94         if (Bptr < 0)
  95         {
  96             // Case (1) Bptr=-1
  97             if (Bptr == -1)
  98             {
  99                 Bptr = labsB.size() - 1;
 100             }
 101
 102             // Case (2) Bptr = -2
 103             else
 104             {
 105                 Bptr = labsB.size() - 2;
 106             }
 107         }
 108
 109         // Test whether downward label matches second A label
 110         if (labsB[Bptr] == secondA)
 111         {
 112             // Yes - direction is 'down'
 113             dir = -1;
 114         }
 115     }
 116
 117     // Check whether a match was made at all, and exit false if not
 118     if (dir == 0)
 119     {
 120         return false;
 121     }
 122
 123     // Decrement size by 2 to account for first searches
 124     sizeA -= 2;
 125
 126     // We now have both direction of search and next element
 127     // to search, so we can continue search until no more points.
 128     label Aptr = 1;
 129     if (dir > 0)
 130     {
 131         while (sizeA--)
 132         {
 133             Aptr++;
 134             if (Aptr >= labsA.size())
 135             {
 136                 Aptr = 0;
 137             }
 138
 139             Bptr++;
 140             if (Bptr >= labsB.size())
 141             {
 142                 Bptr = 0;
 143             }
 144             if (labsA[Aptr] != labsB[Bptr])
 145             {
 146                 return false;
 147             }
 148         }
 149     }
 150     else
 151     {
 152         while (sizeA--)
 153         {
 154             Aptr++;
 155             if (Aptr >= labsA.size())
 156             {
 157                 Aptr = 0;
 158             }
 159
 160             Bptr--;
 161             if (Bptr < 0)
 162             {
 163                 Bptr = labsB.size() - 1;
 164             }
 165             if (labsA[Aptr] != labsB[Bptr])
 166             {
 167                 return false;
 168             }
 169         }
 170     }
 171
 172     // They must be equal
 173     return true;
 174 }
 175
 176
 177 // ************************************************************************* //