src/OpenFOAM/matrices/lduMatrix/lduAddressing/lduAddressing.H

   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 Class
  26     Foam::lduAddressing
  27
  28 Description
  29     The class contains the addressing required by the lduMatrix: upper, lower
  30     and losort.
  31
  32     The addressing can be created in two ways: either with references to
  33     upper and lower in which case it stores references or from labelLists,
  34     in which case it stores the addressing itself. Additionally, the losort
  35     addressing belongs to the class is as on lazy evaluation.
  36
  37     The ordering of owner addresses is such that the labels are in
  38     increasing order, with groups of identical labels for edges "owned" by
  39     the same point. The neighbour labels are also ordered in ascending
  40     order but only for groups of edges belonging to each point. An example
  41     is given below:
  42     @verbatim
  43         owner     eighbour
  44         0         1
  45         0         20
  46         1         2
  47         1         21
  48         2         3
  49         2         22
  50         3         4
  51         3         23
  52         4         5
  53         4         24
  54         5         6
  55         5         25
  56         6         7
  57         6         26
  58         7         8
  59         7         27
  60         8         9
  61         8         28
  62         9         10
  63         9         29
  64     @endverbatim
  65
  66     There exists an alternative way of addressing the owner
  67     list: instead of repeating the same label in the owner list, it is
  68     possible to address the start of each point neighbours in the
  69     neighbour list. This reduces the size of owner addressing from a list
  70     over all edges to a list over all points + 1:
  71
  72     @verbatim
  73         Owner start list: 0 2 4 6 8 10 12 14 16 18
  74     @endverbatim
  75
  76     We shall use the second form of the addressing for fast lookup
  77     of edge label from the known owner and neighbour, using the following
  78     algorithm:
  79     -# take the owner label and position the start of lookup
  80        using the owner start list
  81     -# loop through all neighbours of this owner (ending at the start of
  82       lookup of owner + 1) until the match with current neighbour is found.
  83       The index used on the neighbour list for the match is the edge index.
  84
  85     While owner start addressing allows us to find the edge owned by the
  86     points, it is also necessary to find the edges for which the point is
  87     a neighbour. Losort addressing lists the edges neighboured by the
  88     point and we shall use the same trick as above to address into this
  89     list. Thus, for every point the losort start gives the address of the
  90     first face to neighbour this point.
  91
  92 SourceFiles
  93     lduAddressing.C
  94
  95 \*---------------------------------------------------------------------------*/
  96
  97 #ifndef lduAddressing_H
  98 #define lduAddressing_H
  99
 100 #include "labelList.H"
 101 #include "lduSchedule.H"
 102
 103 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 104
 105 namespace Foam
 106 {
 107
 108 /*---------------------------------------------------------------------------*\
 109                            Class lduAddressing Declaration
 110 \*---------------------------------------------------------------------------*/
 111
 112 class lduAddressing
 113 {
 114     // Private data
 115
 116         //- Number of equations
 117         label size_;
 118
 119
 120     //- Demand-driven data
 121
 122         //- Losort addressing
 123         mutable labelList* losortPtr_;
 124
 125         //- Owner start addressing
 126         mutable labelList* ownerStartPtr_;
 127
 128         //- Losort start addressing
 129         mutable labelList* losortStartPtr_;
 130
 131
 132     // Private Member Functions
 133
 134         //- Disallow default bitwise copy construct
 135         lduAddressing(const lduAddressing&);
 136
 137         //- Disallow default bitwise assignment
 138         void operator=(const lduAddressing&);
 139
 140         //- Calculate losort
 141         void calcLosort() const;
 142
 143         //- Calculate owner start
 144         void calcOwnerStart() const;
 145
 146         //- Calculate losort start
 147         void calcLosortStart() const;
 148
 149
 150 public:
 151
 152     // Constructor
 153     lduAddressing(const label nEqns)
 154     :
 155         size_(nEqns),
 156         losortPtr_(NULL),
 157         ownerStartPtr_(NULL),
 158         losortStartPtr_(NULL)
 159     {}
 160
 161
 162     // Destructor
 163
 164         virtual ~lduAddressing();
 165
 166
 167     // Member Functions
 168
 169         //- Return number of equations
 170         label size() const
 171         {
 172             return size_;
 173         }
 174
 175         //- Return number of interfaces
 176         virtual label nPatches() const = 0;
 177
 178         //- Return lower addressing
 179         virtual const unallocLabelList& lowerAddr() const = 0;
 180
 181         //- Return upper addressing
 182         virtual const unallocLabelList& upperAddr() const = 0;
 183
 184         //- Return patch to internal addressing given patch number
 185         virtual const unallocLabelList& patchAddr
 186         (
 187             const label patchNo
 188         ) const = 0;
 189
 190         // Return patch field evaluation schedule
 191         virtual const lduSchedule& patchSchedule() const = 0;
 192
 193         //- Return losort addressing
 194         const unallocLabelList& losortAddr() const;
 195
 196         //- Return owner start addressing
 197         const unallocLabelList& ownerStartAddr() const;
 198
 199         //- Return losort start addressing
 200         const unallocLabelList& losortStartAddr() const;
 201
 202         //- Return off-diagonal index given owner and neighbour label
 203         label triIndex(const label a, const label b) const;
 204 };
 205
 206
 207 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 208
 209 } // End namespace Foam
 210
 211 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 212
 213 #endif
 214
 215 // ************************************************************************* //