src/foam/coordinateSystems/coordinateSystem.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "IOstream.H"
  27 #include "coordinateSystem.H"
  28 #include "coordinateSystems.H"
  29 #include "boundBox.H"
  30 #include "addToRunTimeSelectionTable.H"
  31
  32 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  33
  34 namespace Foam
  35 {
  36     defineTypeNameAndDebug(coordinateSystem, 0);
  37     defineRunTimeSelectionTable(coordinateSystem, dictionary);
  38     defineRunTimeSelectionTable(coordinateSystem, origRotation);
  39 }
  40
  41 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  42
  43 Foam::coordinateSystem::coordinateSystem()
  44 :
  45     name_(type()),
  46     note_(),
  47     origin_(point::zero),
  48     R_(),
  49     Rtr_(sphericalTensor::I)
  50 {}
  51
  52
  53 Foam::coordinateSystem::coordinateSystem
  54 (
  55     const word& name,
  56     const coordinateSystem& cs
  57 )
  58 :
  59     name_(name),
  60     note_(),
  61     origin_(cs.origin_),
  62     R_(cs.R_),
  63     Rtr_(cs.Rtr_)
  64 {}
  65
  66
  67 Foam::coordinateSystem::coordinateSystem
  68 (
  69     const word& name,
  70     const point& origin,
  71     const coordinateRotation& cr
  72 )
  73 :
  74     name_(name),
  75     note_(),
  76     origin_(origin),
  77     R_(cr),
  78     Rtr_(R_.T())
  79 {}
  80
  81
  82 Foam::coordinateSystem::coordinateSystem
  83 (
  84     const word& name,
  85     const point& origin,
  86     const vector& axis,
  87     const vector& dirn
  88 )
  89 :
  90     name_(name),
  91     note_(),
  92     origin_(origin),
  93     R_(axis, dirn),
  94     Rtr_(R_.T())
  95 {}
  96
  97
  98 Foam::coordinateSystem::coordinateSystem
  99 (
 100     const word& name,
 101     const dictionary& dict
 102 )
 103 :
 104     name_(name),
 105     note_(),
 106     origin_(point::zero),
 107     R_(),
 108     Rtr_(sphericalTensor::I)
 109 {
 110     operator=(dict);
 111 }
 112
 113
 114 Foam::coordinateSystem::coordinateSystem
 115 (
 116     const dictionary& dict
 117 )
 118 :
 119     name_(type()),
 120     note_(),
 121     origin_(point::zero),
 122     R_(),
 123     Rtr_(sphericalTensor::I)
 124 {
 125     operator=(dict);
 126 }
 127
 128
 129 Foam::coordinateSystem::coordinateSystem
 130 (
 131     const dictionary& dict,
 132     const objectRegistry& obr
 133 )
 134 :
 135     name_(type()),
 136     note_(),
 137     origin_(point::zero),
 138     R_(),
 139     Rtr_(sphericalTensor::I)
 140 {
 141     const entry* entryPtr = dict.lookupEntryPtr(typeName_(), false, false);
 142
 143     // a simple entry is a lookup into global coordinateSystems
 144     if (entryPtr && !entryPtr->isDict())
 145     {
 146         word csName;
 147         entryPtr->stream() >> csName;
 148
 149         const coordinateSystems& csLst = coordinateSystems::New(obr);
 150
 151         label csId = csLst.find(csName);
 152         if (debug)
 153         {
 154             Info<< "coordinateSystem::coordinateSystem"
 155                 "(const dictionary&, const objectRegistry&):"
 156                 << nl << "using global coordinate system: "
 157                 << csName << "=" << csId << endl;
 158         }
 159
 160         if (csId < 0)
 161         {
 162             FatalErrorIn
 163             (
 164                 "coordinateSystem::coordinateSystem"
 165                 "(const dictionary&, const objectRegistry&)"
 166             )   << "could not find coordinate system: " << csName << nl
 167                 << "available coordinate systems: " << csLst.toc() << nl << nl
 168                 << exit(FatalError);
 169         }
 170
 171         // copy coordinateSystem, but assign the name as the typeName
 172         // to avoid strange things in writeDict()
 173         operator=(csLst[csId]);
 174         name_ = typeName_();
 175     }
 176     else
 177     {
 178         operator=(dict);
 179     }
 180 }
 181
 182
 183 Foam::coordinateSystem::coordinateSystem(Istream& is)
 184 :
 185     name_(is),
 186     note_(),
 187     origin_(point::zero),
 188     R_(),
 189     Rtr_(sphericalTensor::I)
 190 {
 191     dictionary dict(is);
 192     operator=(dict);
 193 }
 194
 195
 196 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 197
 198 Foam::coordinateSystem::~coordinateSystem()
 199 {}
 200
 201
 202 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 203
 204 Foam::coordinateSystem::spanInfo Foam::coordinateSystem::spanLimited() const
 205 {
 206     return spanInfo(Pair<bool>(false, false));
 207 }
 208
 209
 210 Foam::boundBox Foam::coordinateSystem::spanBounds() const
 211 {
 212     return boundBox::greatBox;
 213 }
 214
 215
 216 Foam::dictionary Foam::coordinateSystem::dict(bool ignoreType) const
 217 {
 218     dictionary dict;
 219
 220     dict.add("name", name_);
 221
 222     // only write type for derived types
 223     if (!ignoreType && type() != typeName_())
 224     {
 225         dict.add("type", type());
 226     }
 227
 228     // The note entry is optional
 229     if (note_.size())
 230     {
 231         dict.add("note", note_);
 232     }
 233
 234     dict.add("origin", origin_);
 235     dict.add("e1", e1());
 236     dict.add("e3", e3());
 237
 238     return dict;
 239 }
 240
 241
 242 Foam::vector Foam::coordinateSystem::localToGlobal
 243 (
 244     const vector& local,
 245     bool translate
 246 ) const
 247 {
 248     if (translate)
 249     {
 250         return (R_ & local) + origin_;
 251     }
 252     else
 253     {
 254         return (R_ & local);
 255     }
 256 }
 257
 258
 259 Foam::tmp<Foam::vectorField> Foam::coordinateSystem::localToGlobal
 260 (
 261     const vectorField& local,
 262     bool translate
 263 ) const
 264 {
 265     if (translate)
 266     {
 267         return (R_ & local) + origin_;
 268     }
 269     else
 270     {
 271         return (R_ & local);
 272     }
 273 }
 274
 275
 276 Foam::vector Foam::coordinateSystem::globalToLocal
 277 (
 278     const vector& global,
 279     bool translate
 280 ) const
 281 {
 282     if (translate)
 283     {
 284         return (Rtr_ & (global - origin_));
 285     }
 286     else
 287     {
 288         return (Rtr_ & global);
 289     }
 290 }
 291
 292
 293 Foam::tmp<Foam::vectorField> Foam::coordinateSystem::globalToLocal
 294 (
 295     const vectorField& global,
 296     bool translate
 297 ) const
 298 {
 299     if (translate)
 300     {
 301         return (Rtr_ & (global - origin_));
 302     }
 303     else
 304     {
 305         return (Rtr_ & global);
 306     }
 307 }
 308
 309
 310 void Foam::coordinateSystem::write(Ostream& os) const
 311 {
 312     os  << type()
 313         << " origin: " << origin()
 314         << " e1: " << e1() << " e3: " << e3();
 315 }
 316
 317
 318 void Foam::coordinateSystem::writeDict(Ostream& os, bool subDict) const
 319 {
 320     if (subDict)
 321     {
 322         os  << indent << nl
 323             << indent << token::BEGIN_BLOCK << incrIndent << nl;
 324     }
 325
 326     // only write type for derived types
 327     if (type() != typeName_())
 328     {
 329         os.writeKeyword("type") << type() << token::END_STATEMENT << nl;
 330     }
 331
 332     // The note entry is optional
 333     if (note_.size())
 334     {
 335         os.writeKeyword("note") << note_ << token::END_STATEMENT << nl;
 336     }
 337
 338     os.writeKeyword("name")   << name_    << token::END_STATEMENT << nl;
 339     os.writeKeyword("origin") << origin_  << token::END_STATEMENT << nl;
 340     os.writeKeyword("e1")     << e1()     << token::END_STATEMENT << nl;
 341     os.writeKeyword("e3")     << e3()     << token::END_STATEMENT << nl;
 342
 343     if (subDict)
 344     {
 345         os << decrIndent << indent << token::END_BLOCK << endl;
 346     }
 347 }
 348
 349 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 350
 351 void Foam::coordinateSystem::operator=(const dictionary& rhs)
 352 {
 353     if (debug)
 354     {
 355         Pout<< "coordinateSystem::operator=(const dictionary&) : "
 356             << "assign from " << rhs << endl;
 357     }
 358
 359     // allow as embedded sub-dictionary "coordinateSystem"
 360     const dictionary& dict =
 361     (
 362         rhs.found(typeName_())
 363       ? rhs.subDict(typeName_())
 364       : rhs
 365     );
 366
 367     // unspecified origin is (0 0 0)
 368     origin_ = point::zero;
 369     dict.readIfPresent("origin", origin_);
 370
 371     // The note entry is optional
 372     note_.clear();
 373     rhs.readIfPresent("note", note_);
 374
 375     // specify via coordinateRotation sub-dictionary
 376     if (dict.found("coordinateRotation"))
 377     {
 378         R_  = coordinateRotation::New(dict.subDict("coordinateRotation"))();
 379     }
 380     else
 381     {
 382         // let coordinateRotation constructor extract the axes specification
 383         R_ = coordinateRotation(dict);
 384     }
 385
 386     Rtr_ = R_.T();
 387 }
 388
 389
 390 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 391
 392 bool Foam::operator!=(const coordinateSystem& a, const coordinateSystem& b)
 393 {
 394     return (a.origin() != b.origin() || a.R() != b.R() || a.type() != b.type());
 395 }
 396
 397
 398 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
 399
 400 Foam::Ostream& Foam::operator<<(Ostream& os, const coordinateSystem& cs)
 401 {
 402     cs.write(os);
 403     os.check("Ostream& operator<<(Ostream&, const coordinateSystem&");
 404     return os;
 405 }
 406
 407
 408 // ************************************************************************* //