src/meshTools/coordinateSystems/coordinateRotation/coordinateRotation.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2011 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 Class
  25     Foam::coordinateRotation
  26
  27 Description
  28     A coordinate rotation specified per local axes and the base class for
  29     other rotation specifications
  30
  31     The rotation is defined by a combination of local vectors (e1/e2), (e2/e3)
  32     or (e3/e1). Any nonorthogonality will be absorbed into the second vector.
  33
  34     For convenience, the dictionary constructor forms allow a few shortcuts:
  35     - if the \c type is not otherwise specified, the type \c axes
  36       is implicit
  37     - if an axes specification (eg, e3/e1) is used, the coordinateRotation
  38       sub-dictionary can be dropped.
  39
  40     Specifying the rotation by an EulerCoordinateRotation
  41     (type "EulerRotation") or by a STARCDCoordinateRotation
  42     (type "STARCDRotation") requires the coordinateRotation sub-dictionary.
  43
  44     \verbatim
  45         coordinateRotation
  46         {
  47             type        STARCDRotation
  48             rotation    (0 0 90);
  49         }
  50     \endverbatim
  51
  52     - the rotation angles are in degrees, unless otherwise explictly specified:
  53
  54     \verbatim
  55         coordinateRotation
  56         {
  57             type        STARCDRotation
  58             degrees     false;
  59             rotation    (0 0 3.141592654);
  60         }
  61     \endverbatim
  62
  63 Deprecated
  64     Specifying the local vectors as an \c axis (corresponding to e3) and a
  65     \c direction (corresponding to e1), is allowed for backwards
  66     compatibility, but this terminology is generally a bit confusing.
  67     (deprecated Apr 2008)
  68
  69 \*---------------------------------------------------------------------------*/
  70
  71 #ifndef coordinateRotation_H
  72 #define coordinateRotation_H
  73
  74 #include "vector.H"
  75 #include "tensor.H"
  76 #include "dictionary.H"
  77 #include "runTimeSelectionTables.H"
  78
  79 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  80
  81 namespace Foam
  82 {
  83
  84 /*---------------------------------------------------------------------------*\
  85                     Class coordinateRotation Declaration
  86 \*---------------------------------------------------------------------------*/
  87
  88 class coordinateRotation
  89 :
  90     public tensor
  91 {
  92     // Private data
  93
  94         //- the combination of local axes to be used
  95         enum axisOrder
  96         {
  97             e1e2,
  98             e2e3,
  99             e3e1
 100         };
 101
 102     // Private Member Functions
 103
 104         //- Calculate transformation tensor
 105         void calcTransform
 106         (
 107             const vector& axis1,
 108             const vector& axis2,
 109             const axisOrder& order = e3e1
 110         );
 111
 112 public:
 113
 114     //- Runtime type information
 115     TypeName("coordinateRotation");
 116
 117     // Constructors
 118
 119         //- Construct null
 120         coordinateRotation();
 121
 122         //- Construct from 2 axes
 123         coordinateRotation
 124         (
 125             const vector& axis,
 126             const vector& dir
 127         );
 128
 129         //- Construct from dictionary
 130         coordinateRotation(const dictionary&);
 131
 132         //- Return clone
 133         autoPtr<coordinateRotation> clone() const
 134         {
 135             return autoPtr<coordinateRotation>(new coordinateRotation(*this));
 136         }
 137
 138     // Declare run-time constructor selection table
 139
 140         declareRunTimeSelectionTable
 141         (
 142             autoPtr,
 143             coordinateRotation,
 144             dictionary,
 145             (
 146                 const dictionary& dict
 147             ),
 148             (dict)
 149         );
 150
 151
 152     // Selectors
 153
 154         //- Select constructed from Istream
 155         static autoPtr<coordinateRotation> New
 156         (
 157             const dictionary& dict
 158         );
 159
 160
 161     //- Destructor
 162     virtual ~coordinateRotation()
 163     {}
 164
 165
 166     // Member Functions
 167
 168         //- Reset rotation to an identity rotation
 169         virtual void clear();
 170
 171         //- Return local-to-global transformation tensor
 172         const tensor& R() const
 173         {
 174             return (*this);
 175         }
 176
 177         //- Return local Cartesian x-axis
 178         const vector e1() const
 179         {
 180             return tensor::T().x();
 181         }
 182
 183         //- Return local Cartesian y-axis
 184         const vector e2() const
 185         {
 186             return tensor::T().y();
 187         }
 188
 189         //- Return local Cartesian z-axis
 190         const vector e3() const
 191         {
 192             return tensor::T().z();
 193         }
 194
 195
 196     // Member Operators
 197
 198         //- assign from dictionary
 199         void operator=(const dictionary&);
 200
 201 };
 202
 203
 204 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 205
 206 } // End namespace Foam
 207
 208 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 209
 210 #endif
 211
 212 // ************************************************************************* //