src/foam/coordinateSystems/parabolicCylindricalCS.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 "parabolicCylindricalCS.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(parabolicCylindricalCS, 0);
  36     addToRunTimeSelectionTable
  37     (
  38         coordinateSystem,
  39         parabolicCylindricalCS,
  40         dictionary
  41     );
  42 }
  43
  44
  45 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  46
  47 Foam::parabolicCylindricalCS::parabolicCylindricalCS(const bool inDegrees)
  48 :
  49     coordinateSystem(),
  50     inDegrees_(inDegrees)
  51 {}
  52
  53
  54 Foam::parabolicCylindricalCS::parabolicCylindricalCS
  55 (
  56     const word& name,
  57     const point& origin,
  58     const coordinateRotation& cr,
  59     const bool inDegrees
  60 )
  61 :
  62     coordinateSystem(name, origin, cr),
  63     inDegrees_(inDegrees)
  64 {}
  65
  66
  67 Foam::parabolicCylindricalCS::parabolicCylindricalCS
  68 (
  69     const word& name,
  70     const dictionary& dict
  71 )
  72 :
  73     coordinateSystem(name, dict),
  74     inDegrees_(dict.lookupOrDefault<Switch>("degrees", true))
  75 {}
  76
  77
  78 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  79
  80 Foam::coordinateSystem::spanInfo
  81 Foam::parabolicCylindricalCS::spanLimited() const
  82 {
  83     spanInfo b(Pair<bool>(true, true));
  84
  85     // Upper bound or r is unlimited
  86     b[0] = Pair<bool>(true, false);
  87
  88     // z is unlimited
  89     b[2] = Pair<bool>(false, false);
  90
  91     return b;
  92 }
  93
  94
  95 Foam::boundBox Foam::parabolicCylindricalCS::spanBounds() const
  96 {
  97     return boundBox
  98     (
  99         vector
 100         (
 101             0,
 102             ( inDegrees_ ? -180.0 : -mathematicalConstant::pi ),
 103             -GREAT
 104         ),
 105         vector
 106         (
 107             GREAT,
 108             ( inDegrees_ ? 180.0 : mathematicalConstant::pi ),
 109             GREAT
 110         )
 111     );
 112 }
 113
 114
 115 bool Foam::parabolicCylindricalCS::inDegrees() const
 116 {
 117     return inDegrees_;
 118 }
 119
 120
 121 Foam::Switch& Foam::parabolicCylindricalCS::inDegrees()
 122 {
 123     return inDegrees_;
 124 }
 125
 126
 127 Foam::vector Foam::parabolicCylindricalCS::localToGlobal
 128 (
 129     const vector& local,
 130     bool translate
 131 ) const
 132 {
 133     // Notation: u = local.x() v = local.y() z = local.z();
 134     if (local.y() < 0.0)
 135     {
 136         FatalErrorIn
 137         (
 138             "parabolicCylindricalCS::localToGlobal(const vector&, bool) const"
 139         )
 140             << "parabolic cylindrical coordinates v < 0"
 141             << abort(FatalError);
 142     }
 143
 144     return coordinateSystem::localToGlobal
 145     (
 146         vector
 147         (
 148             0.5*(sqr(local.x()) - sqr(local.y())),
 149             local.x()*local.y(),
 150             local.z()
 151         ),
 152         translate
 153     );
 154 }
 155
 156
 157 Foam::tmp<Foam::vectorField> Foam::parabolicCylindricalCS::localToGlobal
 158 (
 159     const vectorField& local,
 160     bool translate
 161 ) const
 162 {
 163     if (min(local.component(vector::Y)) < 0.0)
 164     {
 165         FatalErrorIn
 166         (
 167             "parabolicCylindricalCS::localToGlobal"
 168             "(const vectorField&, bool) const"
 169         )   << "parabolic cylindrical coordinates v < 0"
 170             << abort(FatalError);
 171     }
 172
 173     vectorField lc(local.size());
 174     lc.replace
 175     (
 176         vector::X,
 177         0.5*
 178         (
 179             sqr(local.component(vector::X))
 180           - sqr(local.component(vector::Y))
 181         )
 182     );
 183
 184     lc.replace
 185     (
 186         vector::Y,
 187         local.component(vector::X) * local.component(vector::Y)
 188     );
 189
 190     lc.replace
 191     (
 192         vector::Z,
 193         local.component(vector::Z)
 194     );
 195
 196     return coordinateSystem::localToGlobal(lc, translate);
 197 }
 198
 199
 200 Foam::vector Foam::parabolicCylindricalCS::globalToLocal
 201 (
 202     const vector& global,
 203     bool translate
 204 ) const
 205 {
 206     notImplemented
 207     (
 208         "parabolicCylindricalCS::globalToLocal(const vector&, bool) const"
 209     );
 210
 211     return vector::zero;
 212 }
 213
 214 Foam::tmp<Foam::vectorField> Foam::parabolicCylindricalCS::globalToLocal
 215 (
 216     const vectorField& global,
 217     bool translate
 218 ) const
 219 {
 220     notImplemented
 221     (
 222         "parabolicCylindricalCS::globalToLocal(const vectorField&, bool) const"
 223     );
 224
 225     return tmp<vectorField>(vectorField::null());
 226 }
 227
 228
 229 void Foam::parabolicCylindricalCS::write(Ostream& os) const
 230 {
 231     coordinateSystem::write(os);
 232     os << "inDegrees: " << inDegrees() << endl;
 233 }
 234
 235
 236 void Foam::parabolicCylindricalCS::writeDict(Ostream& os, bool subDict) const
 237 {
 238     if (subDict)
 239     {
 240         os  << indent << nl
 241             << indent << token::BEGIN_BLOCK << incrIndent << nl;
 242     }
 243
 244     coordinateSystem::writeDict(os, false);
 245     os.writeKeyword("inDegrees") << inDegrees_ << token::END_STATEMENT << nl;
 246
 247     if (subDict)
 248     {
 249         os << decrIndent << indent << token::END_BLOCK << endl;
 250     }
 251 }
 252
 253
 254 // ************************************************************************* //