src/foam/coordinateSystems/coordinateRotation/coordinateRotation.H

   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 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
  68 \*---------------------------------------------------------------------------*/
  69
  70 #ifndef coordinateRotation_H
  71 #define coordinateRotation_H
  72
  73 #include "vector.H"
  74 #include "tensor.H"
  75 #include "runTimeSelectionTables.H"
  76
  77 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  78
  79 namespace Foam
  80 {
  81
  82 class dictionary;
  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
 103     // Private Member Functions
 104
 105         //- Calculate transformation tensor
 106         void calcTransform
 107         (
 108             const vector& axis1,
 109             const vector& axis2,
 110             const axisOrder& order = e3e1
 111         );
 112
 113
 114 public:
 115
 116     //- Runtime type information
 117     TypeName("coordinateRotation");
 118
 119
 120     // Constructors
 121
 122         //- Construct null
 123         coordinateRotation();
 124
 125         //- Construct from 2 axes
 126         coordinateRotation
 127         (
 128             const vector& axis,
 129             const vector& dir
 130         );
 131
 132         //- Construct from 1 vector and angle
 133         coordinateRotation
 134         (
 135             const vector& v,
 136             const scalar angle
 137         );
 138
 139         //- Construct from dictionary
 140         coordinateRotation(const dictionary&);
 141
 142         //- Return clone
 143         autoPtr<coordinateRotation> clone() const
 144         {
 145             return autoPtr<coordinateRotation>(new coordinateRotation(*this));
 146         }
 147
 148     // Declare run-time constructor selection table
 149
 150 #ifndef SWIG
 151         declareRunTimeSelectionTable
 152         (
 153             autoPtr,
 154             coordinateRotation,
 155             dictionary,
 156             (
 157                 const dictionary& dict
 158             ),
 159             (dict)
 160         );
 161 #endif
 162
 163
 164     // Selectors
 165
 166         //- Select constructed from Istream
 167         static autoPtr<coordinateRotation> New
 168         (
 169             const dictionary& dict
 170         );
 171
 172
 173     // Destructor
 174
 175         virtual ~coordinateRotation()
 176         {}
 177
 178
 179     // Member Functions
 180
 181         //- Return local-to-global transformation tensor
 182         const tensor& R() const
 183         {
 184             return (*this);
 185         }
 186
 187         //- Return local Cartesian x-axis
 188         vector e1() const
 189         {
 190             return tensor::T().x();
 191         }
 192
 193         //- Return local Cartesian y-axis
 194         vector e2() const
 195         {
 196             return tensor::T().y();
 197         }
 198
 199         //- Return local Cartesian z-axis
 200         vector e3() const
 201         {
 202             return tensor::T().z();
 203         }
 204
 205
 206     // Member Operators
 207
 208         //- assign from dictionary
 209         void operator=(const dictionary&);
 210
 211 };
 212
 213
 214 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 215
 216 } // End namespace Foam
 217
 218 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 219
 220 #endif
 221
 222 // ************************************************************************* //