src/ODE/sixDOF/finiteRotation/finiteRotation.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     |
   5     \\  /    A nd           | For copyright notice see file Copyright
   6      \\/     M anipulation  |
   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     finiteRotation
  26
  27 Author
  28     Dubravko Matijasevic, FSB Zagreb.  All rights reserved.
  29     Updated by Hrvoje Jasak
  30
  31 SourceFiles
  32     finiteRotation.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef finiteRotation_H
  37 #define finiteRotation_H
  38
  39 #include "HamiltonRodriguezRot.H"
  40 #include "foamTime.H"
  41
  42 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  43
  44 namespace Foam
  45 {
  46 /*---------------------------------------------------------------------------*\
  47                          Class finiteRotation Declaration
  48 \*---------------------------------------------------------------------------*/
  49
  50 class finiteRotation
  51 {
  52     // Private data
  53
  54         //- Initial rotation
  55         HamiltonRodriguezRot eInitial_;
  56
  57         //- Rotational tensor
  58         tensor rotTensor_;
  59
  60         //- Incremental rotational tensor
  61         tensor rotIncrementTensor_;
  62
  63
  64     // Private Member Functions
  65
  66         //- Calculate unit rotation vector from given rotation tensor
  67         static vector rotVector(const tensor& rotT);
  68
  69         //- Calculate rotation angle from given rotation tensor
  70         static scalar rotAngle(const tensor& rotT);
  71
  72         //- Calculate Euler angles (x-y-z (roll-pitch-yaw) convention) from
  73         //  given rotation tensor. Reference: Mike Day, Insomniac Games,
  74         //  Extracting Euler Angles from a Rotation Matrix.
  75         static vector eulerAngles(const tensor& rotT);
  76
  77
  78 public:
  79
  80     // Constructors
  81
  82         //- Construct from cooordinate rotation
  83         explicit finiteRotation(const HamiltonRodriguezRot& rot);
  84
  85         //- Construct from rotation vector and angle
  86         finiteRotation
  87         (
  88             const vector& r,
  89             const scalar& angle
  90         );
  91
  92
  93     // Destructor
  94
  95         ~finiteRotation();
  96
  97
  98     // Member Functions
  99
 100         //- Update rotation
 101         void updateRotation(const HamiltonRodriguezRot& rot);
 102
 103         //- Return initial quaternions
 104         const HamiltonRodriguezRot& eInitial() const;
 105
 106         //- Return current quaternions
 107         HamiltonRodriguezRot eCurrent() const;
 108
 109         //-Transformations to inertial coordinate system
 110         const tensor& rotTensor() const;
 111
 112         //- Return rotation vector
 113         vector rotVector() const;
 114
 115         //- Return rotation angle
 116         scalar rotAngle() const;
 117
 118         //- Return Euler angles (see static function eulerAngles for convention)
 119         vector eulerAngles() const;
 120
 121         // Transformations between new and previous rotation
 122         const tensor& rotIncrementTensor() const;
 123
 124         //- Return rotation vector increment
 125         vector rotIncrementVector() const;
 126
 127         //- Return rotation angle increment
 128         scalar rotIncrementAngle() const;
 129
 130         // Return average rotational velocity vector
 131         vector omegaAverage(const scalar deltaT) const;
 132
 133         // Return mean rotation for last time step
 134         tensor rotTensorAverage() const;
 135
 136         // Return mean rotation vector for last time step
 137         vector rotVectorAverage() const;
 138
 139         // Return average rotational velocity vector in absolute coord. system
 140         vector omegaAverageAbsolute(const scalar deltaT) const;
 141 };
 142
 143
 144 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 145
 146 } // End namespace Foam
 147
 148 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 149
 150 #endif
 151
 152 // ************************************************************************* //