src/foam/coordinateSystems/toroidalCS.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 "toroidalCS.H"
  27 #include "mathematicalConstants.H"
  28 #include "boundBox.H"
  29 #include "addToRunTimeSelectionTable.H"
  30
  31 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  32
  33 namespace Foam
  34 {
  35     defineTypeNameAndDebug(toroidalCS, 0);
  36     addToRunTimeSelectionTable(coordinateSystem, toroidalCS, dictionary);
  37 }
  38
  39 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  40
  41
  42 Foam::toroidalCS::toroidalCS
  43 (
  44     const word& name,
  45     const point& origin,
  46     const coordinateRotation& cr,
  47     const scalar radius,
  48     const bool inDegrees
  49 )
  50 :
  51     coordinateSystem(name, origin, cr),
  52     radius_(radius),
  53     inDegrees_(inDegrees)
  54 {}
  55
  56
  57 Foam::toroidalCS::toroidalCS
  58 (
  59     const word& name,
  60     const dictionary& dict
  61 )
  62 :
  63     coordinateSystem(name, dict),
  64     radius_(readScalar(dict.lookup("radius"))),
  65     inDegrees_(dict.lookupOrDefault<Switch>("degrees", true))
  66 {}
  67
  68
  69 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  70
  71 Foam::coordinateSystem::spanInfo Foam::toroidalCS::spanLimited() const
  72 {
  73     spanInfo b(Pair<bool>(true, true));
  74
  75     // Upper bound or r is unlimited
  76     b[0] = Pair<bool>(true, false);
  77
  78     return b;
  79 }
  80
  81
  82 Foam::boundBox Foam::toroidalCS::spanBounds() const
  83 {
  84     return boundBox
  85     (
  86         vector
  87         (
  88             0,
  89             ( inDegrees_ ? -180.0 : -mathematicalConstant::pi ),
  90             ( inDegrees_ ? -180.0 : -mathematicalConstant::pi )
  91         ),
  92         vector
  93         (
  94             GREAT,
  95             ( inDegrees_ ? 180.0 : mathematicalConstant::pi ),
  96             ( inDegrees_ ? 180.0 : mathematicalConstant::pi )
  97         )
  98     );
  99 }
 100
 101
 102 bool Foam::toroidalCS::inDegrees() const
 103 {
 104     return inDegrees_;
 105 }
 106
 107
 108 Foam::Switch& Foam::toroidalCS::inDegrees()
 109 {
 110     return inDegrees_;
 111 }
 112
 113
 114 Foam::vector Foam::toroidalCS::localToGlobal
 115 (
 116     const vector& local,
 117     bool translate
 118 ) const
 119 {
 120     // Notation: r = local.x()
 121     scalar theta = local.y()*mathematicalConstant::pi/180.0;
 122     scalar phi = local.z()*mathematicalConstant::pi/180.0;
 123
 124     scalar rprime = radius_ + local.x()*sin(phi);
 125
 126     if ((local.x()*sin(phi)) > (radius_))
 127     {
 128         FatalErrorIn("toroidalCS::toGlobal(vector) const")
 129             << "Badly defined toroidal coordinates"
 130             << abort(FatalError);
 131     }
 132
 133     return coordinateSystem::localToGlobal
 134     (
 135         vector(rprime*cos(theta), rprime*sin(theta), local.x()*cos(phi)),
 136         translate
 137     );
 138 }
 139
 140
 141 Foam::tmp<Foam::vectorField> Foam::toroidalCS::localToGlobal
 142 (
 143     const vectorField& local,
 144     bool translate
 145 ) const
 146 {
 147     const scalarField r = local.component(vector::X);
 148
 149     const scalarField theta =
 150         local.component(vector::Y)*mathematicalConstant::pi/180.0;
 151
 152     const scalarField phi =
 153         local.component(vector::Z)*mathematicalConstant::pi/180.0;
 154
 155     const scalarField rprime = radius_ + r*sin(phi);
 156
 157     vectorField lc(local.size());
 158     lc.replace(vector::X, rprime*cos(theta));
 159     lc.replace(vector::Y, rprime*sin(theta));
 160     lc.replace(vector::Z, r*cos(phi));
 161
 162     return coordinateSystem::localToGlobal(lc, translate);
 163 }
 164
 165
 166 Foam::vector Foam::toroidalCS::globalToLocal
 167 (
 168     const vector& global,
 169     bool translate
 170 ) const
 171 {
 172     notImplemented
 173     (
 174         "toroidalCS::globalToLocal(const vector&, bool) const"
 175     );
 176
 177     return vector::zero;
 178 }
 179
 180
 181 Foam::tmp<Foam::vectorField> Foam::toroidalCS::globalToLocal
 182 (
 183     const vectorField& global,
 184     bool translate
 185 ) const
 186 {
 187     notImplemented
 188     (
 189         "toroidalCS::globalToLocal(const vectorField&, bool) const"
 190     );
 191
 192     return tmp<vectorField>(vectorField::null());
 193 }
 194
 195
 196 void Foam::toroidalCS::write(Ostream& os) const
 197 {
 198     coordinateSystem::write(os);
 199     os << "radius: " << radius() << endl;
 200 }
 201
 202
 203 void Foam::toroidalCS::writeDict(Ostream& os, bool subDict) const
 204 {
 205     if (subDict)
 206     {
 207         os  << indent << nl
 208             << indent << token::BEGIN_BLOCK << incrIndent << nl;
 209     }
 210
 211     coordinateSystem::writeDict(os, false);
 212     os.writeKeyword("radius") << radius() << token::END_STATEMENT << nl;
 213
 214     if (subDict)
 215     {
 216         os << decrIndent << indent << token::END_BLOCK << endl;
 217     }
 218 }
 219
 220
 221 // ************************************************************************* //