src/mesh/cfMesh/utilities/anisotropicMeshing/coordinateModification/planeScaling.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | cfMesh: A library for mesh generation
   4    \\    /   O peration     |
   5     \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
   6      \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of cfMesh.
  10
  11     cfMesh 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     cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "planeScaling.H"
  27 #include "addToRunTimeSelectionTable.H"
  28 #include "boundBox.H"
  29 #include "plane.H"
  30
  31 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  32
  33 namespace Foam
  34 {
  35
  36 defineTypeNameAndDebug(planeScaling, 0);
  37 addToRunTimeSelectionTable
  38 (
  39     coordinateModification,
  40     planeScaling,
  41     dictionary
  42 );
  43
  44 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  45
  46 planeScaling::planeScaling()
  47 :
  48     coordinateModification(),
  49     origin_(vector::zero),
  50     normal_(1, 1, 1),
  51     scalingDistance_(0.0),
  52     scalingFactor_(1.0)
  53 {}
  54
  55 planeScaling::planeScaling
  56 (
  57     const word& name,
  58     const point& origin,
  59     const vector& normal,
  60     const scalar scalingDistance,
  61     const scalar scalingFactor
  62 )
  63 :
  64     coordinateModification(),
  65     origin_(origin),
  66     normal_(normal/mag(normal)),
  67     scalingDistance_(scalingDistance),
  68     scalingFactor_(scalingFactor)
  69 {
  70     if( scalingFactor_ < SMALL )
  71     {
  72         Warning << "Scaling factor for plane " << name << " is less than 0.0 "
  73                 << endl;
  74
  75         scalingFactor_= 1.0;
  76     }
  77
  78     setName(name);
  79 }
  80
  81 planeScaling::planeScaling
  82 (
  83     const word& name,
  84     const dictionary& dict
  85 )
  86 :
  87     coordinateModification(name, dict)
  88 {
  89     this->operator=(dict);
  90 }
  91
  92 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  93
  94 point planeScaling::origin() const
  95 {
  96     return origin_;
  97 }
  98
  99 void planeScaling::translateAndModifyObject(const vector& disp)
 100 {
 101     origin_ += disp;
 102
 103     scalingDistance_ /= scalingFactor_;
 104 }
 105
 106 vector planeScaling::displacement(const point& p) const
 107 {
 108     const scalar dist = (p - origin_) & normal_;
 109
 110     const vector translationVec =
 111         normal_ * scalingDistance_ * ((1.0/scalingFactor_) - 1.0);
 112
 113     const scalar t = dist / scalingDistance_;
 114
 115     const scalar tBnd = Foam::max(0.0, Foam::min(1.0, t));
 116
 117     return tBnd * translationVec;
 118 }
 119
 120 vector planeScaling::backwardDisplacement(const point& p) const
 121 {
 122     const scalar dist = (p - origin_) & normal_;
 123
 124     const vector translationVec =
 125         normal_ * scalingDistance_ * (scalingFactor_ - 1.0);
 126
 127     const scalar t = dist / scalingDistance_;
 128
 129     const scalar tBnd = Foam::max(0.0, Foam::min(1.0, t));
 130
 131     return tBnd * translationVec;
 132 }
 133
 134 bool planeScaling::combiningPossible() const
 135 {
 136     return true;
 137 }
 138
 139 void planeScaling::boundingPlanes(PtrList<plane>& pl) const
 140 {
 141     if( Foam::mag(scalingFactor_ - 1.0) > VSMALL )
 142     {
 143         pl.setSize(2);
 144
 145         pl.set(0, new plane(origin_, normal_));
 146         pl.set(1, new plane(origin_ + scalingDistance_ * normal_, normal_));
 147     }
 148     else
 149     {
 150         pl.clear();
 151     }
 152 }
 153
 154 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 155
 156 dictionary planeScaling::dict(bool ignoreType) const
 157 {
 158     dictionary dict;
 159
 160     dict.add("type", type());
 161
 162     dict.add("origin", origin_);
 163     dict.add("normal", normal_);
 164     dict.add("scalingDistance", scalingDistance_);
 165     dict.add("scalingFactor", scalingFactor_);
 166
 167     return dict;
 168 }
 169
 170 void planeScaling::write(Ostream& os) const
 171 {
 172     os  << " type:   " << type()
 173         << " origin: " << origin_
 174         << " normal: " << normal_
 175         << " scalingDistance: " << scalingDistance_
 176         << " scalingFactor: " << scalingFactor_;
 177 }
 178
 179 void planeScaling::writeDict(Ostream& os, bool subDict) const
 180 {
 181     if( subDict )
 182     {
 183         os << indent << token::BEGIN_BLOCK << incrIndent << nl;
 184     }
 185
 186     // only write type for derived types
 187     if( type() != typeName_() )
 188     {
 189         os.writeKeyword("type") << type() << token::END_STATEMENT << nl;
 190     }
 191
 192     os.writeKeyword("origin") << origin_ << token::END_STATEMENT << nl;
 193     os.writeKeyword("normal") << normal_ << token::END_STATEMENT << nl;
 194     os.writeKeyword("scalingDistance") << scalingDistance_
 195                                            << token::END_STATEMENT << nl;
 196     os.writeKeyword("scalingFactor") << scalingFactor_
 197                                     << token::END_STATEMENT << nl;
 198
 199     if( subDict )
 200     {
 201         os << decrIndent << indent << token::END_BLOCK << endl;
 202     }
 203 }
 204
 205 void planeScaling::operator=(const dictionary& d)
 206 {
 207     // allow as embedded sub-dictionary "coordinateSystem"
 208     const dictionary& dict =
 209     (
 210         d.found(typeName_())
 211       ? d.subDict(typeName_())
 212       : d
 213     );
 214
 215     // unspecified centre is (0 0 0)
 216     if( dict.found("origin") )
 217     {
 218         dict.lookup("origin") >> origin_;
 219     }
 220     else
 221     {
 222         FatalErrorIn
 223         (
 224             "void planeScaling::operator=(const dictionary& d)"
 225         ) << "Entry origin is not specified!" << exit(FatalError);
 226
 227         origin_ = vector::zero;
 228     }
 229
 230     // specify normal
 231     if( dict.found("normal") )
 232     {
 233         dict.lookup("normal") >> normal_;
 234     }
 235     else
 236     {
 237         FatalErrorIn
 238         (
 239             "void planeScaling::operator=(const dictionary& d)"
 240         ) << "Entry lengthX is not specified!" << exit(FatalError);
 241
 242         normal_ = vector(1, 1, 1);
 243     }
 244
 245     // specify translation distance
 246     if( dict.found("scalingDistance") )
 247     {
 248         scalingDistance_ = readScalar(dict.lookup("scalingDistance"));
 249     }
 250     else
 251     {
 252         FatalErrorIn
 253         (
 254             "void planeScaling::operator=(const dictionary& d)"
 255         ) << "Entry scalingDistance is not specified!" << exit(FatalError);
 256
 257         scalingDistance_ = 0.0;
 258     }
 259
 260     // specify scaling factor
 261     if( dict.found("scalingFactor") )
 262     {
 263         scalingFactor_ = readScalar(dict.lookup("scalingFactor"));
 264     }
 265     else
 266     {
 267         WarningIn
 268         (
 269             "void planeScaling::operator=(const dictionary& d)"
 270         ) << "Entry scalingFactor is not specified!" << endl;
 271
 272         scalingFactor_ = 1.0;
 273     }
 274 }
 275
 276 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 277
 278 Ostream& planeScaling::operator<<(Ostream& os) const
 279 {
 280     os << "name " << name() << nl;
 281     write(os);
 282     return os;
 283 }
 284
 285 Ostream& operator<<(Ostream& os, const planeScaling& pt)
 286 {
 287     return pt.operator<<(os);
 288 }
 289
 290 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 291
 292 } // End namespace Foam
 293
 294 // ************************************************************************* //