src/OpenFOAM/coordinateSystems/coordinateRotation/coordinateRotation.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     Foam::coordinateRotation
  27
  28 Description
  29     A coordinate rotation specified per local axes and the base class for
  30     other rotation specifications
  31
  32     The rotation is defined by a combination of local vectors (e1/e2), (e2/e3)
  33     or (e3/e1). Any nonorthogonality will be absorbed into the second vector.
  34
  35     For convenience, the dictionary constructor forms allow a few shortcuts:
  36     - if the @c type is not otherwise specified, the type @c axes
  37       is implicit
  38     - if an axes specification (eg, e3/e1) is used, the coordinateRotation
  39       sub-dictionary can be dropped.
  40
  41     Specifying the rotation by an EulerCoordinateRotation
  42     (type "EulerRotation") or by a STARCDCoordinateRotation
  43     (type "STARCDRotation") requires the coordinateRotation sub-dictionary.
  44
  45     @verbatim
  46         coordinateRotation
  47         {
  48             type        STARCDRotation
  49             rotation    (0 0 90);
  50         }
  51     @endverbatim
  52
  53     - the rotation angles are in degrees, unless otherwise explictly specified:
  54
  55     @verbatim
  56         coordinateRotation
  57         {
  58             type        STARCDRotation
  59             degrees     false;
  60             rotation    (0 0 3.141592654);
  61         }
  62     @endverbatim
  63
  64 Deprecated
  65     Specifying the local vectors as an @c axis (corresponding to e3) and a
  66     @c direction (corresponding to e1), is allowed for backwards
  67     compatibility, but this terminology is generally a bit confusing.
  68
  69 \*---------------------------------------------------------------------------*/
  70
  71 #ifndef coordinateRotation_H
  72 #define coordinateRotation_H
  73
  74 #include "vector.H"
  75 #include "tensor.H"
  76 #include "runTimeSelectionTables.H"
  77
  78 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  79
  80 namespace Foam
  81 {
  82
  83 class dictionary;
  84
  85 /*---------------------------------------------------------------------------*\
  86                     Class coordinateRotation Declaration
  87 \*---------------------------------------------------------------------------*/
  88
  89 class coordinateRotation
  90 :
  91     public tensor
  92 {
  93     // Private data
  94
  95         //- the combination of local axes to be used
  96         enum axisOrder
  97         {
  98             e1e2,
  99             e2e3,
 100             e3e1
 101         };
 102
 103
 104     // Private Member Functions
 105
 106         //- Calculate transformation tensor
 107         void calcTransform
 108         (
 109             const vector& axis1,
 110             const vector& axis2,
 111             const axisOrder& order = e3e1
 112         );
 113
 114
 115 public:
 116
 117     //- Runtime type information
 118     TypeName("coordinateRotation");
 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 // ************************************************************************* //