src/ODE/sixDOF/sixDOFqODE/sixDOFqODE.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     sixDOFqODE
  26
  27 Description
  28     6-DOF solver using quaternions
  29
  30 Author
  31     Dubravko Matijasevic, FSB Zagreb.  All rights reserved.
  32     Updated by Hrvoje Jasak.
  33
  34 SourceFiles
  35     sixDOFqODEI.H
  36     sixDOFqODE.C
  37
  38 \*---------------------------------------------------------------------------*/
  39
  40 #ifndef sixDOFqODE_H
  41 #define sixDOFqODE_H
  42
  43 #include "ODE.H"
  44 #include "IOdictionary.H"
  45 #include "dimensionedTypes.H"
  46 #include "HamiltonRodriguezRot.H"
  47 #include "finiteRotation.H"
  48 #include "vectorField.H"
  49
  50 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  51
  52 namespace Foam
  53 {
  54
  55 /*---------------------------------------------------------------------------*\
  56                          Class sixDOFqODE Declaration
  57 \*---------------------------------------------------------------------------*/
  58
  59 class sixDOFqODE
  60 :
  61     public IOdictionary,
  62     public ODE
  63 {
  64     // Private data
  65
  66         // Body data
  67
  68             //- Mass
  69             dimensionedScalar mass_;
  70
  71             //- Rotational moment of inertia around centre of mass
  72             //  in body (relative) coordinates - aligned with main axes
  73             dimensionedDiagTensor momentOfInertia_;
  74
  75
  76         // Platform variables
  77
  78             //- Spring equilibrium position for translation
  79             dimensionedVector Xequilibrium_;
  80
  81             //- Linear spring coeffs
  82             dimensionedDiagTensor linSpringCoeffs_;
  83
  84             //- Linear damping coeffs
  85             dimensionedDiagTensor linDampingCoeffs_;
  86
  87             //- Translational relaxation factor
  88             scalar relaxFactorT_;
  89
  90             //- Rotational relaxation factor
  91             scalar relaxFactorR_;
  92
  93             //- Old translational relaxation factor
  94             scalar oldRelaxFactorT_;
  95
  96             //- Old rotational relaxation factor
  97             scalar oldRelaxFactorR_;
  98
  99
 100         // Initial body state variables
 101
 102             //- Displacement relative to spring equilibrium
 103             dimensionedVector Xrel_;
 104
 105             //- Velocity of mass centroid
 106             dimensionedVector U_;
 107
 108             //- Average velocity of mass centroid at previous time-step
 109             dimensionedVector Uaverage_;
 110
 111             //- Finite rotation
 112             finiteRotation rotation_;
 113
 114             //- Rotational velocity about mass centroid
 115             dimensionedVector omega_;
 116
 117
 118         // Average variables that need to be stored
 119
 120             //- Average rotational velocity in relative coordinate system
 121             dimensionedVector omegaAverage_;
 122
 123             //- Average rotational velocity in absolute coordinate system
 124             dimensionedVector omegaAverageAbsolute_;
 125
 126
 127         // External forces
 128
 129             //- Accelerations from previous iterations
 130             //  A_[2] is the old value, A_[1] old old, A_[0] old old old
 131             List<vector> A_;
 132             List<vector> OmegaDot_;
 133
 134             //- Previos iteration non relaxed accelerations
 135             List<vector> An_;
 136             List<vector> OmegaDotn_;
 137
 138             //- Force driving the motion in inertial coord. sys.
 139             dimensionedVector force_;
 140
 141             //- Moment driving the motion in inertial coord. sys.
 142             dimensionedVector moment_;
 143
 144             //- Force driving the motion in relative coord. sys.
 145             dimensionedVector forceRelative_;
 146
 147             //- Moment driving the motion in relative coord. sys.
 148             dimensionedVector momentRelative_;
 149
 150
 151         //- ODE coefficients
 152         scalarField coeffs_;
 153
 154
 155         //- Motion constraints (given as fixed motion components)
 156
 157             //- Fixed surge (x-translation)
 158             Switch fixedSurge_;
 159
 160             //- Fixed sway (y-translation)
 161             Switch fixedSway_;
 162
 163             //- Fixed heave (z-translation)
 164             Switch fixedHeave_;
 165
 166             //- Fixed roll (rotation around x)
 167             Switch fixedRoll_;
 168
 169             //- Fixed pitch (rotation around y)
 170             Switch fixedPitch_;
 171
 172             //- Fixed yaw (rotation around z)
 173             Switch fixedYaw_;
 174
 175             //- Restraints in referent coordinate system
 176             Switch referentMotionConstraints_;
 177
 178             //- Rotation of referent coordinate system
 179             HamiltonRodriguezRot referentRotation_;
 180
 181
 182     // Private Member Functions
 183
 184         //- Disallow default bitwise copy construct
 185         sixDOFqODE(const sixDOFqODE&);
 186
 187         //- Disallow default bitwise assignment
 188         void operator=(const sixDOFqODE&);
 189
 190
 191         //- Set ODE coefficients from position and rotation
 192         void setCoeffs();
 193
 194
 195         // Variables in relative coordinate system (solved for)
 196
 197             //- Return acceleration in relative coordinate system
 198             //  given current values of relative displacement and velocity
 199             dimensionedVector A
 200             (
 201                 const dimensionedVector& xR,
 202                 const dimensionedVector& uR,
 203                 const HamiltonRodriguezRot& rotation
 204             ) const;
 205
 206
 207             //- Return rotational acceleration in relative coordinate system
 208             //  given current values for relative rotational velocity
 209             dimensionedVector OmegaDot
 210             (
 211                 const HamiltonRodriguezRot& rotation,
 212                 const dimensionedVector& omega
 213             ) const;
 214
 215             //- Return the Euler part of moment equation
 216             dimensionedVector E
 217             (
 218                 const dimensionedVector& omega
 219             ) const;
 220
 221             //- Constrain rotation vector in referent or global coordinate
 222             //  system
 223             void constrainRotation(vector& vec) const;
 224
 225             //- Constrain translation vector in referent or global coordinate
 226             //  system
 227             void constrainTranslation(vector& vec) const;
 228
 229             //- Update Aitkens relaxation parameters
 230             void aitkensRelaxation(const scalar min, const scalar max);
 231
 232
 233 public:
 234
 235     // Constructors
 236
 237         //- Construct from dictionary
 238         sixDOFqODE(const IOobject& io);
 239
 240         //- Construct sixDOFqODE, changing name
 241         sixDOFqODE
 242         (
 243             const word& name,
 244             const sixDOFqODE& sd
 245         );
 246
 247
 248     // Destructor
 249
 250         virtual ~sixDOFqODE();
 251
 252
 253     // Member Functions
 254
 255         //- Return mass
 256         inline const dimensionedScalar& mass() const;
 257
 258         //- Return access to mass
 259         inline dimensionedScalar& mass();
 260
 261         //- Return moment of inertia
 262         inline const dimensionedDiagTensor& momentOfInertia() const;
 263
 264         //- Return access to moment of inertia
 265         inline dimensionedDiagTensor& momentOfInertia();
 266
 267         //- Return equilibrium position of origin
 268         inline const dimensionedVector& Xequilibrium() const;
 269
 270         //- Return access to equilibrium position of origin
 271         inline dimensionedVector& Xequilibrium();
 272
 273
 274         // Variables in relative coordinate system (solved for)
 275
 276             //- Return displacement in translated coordinate system
 277             //  relative to spring equilibrium
 278             inline const dimensionedVector& Xrel() const;
 279
 280             //- Return rotational velocity in relative coordinate system
 281             inline const dimensionedVector& omega() const;
 282
 283             //- Return rotational acceleration in relative coordinate system
 284             inline dimensionedVector omegaDot() const;
 285
 286
 287         // Displacement and rotation in the absolute coordinate system
 288
 289             //- Return position of origin in absolute coordinate system
 290             inline dimensionedVector X() const;
 291
 292             //- Return velocity of origin
 293             inline const dimensionedVector& U() const;
 294
 295             //- Return average velocity of origin for the previous time-step
 296             inline const dimensionedVector& Uaverage() const;
 297
 298             //- Return finite rotation
 299             inline const finiteRotation& rotation() const;
 300
 301             //- Return acceleration of origin
 302             inline dimensionedVector A() const;
 303
 304             //- Return rotational vector of body
 305             inline vector rotVector() const;
 306
 307             //- Return rotation angle of body
 308             inline dimensionedScalar rotAngle() const;
 309
 310
 311         // Non-constant access
 312
 313             //- Set position of origin
 314             inline void setXrel(const vector& x);
 315
 316             //- Set velocity of origin
 317             inline void setU(const vector& u);
 318
 319             //- Set rotational angle in relative
 320             //  coordinate system
 321             inline void setRotation(const HamiltonRodriguezRot& rot);
 322
 323             //- Set rotational velocity in relative
 324             //  coordinate system
 325             inline void setOmega(const vector& omega);
 326
 327             //- Set referent coordinate system to apply constraints
 328             inline void setReferentRotation(const HamiltonRodriguezRot& rot);
 329
 330
 331         // Average motion per time-step
 332
 333             //- Return average rotational vector of body
 334             inline vector rotVectorAverage() const;
 335
 336             //- Return average rotational velocity in
 337             //  relative coordinate system
 338             inline const dimensionedVector& omegaAverage() const;
 339
 340             //- Return average rotational velocity in
 341             //  absolute coordinate system
 342             inline const dimensionedVector& omegaAverageAbsolute() const;
 343
 344
 345         // Force and moment
 346
 347             //- Return force in inertial coord. sys.
 348             inline const dimensionedVector& force() const;
 349
 350             //- Return access to force in inertial coord. sys.
 351             inline dimensionedVector& force();
 352
 353             //- Return moment in inertial coord. sys.
 354             inline const dimensionedVector& moment() const;
 355
 356             //- Return access to moment in inertial coord. sys.
 357             inline dimensionedVector& moment();
 358
 359             //- Return force in relative coord. sys.
 360             inline const dimensionedVector& forceRelative() const;
 361
 362             //- Return access to force in relative coord. sys.
 363             inline dimensionedVector& forceRelative();
 364
 365             //- Return moment in relative coord. sys.
 366             inline const dimensionedVector& momentRelative() const;
 367
 368             //- Return access to moment in relative coord. sys.
 369             inline dimensionedVector& momentRelative();
 370
 371             //- Return total force in inertial coord. sys.
 372             inline dimensionedVector forceTotal() const;
 373
 374             //- Return total moment in inertial coord. sys.
 375             inline dimensionedVector momentTotal() const;
 376
 377             //- Relax the force(acceleration) using Aitkens or fixed relaxation
 378             void relaxAcceleration
 379             (
 380                 const scalar minRelFactor,
 381                 const scalar maxRelFactor
 382             );
 383
 384
 385         // Rotations
 386
 387             //- Return rotation tensor to relative coordinate system
 388             inline tensor toRelative() const;
 389
 390             //- Return rotation tensor to absolute coordinate system
 391             inline tensor toAbsolute() const;
 392
 393             //- Return transformation tensor between new and previous rotation
 394             inline const tensor& rotIncrementTensor() const;
 395
 396             //-  Set ODE parameters from another ODE
 397             void setState(const sixDOFqODE&);
 398
 399
 400         // ODE parameters
 401
 402             //- Return number of equations
 403             virtual label nEqns() const
 404             {
 405                 return 13;
 406             }
 407
 408             //- Return access to coefficients
 409             virtual scalarField& coeffs()
 410             {
 411                 return coeffs_;
 412             }
 413
 414             //- Return reference to coefficients
 415             virtual const scalarField& coeffs() const
 416             {
 417                 return coeffs_;
 418             }
 419
 420             //- Return derivatives
 421             virtual void derivatives
 422             (
 423                 const scalar x,
 424                 const scalarField& y,
 425                 scalarField& dydx
 426             ) const;
 427
 428             //- Return Jacobian
 429             virtual void jacobian
 430             (
 431                 const scalar x,
 432                 const scalarField& y,
 433                 scalarField& dfdx,
 434                 scalarSquareMatrix& dfdy
 435             ) const;
 436
 437             //- Update ODE after the solution, advancing by delta
 438             virtual void update(const scalar delta);
 439
 440
 441         //- WriteData member function required by regIOobject
 442         bool writeData(Ostream&) const;
 443
 444
 445     // Ostream operator
 446
 447         friend Ostream& operator<<(Ostream&, const sixDOFqODE&);
 448 };
 449
 450
 451 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 452
 453 } // End namespace Foam
 454
 455 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 456
 457 #include "sixDOFqODEI.H"
 458
 459 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 460
 461 #endif
 462
 463 // ************************************************************************* //