src/meshTools/coordinateSystems/cylindricalCS.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 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 \*---------------------------------------------------------------------------*/
  26
  27 #include "cylindricalCS.H"
  28
  29 #include "one.H"
  30 #include "Switch.H"
  31 #include "mathematicalConstants.H"
  32 #include "addToRunTimeSelectionTable.H"
  33
  34 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  35
  36 namespace Foam
  37 {
  38     defineTypeNameAndDebug(cylindricalCS, 0);
  39     addToRunTimeSelectionTable(coordinateSystem, cylindricalCS, dictionary);
  40     addToRunTimeSelectionTable(coordinateSystem, cylindricalCS, origRotation);
  41 }
  42
  43
  44 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  45
  46 Foam::cylindricalCS::cylindricalCS(const bool inDegrees)
  47 :
  48     coordinateSystem(),
  49     inDegrees_(inDegrees)
  50 {}
  51
  52
  53 Foam::cylindricalCS::cylindricalCS
  54 (
  55     const coordinateSystem& cs,
  56     const bool inDegrees
  57 )
  58 :
  59     coordinateSystem(cs),
  60     inDegrees_(inDegrees)
  61 {}
  62
  63
  64 Foam::cylindricalCS::cylindricalCS
  65 (
  66     const word& name,
  67     const coordinateSystem& cs,
  68     const bool inDegrees
  69 )
  70 :
  71     coordinateSystem(name, cs),
  72     inDegrees_(inDegrees)
  73 {}
  74
  75
  76 Foam::cylindricalCS::cylindricalCS
  77 (
  78     const word& name,
  79     const point& origin,
  80     const coordinateRotation& cr,
  81     const bool inDegrees
  82 )
  83 :
  84     coordinateSystem(name, origin, cr),
  85     inDegrees_(inDegrees)
  86 {}
  87
  88
  89 Foam::cylindricalCS::cylindricalCS
  90 (
  91     const word& name,
  92     const point& origin,
  93     const vector& axis,
  94     const vector& dirn,
  95     const bool inDegrees
  96 )
  97 :
  98     coordinateSystem(name, origin, axis, dirn),
  99     inDegrees_(inDegrees)
 100 {}
 101
 102
 103 Foam::cylindricalCS::cylindricalCS
 104 (
 105     const word& name,
 106     const dictionary& dict
 107 )
 108 :
 109     coordinateSystem(name, dict),
 110     inDegrees_(dict.lookupOrDefault<Switch>("degrees", true))
 111 {}
 112
 113
 114 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 115
 116 bool Foam::cylindricalCS::inDegrees() const
 117 {
 118     return inDegrees_;
 119 }
 120
 121
 122 bool& Foam::cylindricalCS::inDegrees()
 123 {
 124     return inDegrees_;
 125 }
 126
 127
 128 Foam::vector Foam::cylindricalCS::localToGlobal
 129 (
 130     const vector& local,
 131     bool translate
 132 ) const
 133 {
 134     scalar theta
 135     (
 136         local.y() * ( inDegrees_ ? mathematicalConstant::pi/180.0 : 1.0 )
 137     );
 138
 139     return coordinateSystem::localToGlobal
 140     (
 141         vector(local.x()*cos(theta), local.x()*sin(theta), local.z()),
 142         translate
 143     );
 144 }
 145
 146
 147 Foam::tmp<Foam::vectorField> Foam::cylindricalCS::localToGlobal
 148 (
 149     const vectorField& local,
 150     bool translate
 151 ) const
 152 {
 153     scalarField theta =
 154     (
 155         local.component(vector::Y)
 156       * ( inDegrees_ ? mathematicalConstant::pi/180.0 : 1.0 )
 157     );
 158
 159
 160     vectorField lc(local.size());
 161     lc.replace(vector::X, local.component(vector::X)*cos(theta));
 162     lc.replace(vector::Y, local.component(vector::X)*sin(theta));
 163     lc.replace(vector::Z, local.component(vector::Z));
 164
 165     return coordinateSystem::localToGlobal(lc, translate);
 166 }
 167
 168
 169 Foam::vector Foam::cylindricalCS::globalToLocal
 170 (
 171     const vector& global,
 172     bool translate
 173 ) const
 174 {
 175     const vector lc = coordinateSystem::globalToLocal(global, translate);
 176
 177     return vector
 178     (
 179         sqrt(sqr(lc.x()) + sqr(lc.y())),
 180         atan2
 181         (
 182             lc.y(),
 183             lc.x()
 184         ) * ( inDegrees_ ? 180.0/mathematicalConstant::pi : 1.0 ),
 185         lc.z()
 186     );
 187 }
 188
 189
 190 Foam::tmp<Foam::vectorField> Foam::cylindricalCS::globalToLocal
 191 (
 192     const vectorField& global,
 193     bool translate
 194 ) const
 195 {
 196     const vectorField lc =
 197         coordinateSystem::globalToLocal(global, translate);
 198
 199     tmp<vectorField> tresult(new vectorField(lc.size()));
 200     vectorField& result = tresult();
 201
 202     result.replace
 203     (
 204         vector::X,
 205         sqrt(sqr(lc.component(vector::X)) + sqr(lc.component(vector::Y)))
 206     );
 207
 208     result.replace
 209     (
 210         vector::Y,
 211         atan2
 212         (
 213             lc.component(vector::Y),
 214             lc.component(vector::X)
 215         ) * ( inDegrees_ ? 180.0/mathematicalConstant::pi : 1.0 )
 216     );
 217
 218     result.replace(vector::Z, lc.component(vector::Z));
 219
 220     return tresult;
 221 }
 222
 223
 224 // ************************************************************************* //