src/meshTools/coordinateSystems/coordinateSystem.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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 Class
  25     Foam::coordinateSystem
  26
  27 Description
  28     A cartesian coordinate system and the base class for other coordinate
  29     system specifications.
  30
  31     All systems are defined by an origin point and a coordinateRotation.
  32     For convenience, the dictionary constructor forms allow a few shortcuts:
  33     - the default origin corresponds to <em>(0 0 0)</em>
  34     - if the \c type is not otherwise specified, a Cartesian coordinateSystem
  35       is implicit
  36
  37     \verbatim
  38         flipped
  39         {
  40             origin  (0 0 0);
  41             coordinateRotation
  42             {
  43                 type        STARCDRotation;
  44                 rotation    (0 0 90);
  45             }
  46         }
  47     \endverbatim
  48
  49     - if an axes specification (eg, e3/e1) is used, the coordinateRotation
  50       sub-dictionary can be dropped.
  51
  52     \verbatim
  53         flipped     // the same, specified as axes
  54         {
  55             origin  (0 0 0);
  56             coordinateRotation
  57             {
  58                 type    axes;
  59                 e3      (1 0 0);
  60                 e1      (0 0 -1);
  61             }
  62         }
  63         flipped     // the same, using all the shortcuts
  64         {
  65             e3      (1 0 0);
  66             e1      (0 0 -1);
  67         }
  68     \endverbatim
  69
  70     - if a sub-dictionary coordinateSystem is found within the dictionary, it
  71       will be used. This provides a convenient means of embedding
  72       coordinateSystem information in another dictionary.
  73       This is used, for example, in the porousZones:
  74
  75     \verbatim
  76         1
  77         (
  78         cat1
  79         {
  80             coordinateSystem
  81             {
  82                 origin  (0 0 0);
  83                 coordinateRotation
  84                 {
  85                     type        STARCDRotation;
  86                     rotation    (0 0 90);
  87                 }
  88             }
  89             porosity        0.781;
  90             Darcy
  91             {
  92                 d   d [0 -2 0 0 0]  (-1000 -1000 0.50753e+08);
  93                 f   f [0 -1 0 0 0]  (-1000 -1000 12.83);
  94             }
  95         }
  96         )
  97     \endverbatim
  98
  99     - additionally, if the coordinateSystem points to a plain entry,
 100       it can be used to reference one of the global coordinateSystems
 101
 102     \verbatim
 103         1
 104         (
 105         cat1
 106         {
 107             coordinateSystem  system_10;
 108             porosity        0.781;
 109             Darcy
 110             {
 111                 d   d [0 -2 0 0 0]  (-1000 -1000 0.50753e+08);
 112                 f   f [0 -1 0 0 0]  (-1000 -1000 12.83);
 113             }
 114         }
 115         )
 116     \endverbatim
 117     For this to work correctly, the coordinateSystem constructor must be
 118     supplied with both a dictionary and an objectRegistry.
 119
 120 See Also
 121     coordinateSystems and coordinateSystems::New
 122
 123 SourceFiles
 124     coordinateSystem.C
 125     newCoordinateSystem.C
 126 \*---------------------------------------------------------------------------*/
 127
 128 #ifndef coordinateSystem_H
 129 #define coordinateSystem_H
 130
 131 #include "vector.H"
 132 #include "point.H"
 133 #include "tensor.H"
 134 #include "vectorField.H"
 135 #include "pointField.H"
 136 #include "tmp.H"
 137 #include "coordinateRotation.H"
 138 #include "objectRegistry.H"
 139
 140 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 141
 142 namespace Foam
 143 {
 144
 145 /*---------------------------------------------------------------------------*\
 146                      Class coordinateSystem Declaration
 147 \*---------------------------------------------------------------------------*/
 148
 149 class coordinateSystem
 150 {
 151     // Private data
 152
 153         //- Name of coordinate system
 154         mutable word name_;
 155
 156         //- Optional note
 157         mutable string note_;
 158
 159         //- Origin
 160         mutable point origin_;
 161
 162         //- Local-to-Global transformation tensor
 163         coordinateRotation R_;
 164
 165         //- Global-to-Local transformation tensor
 166         tensor Rtr_;
 167
 168
 169 protected:
 170
 171     // Protected Member Functions
 172
 173         //- Convert from local coordinate system to the global Cartesian system
 174         //  with optional translation for the origin
 175         virtual vector localToGlobal(const vector&, bool translate) const;
 176
 177         //- Convert from local coordinate system to the global Cartesian system
 178         //  with optional translation for the origin
 179         virtual tmp<vectorField> localToGlobal
 180         (
 181             const vectorField&,
 182             bool translate
 183         ) const;
 184
 185         //- Convert from global Cartesian system to the local coordinate system
 186         //  with optional translation for the origin
 187         virtual vector globalToLocal(const vector&, bool translate) const;
 188
 189         //- Convert from global Cartesian system to the local coordinate system
 190         //  with optional translation for the origin
 191         virtual tmp<vectorField> globalToLocal
 192         (
 193             const vectorField&,
 194             bool translate
 195         ) const;
 196
 197
 198 public:
 199
 200     //- Runtime type information
 201     TypeName("coordinateSystem");
 202
 203
 204     // Constructors
 205
 206         //- Construct null. This is equivalent to an identity coordinateSystem
 207         coordinateSystem();
 208
 209         //- Construct copy with a different name
 210         coordinateSystem
 211         (
 212             const word& name,
 213             const coordinateSystem&
 214         );
 215
 216         //- Construct from origin and rotation
 217         coordinateSystem
 218         (
 219             const word& name,
 220             const point& origin,
 221             const coordinateRotation&
 222         );
 223
 224         //- Construct from origin and 2 axes
 225         coordinateSystem
 226         (
 227             const word& name,
 228             const point& origin,
 229             const vector& axis,
 230             const vector& dirn
 231         );
 232
 233         //- Construct from dictionary with a given name
 234         coordinateSystem(const word& name, const dictionary&);
 235
 236         //- Construct from dictionary with default name
 237         coordinateSystem(const dictionary&);
 238
 239         //- Construct from dictionary (default name)
 240         //  With the ability to reference global coordinateSystems
 241         coordinateSystem(const dictionary&, const objectRegistry&);
 242
 243         //- Construct from Istream
 244         //  The Istream contains a word followed by a dictionary
 245         coordinateSystem(Istream&);
 246
 247         //- Return clone
 248         autoPtr<coordinateSystem> clone() const
 249         {
 250             return autoPtr<coordinateSystem>(new coordinateSystem(*this));
 251         }
 252
 253
 254     // Declare run-time constructor selection table
 255
 256         declareRunTimeSelectionTable
 257         (
 258             autoPtr,
 259             coordinateSystem,
 260             dictionary,
 261             (
 262                 const word& name,
 263                 const dictionary& dict
 264             ),
 265             (name, dict)
 266         );
 267
 268         declareRunTimeSelectionTable
 269         (
 270             autoPtr,
 271             coordinateSystem,
 272             origRotation,
 273             (
 274                 const word& name,
 275                 const point& origin,
 276                 const coordinateRotation& cr
 277             ),
 278             (name, origin, cr)
 279         );
 280
 281
 282     // Selectors
 283
 284         //- Select constructed from dictionary
 285         static autoPtr<coordinateSystem> New
 286         (
 287             const word& name,
 288             const dictionary&
 289         );
 290
 291         //- Select constructed from origin and rotation
 292         static autoPtr<coordinateSystem> New
 293         (
 294             const word& coordType,
 295             const word& name,
 296             const point& origin,
 297             const coordinateRotation&
 298         );
 299
 300         //- Select constructed from Istream
 301         static autoPtr<coordinateSystem> New(Istream& is);
 302
 303
 304     //- Destructor
 305     virtual ~coordinateSystem();
 306
 307
 308     // Member Functions
 309
 310         // Access
 311
 312             //- Return name
 313             const word& name() const
 314             {
 315                 return name_;
 316             }
 317
 318             //- Return non-constant access to the optional note
 319             string& note()
 320             {
 321                 return note_;
 322             }
 323
 324             //- Return the optional note
 325             const string& note() const
 326             {
 327                 return note_;
 328             }
 329
 330             //- Return origin
 331             const point& origin() const
 332             {
 333                 return origin_;
 334             }
 335
 336             //- Return coordinate rotation
 337             const coordinateRotation& rotation() const
 338             {
 339                 return R_;
 340             }
 341
 342             //- Return local-to-global transformation tensor
 343             const tensor& R() const
 344             {
 345                 return R_;
 346             }
 347
 348             //- Return local Cartesian x-axis
 349             const vector e1() const
 350             {
 351                 return Rtr_.x();
 352             }
 353
 354             //- Return local Cartesian y-axis
 355             const vector e2() const
 356             {
 357                 return Rtr_.y();
 358             }
 359
 360             //- Return local Cartesian z-axis
 361             const vector e3() const
 362             {
 363                 return Rtr_.z();
 364             }
 365
 366             //- Return axis (e3: local Cartesian z-axis)
 367             // \deprecated method e3 is preferred (deprecated Apr 2008)
 368             const vector axis() const
 369             {
 370                 return Rtr_.z();
 371             }
 372
 373             //- Return direction (e1: local Cartesian x-axis)
 374             // \deprecated method e1 is preferred (deprecated Apr 2008)
 375             const vector direction() const
 376             {
 377                 return Rtr_.x();
 378             }
 379
 380             //- Return as dictionary of entries
 381             //  \param [in] ignoreType drop type (cartesian, cylindrical, etc)
 382             //  when generating the dictionary
 383             virtual dictionary dict(bool ignoreType=false) const;
 384
 385
 386         // Edit
 387
 388             //- Rename
 389             virtual void rename(const word& newName)
 390             {
 391                 name_ = newName;
 392             }
 393
 394             //- Edit access to origin
 395             point& origin()
 396             {
 397                 return origin_;
 398             }
 399
 400             //- Reset origin and rotation to an identity coordinateSystem
 401             //  Also resets the note
 402             virtual void clear();
 403
 404
 405         // Write
 406
 407             //- Write
 408             virtual void write(Ostream&) const;
 409
 410             //- Write dictionary
 411             virtual void writeDict(Ostream&, bool subDict=true) const;
 412
 413
 414         // Transformations
 415
 416             //- Convert from position in local coordinate system to global
 417             //  Cartesian position
 418             point globalPosition(const point& local) const
 419             {
 420                 return localToGlobal(local, true);
 421             }
 422
 423             //- Convert from position in local coordinate system to global
 424             //  Cartesian position
 425             tmp<pointField> globalPosition(const pointField& local) const
 426             {
 427                 return localToGlobal(local, true);
 428             }
 429
 430             //- Convert from vector components in local coordinate system to
 431             //  global Cartesian vector
 432             vector globalVector(const vector& local) const
 433             {
 434                 return localToGlobal(local, false);
 435             }
 436
 437             //- Convert from vector components in local coordinate system to
 438             //  global Cartesian vector
 439             tmp<vectorField> globalVector(const vectorField& local) const
 440             {
 441                 return localToGlobal(local, false);
 442             }
 443
 444             //- Convert from global Cartesian position to position in local
 445             //  coordinate system
 446             point localPosition(const point& global) const
 447             {
 448                 return globalToLocal(global, true);
 449             }
 450
 451             //- Convert from global Cartesian position to position in local
 452             //  coordinate system
 453             tmp<pointField> localPosition(const pointField& global) const
 454             {
 455                 return globalToLocal(global, true);
 456             }
 457
 458             //- Convert from global Cartesian vector to components in local
 459             //  coordinate system
 460             vector localVector(const vector& global) const
 461             {
 462                 return globalToLocal(global, false);
 463             }
 464
 465             //- Convert from global Cartesian vector to components in local
 466             //  coordinate system
 467             tmp<vectorField> localVector(const vectorField& global) const
 468             {
 469                 return globalToLocal(global, false);
 470             }
 471
 472
 473     // Member Operators
 474
 475         //- assign from dictionary
 476         void operator=(const dictionary&);
 477
 478
 479     // friend Operators
 480
 481         friend bool operator!=
 482         (
 483             const coordinateSystem&,
 484             const coordinateSystem&
 485         );
 486
 487
 488     // IOstream Operators
 489
 490         friend Ostream& operator<<(Ostream&, const coordinateSystem&);
 491 };
 492
 493
 494 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 495
 496 } // End namespace Foam
 497
 498 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 499
 500 #endif
 501
 502 // ************************************************************************* //