src/meshTools/coordinateSystems/sphericalCS.C

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