src/foam/coordinateSystems/cylindricalCS.C

   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 \*---------------------------------------------------------------------------*/
  25
  26 #include "cylindricalCS.H"
  27
  28 #include "mathematicalConstants.H"
  29 #include "boundBox.H"
  30 #include "addToRunTimeSelectionTable.H"
  31
  32 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  33
  34 namespace Foam
  35 {
  36     defineTypeNameAndDebug(cylindricalCS, 0);
  37     addToRunTimeSelectionTable(coordinateSystem, cylindricalCS, dictionary);
  38     addToRunTimeSelectionTable(coordinateSystem, cylindricalCS, origRotation);
  39 }
  40
  41
  42 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  43
  44 Foam::cylindricalCS::cylindricalCS(const bool inDegrees)
  45 :
  46     coordinateSystem(),
  47     inDegrees_(inDegrees)
  48 {}
  49
  50
  51 Foam::cylindricalCS::cylindricalCS
  52 (
  53     const coordinateSystem& cs,
  54     const bool inDegrees
  55 )
  56 :
  57     coordinateSystem(cs),
  58     inDegrees_(inDegrees)
  59 {}
  60
  61
  62 Foam::cylindricalCS::cylindricalCS
  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::cylindricalCS::cylindricalCS
  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::cylindricalCS::cylindricalCS
  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::cylindricalCS::cylindricalCS
 102 (
 103     const word& name,
 104     const dictionary& dict
 105 )
 106 :
 107     coordinateSystem(name, dict),
 108     inDegrees_(dict.lookupOrDefault<Switch>("degrees", true))
 109 {}
 110
 111
 112 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 113
 114 Foam::coordinateSystem::spanInfo Foam::cylindricalCS::spanLimited() const
 115 {
 116     spanInfo b(Pair<bool>(true, true));
 117
 118     // Upper bound or r is unlimited
 119     b[0] = Pair<bool>(true, false);
 120
 121     // z is unlimited
 122     b[2] = Pair<bool>(false, false);
 123
 124     return b;
 125 }
 126
 127
 128 Foam::boundBox Foam::cylindricalCS::spanBounds() const
 129 {
 130     return boundBox
 131     (
 132         vector
 133         (
 134             0,
 135             ( inDegrees_ ? -180.0 : -mathematicalConstant::pi ),
 136             -GREAT
 137         ),
 138         vector
 139         (
 140             GREAT,
 141             ( inDegrees_ ? 180.0 : mathematicalConstant::pi ),
 142             GREAT
 143         )
 144     );
 145 }
 146
 147
 148 bool Foam::cylindricalCS::inDegrees() const
 149 {
 150     return inDegrees_;
 151 }
 152
 153
 154 Foam::Switch& Foam::cylindricalCS::inDegrees()
 155 {
 156     return inDegrees_;
 157 }
 158
 159
 160 Foam::vector Foam::cylindricalCS::localToGlobal
 161 (
 162     const vector& local,
 163     bool translate
 164 ) const
 165 {
 166     scalar theta
 167     (
 168         local.y() * ( inDegrees_ ? mathematicalConstant::pi/180.0 : 1.0 )
 169     );
 170
 171     return coordinateSystem::localToGlobal
 172     (
 173         vector(local.x()*cos(theta), local.x()*sin(theta), local.z()),
 174         translate
 175     );
 176 }
 177
 178
 179 Foam::tmp<Foam::vectorField> Foam::cylindricalCS::localToGlobal
 180 (
 181     const vectorField& local,
 182     bool translate
 183 ) const
 184 {
 185     scalarField theta =
 186     (
 187         local.component(vector::Y)
 188       * ( inDegrees_ ? mathematicalConstant::pi/180.0 : 1.0 )
 189     );
 190
 191
 192     vectorField lc(local.size());
 193     lc.replace(vector::X, local.component(vector::X)*cos(theta));
 194     lc.replace(vector::Y, local.component(vector::X)*sin(theta));
 195     lc.replace(vector::Z, local.component(vector::Z));
 196
 197     return coordinateSystem::localToGlobal(lc, translate);
 198 }
 199
 200
 201 Foam::vector Foam::cylindricalCS::globalToLocal
 202 (
 203     const vector& global,
 204     bool translate
 205 ) const
 206 {
 207     const vector lc = coordinateSystem::globalToLocal(global, translate);
 208
 209     return vector
 210     (
 211         sqrt(sqr(lc.x()) + sqr(lc.y())),
 212         atan2
 213         (
 214             lc.y(),
 215             lc.x()
 216         ) * ( inDegrees_ ? 180.0/mathematicalConstant::pi : 1.0 ),
 217         lc.z()
 218     );
 219 }
 220
 221
 222 Foam::tmp<Foam::vectorField> Foam::cylindricalCS::globalToLocal
 223 (
 224     const vectorField& global,
 225     bool translate
 226 ) const
 227 {
 228     const vectorField lc =
 229         coordinateSystem::globalToLocal(global, translate);
 230
 231     tmp<vectorField> tresult(new vectorField(lc.size()));
 232     vectorField& result = tresult();
 233
 234     result.replace
 235     (
 236         vector::X,
 237         sqrt(sqr(lc.component(vector::X)) + sqr(lc.component(vector::Y)))
 238     );
 239
 240     result.replace
 241     (
 242         vector::Y,
 243         atan2
 244         (
 245             lc.component(vector::Y),
 246             lc.component(vector::X)
 247         ) * ( inDegrees_ ? 180.0/mathematicalConstant::pi : 1.0 )
 248     );
 249
 250     result.replace(vector::Z, lc.component(vector::Z));
 251
 252     return tresult;
 253 }
 254
 255
 256 void Foam::cylindricalCS::write(Ostream& os) const
 257 {
 258     coordinateSystem::write(os);
 259     os << "inDegrees: " << inDegrees() << endl;
 260 }
 261
 262
 263 void Foam::cylindricalCS::writeDict(Ostream& os, bool subDict) const
 264 {
 265     if (subDict)
 266     {
 267         os  << indent << nl
 268             << indent << token::BEGIN_BLOCK << incrIndent << nl;
 269     }
 270
 271     coordinateSystem::writeDict(os, false);
 272     os.writeKeyword("inDegrees") << inDegrees_ << token::END_STATEMENT << nl;
 273
 274     if (subDict)
 275     {
 276         os << decrIndent << indent << token::END_BLOCK << endl;
 277     }
 278 }
 279
 280
 281 // ************************************************************************* //