src/lduSolvers/crMatrix/crAddressing.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-6 H. Jasak All rights reserved
   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     crAddressing
  27
  28 Description
  29     Compressed row addressing class
  30
  31 Author
  32     Hrvoje Jasak, Wikki Ltd.  All rights reserved
  33
  34 \*----------------------------------------------------------------------------*/
  35
  36 #include "crAddressing.H"
  37
  38 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  39
  40 void Foam::crAddressing::setRowCount(const labelList& count)
  41 {
  42     if (count.size() != nRows_)
  43     {
  44         FatalErrorIn("void crAddressing::setRowCount(const labelList& count)")
  45             << "Incorrect size of count: nRows =" << nRows_
  46             << " count = " << count.size()
  47             << abort(FatalError);
  48
  49     }
  50
  51     // Accumulate count
  52     row_[0] = 0;
  53
  54     forAll (count, i)
  55     {
  56         row_[i + 1] = row_[i] + count[i];
  57     }
  58
  59     // Resize and clear column array
  60     col_.setSize(row_[nRows_]);
  61     col_ = 0;
  62 }
  63
  64
  65 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  66
  67 // Construct from given size
  68 Foam::crAddressing::crAddressing
  69 (
  70     const label nRows,
  71     const label nCols,
  72     const labelList& count
  73 )
  74 :
  75     refCount(),
  76     nRows_(nRows),
  77     nCols_(nCols),
  78     row_(nRows + 1),
  79     col_(0)
  80 {
  81     setRowCount(count);
  82 }
  83
  84
  85 // Construct from components
  86 Foam::crAddressing::crAddressing
  87 (
  88     const label nRows,
  89     const label nCols,
  90     const labelList& row,
  91     const labelList& col
  92 )
  93 :
  94     refCount(),
  95     nRows_(nRows),
  96     nCols_(nCols),
  97     row_(row),
  98     col_(col)
  99 {}
 100
 101
 102 // Construct as copy
 103 Foam::crAddressing::crAddressing(const crAddressing& a)
 104 :
 105     refCount(),
 106     nRows_(a.nRows_),
 107     nCols_(a.nCols_),
 108     row_(a.row_),
 109     col_(a.col_)
 110 {}
 111
 112
 113 // Construct from Istream
 114 Foam::crAddressing::crAddressing(Istream& is)
 115 :
 116     refCount(),
 117     nRows_(readLabel(is)),
 118     nCols_(readLabel(is)),
 119     row_(is),
 120     col_(is)
 121 {}
 122
 123
 124 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 125
 126 Foam::tmp<Foam::crAddressing> Foam::crAddressing::T() const
 127 {
 128     const labelList& myRow = row();
 129     const labelList& myCol = col();
 130
 131     labelList trCount(nCols(), 0);
 132
 133     // Count number of entries in a row
 134     for (label i = 0; i < nRows(); i++)
 135     {
 136         for (label ip = myRow[i]; ip < myRow[i + 1]; ip++)
 137         {
 138             trCount[myCol[ip]]++;
 139         }
 140     }
 141
 142     // Create transpose addressing
 143     tmp<crAddressing> ttranspose(new crAddressing(nCols(), nRows(), trCount));
 144     crAddressing& transpose = ttranspose();
 145
 146     // Set coefficients
 147     const labelList& trRow = transpose.row();
 148     labelList& trCol = transpose.col();
 149     trCol = 0;
 150
 151     // Reset count to use as counter
 152     trCount = 0;
 153
 154     label j;
 155
 156     for (label i = 0; i < nRows(); i++)
 157     {
 158         for (label ip = myRow[i]; ip < myRow[i + 1]; ip++)
 159         {
 160             j = myCol[ip];
 161
 162             trCol[trRow[j] + trCount[j]] = i;
 163
 164             trCount[j]++;
 165         }
 166     }
 167
 168     return ttranspose;
 169 }
 170
 171
 172 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 173
 174 void Foam::crAddressing::operator=(const crAddressing& rhs)
 175 {
 176     // Check for assignment to self
 177     if (this == &rhs)
 178     {
 179         FatalErrorIn("Foam::crAddressing::operator=(const Foam::crAddressing&)")
 180             << "Attempted assignment to self"
 181             << abort(FatalError);
 182     }
 183
 184     nRows_ = rhs.nRows_;
 185     nCols_ = rhs.nCols_;
 186     row_ = rhs.row_;
 187     col_ = rhs.col_;
 188 }
 189
 190
 191 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 192
 193 Foam::Ostream& Foam::operator<<(Ostream& os, const crAddressing& a)
 194 {
 195     os  << a.nRows_ << tab << a.nCols_ << nl
 196         << a.row_ << nl
 197         << a.col_ << endl;
 198
 199     return os;
 200 }
 201
 202
 203 // ************************************************************************* //