src/OpenFOAM/meshes/polyMesh/zones/zone/zone.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2009-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 \*---------------------------------------------------------------------------*/
  25
  26 #include "zone.H"
  27 #include "IOstream.H"
  28 #include "demandDrivenData.H"
  29
  30 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  31
  32 defineTypeNameAndDebug(Foam::zone, 0);
  33
  34
  35 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
  36
  37 const Foam::Map<Foam::label>& Foam::zone::lookupMap() const
  38 {
  39     if (!lookupMapPtr_)
  40     {
  41         calcLookupMap();
  42     }
  43
  44     return *lookupMapPtr_;
  45 }
  46
  47
  48 void Foam::zone::calcLookupMap() const
  49 {
  50     if (debug)
  51     {
  52         Info<< "void zone::calcLookupMap() const: "
  53             << "Calculating lookup map"
  54             << endl;
  55     }
  56
  57     if (lookupMapPtr_)
  58     {
  59         FatalErrorIn("void zone::calcLookupMap() const")
  60             << "Lookup map already calculated" << nl
  61             << abort(FatalError);
  62     }
  63
  64     const labelList& addr = *this;
  65
  66     lookupMapPtr_ = new Map<label>(2*addr.size());
  67     Map<label>& lm = *lookupMapPtr_;
  68
  69     forAll(addr, i)
  70     {
  71         lm.insert(addr[i], i);
  72     }
  73
  74     if (debug)
  75     {
  76         Info<< "void zone::calcLookupMap() const: "
  77             << "Finished calculating lookup map"
  78             << endl;
  79     }
  80 }
  81
  82
  83 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  84
  85 Foam::zone::zone
  86 (
  87     const word& name,
  88     const labelUList& addr,
  89     const label index
  90 )
  91 :
  92     labelList(addr),
  93     name_(name),
  94     index_(index),
  95     lookupMapPtr_(NULL)
  96 {}
  97
  98
  99 Foam::zone::zone
 100 (
 101     const word& name,
 102     const Xfer<labelList>& addr,
 103     const label index
 104 )
 105 :
 106     labelList(addr),
 107     name_(name),
 108     index_(index),
 109     lookupMapPtr_(NULL)
 110 {}
 111
 112
 113 Foam::zone::zone
 114 (
 115     const word& name,
 116     const dictionary& dict,
 117     const word& labelsName,
 118     const label index
 119 )
 120 :
 121     labelList(dict.lookup(labelsName)),
 122     name_(name),
 123     index_(index),
 124     lookupMapPtr_(NULL)
 125 {}
 126
 127
 128 Foam::zone::zone
 129 (
 130     const zone& z,
 131     const labelUList& addr,
 132     const label index
 133 )
 134 :
 135     labelList(addr),
 136     name_(z.name()),
 137     index_(index),
 138     lookupMapPtr_(NULL)
 139 {}
 140
 141
 142 Foam::zone::zone
 143 (
 144     const zone& z,
 145     const Xfer<labelList>& addr,
 146     const label index
 147 )
 148 :
 149     labelList(addr),
 150     name_(z.name()),
 151     index_(index),
 152     lookupMapPtr_(NULL)
 153 {}
 154
 155
 156 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 157
 158 Foam::zone::~zone()
 159 {
 160     clearAddressing();
 161 }
 162
 163
 164 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 165
 166 Foam::label Foam::zone::localID(const label globalCellID) const
 167 {
 168     const Map<label>& lm = lookupMap();
 169
 170     Map<label>::const_iterator lmIter = lm.find(globalCellID);
 171
 172     if (lmIter == lm.end())
 173     {
 174         return -1;
 175     }
 176     else
 177     {
 178         return lmIter();
 179     }
 180 }
 181
 182
 183 void Foam::zone::clearAddressing()
 184 {
 185     deleteDemandDrivenData(lookupMapPtr_);
 186 }
 187
 188
 189 bool Foam::zone::checkDefinition(const label maxSize, const bool report) const
 190 {
 191     const labelList& addr = *this;
 192
 193     bool hasError = false;
 194
 195     forAll(addr, i)
 196     {
 197         if (addr[i] < 0 || addr[i] >= maxSize)
 198         {
 199             hasError = true;
 200
 201             if (report)
 202             {
 203                 SeriousErrorIn
 204                 (
 205                     "bool zone::checkDefinition("
 206                     "const label maxSize, const bool report) const"
 207                 )   << "Zone " << name_
 208                     << " contains invalid index label " << addr[i] << nl
 209                     << "Valid index labels are 0.."
 210                     << maxSize-1 << endl;
 211             }
 212             else
 213             {
 214                 // w/o report - can stop checking now
 215                 break;
 216             }
 217         }
 218     }
 219
 220     return hasError;
 221 }
 222
 223
 224 void Foam::zone::write(Ostream& os) const
 225 {
 226     os  << nl << name_
 227         << nl << static_cast<const labelList&>(*this);
 228 }
 229
 230
 231 // * * * * * * * * * * * * * * * Ostream Operator  * * * * * * * * * * * * * //
 232
 233 Foam::Ostream& Foam::operator<<(Ostream& os, const zone& z)
 234 {
 235     z.write(os);
 236     os.check("Ostream& operator<<(Ostream& f, const zone& z");
 237     return os;
 238 }
 239
 240
 241 // ************************************************************************* //