src/meshLibrary/utilities/octrees/meshOctree/refinementControls/objectRefinement/lineRefinement.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 "lineRefinement.H"
  27 #include "addToRunTimeSelectionTable.H"
  28 #include "boundBox.H"
  29
  30 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  31
  32 namespace Foam
  33 {
  34
  35 defineTypeNameAndDebug(lineRefinement, 0);
  36 addToRunTimeSelectionTable(objectRefinement, lineRefinement, dictionary);
  37
  38 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  39
  40 lineRefinement::lineRefinement()
  41 :
  42     objectRefinement(),
  43     p0_(),
  44     p1_()
  45 {}
  46
  47 lineRefinement::lineRefinement
  48 (
  49     const word& name,
  50     const scalar cellSize,
  51     const point& p0,
  52     const point& p1
  53 )
  54 :
  55     objectRefinement(),
  56     p0_(p0),
  57     p1_(p1)
  58 {
  59     setName(name);
  60     setCellSize(cellSize);
  61 }
  62
  63 lineRefinement::lineRefinement
  64 (
  65     const word& name,
  66     const dictionary& dict
  67 )
  68 :
  69     objectRefinement(name, dict)
  70 {
  71     this->operator=(dict);
  72 }
  73
  74 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  75
  76 bool lineRefinement::intersectsObject(const boundBox& bb) const
  77 {
  78     //- check if the cube contains start point or end point
  79     const scalar l = bb.max().x() - bb.min().x();
  80
  81     const point min = bb.min() - l * vector(SMALL, SMALL, SMALL);
  82     const point max = bb.max() + l * vector(SMALL, SMALL, SMALL);
  83
  84     //- check for intersections of line with the cube faces
  85     const vector v(p1_ - p0_);
  86     if( mag(v.x()) > SMALL )
  87     {
  88         if(
  89             ((p0_.x() < min.x()) && (p1_.x() < min.x())) ||
  90             ((p0_.x() > max.x()) && (p1_.x() > max.x()))
  91         )
  92             return false;
  93
  94         {
  95             //- x-min face
  96             const vector n(-1, 0, 0);
  97             const scalar t = (n & (min - p0_)) / (n & v);
  98             const point i = p0_ + t * v;
  99             if(
 100                 (t > -SMALL) && (t < (1.0+SMALL))
 101             )
 102                 if(
 103                     (i.y() > min.y()) && (i.y() < max.y()) &&
 104                     (i.z() > min.z()) && (i.z() < max.z())
 105                 )
 106                     return true;
 107         }
 108         {
 109             //- x-max face
 110             const vector n(1, 0, 0);
 111             const scalar t = (n & (max - p0_)) / (n & v);
 112             const point i = p0_ + t * v;
 113             if(
 114                 (t > -SMALL) && (t < (1.0+SMALL))
 115             )
 116                 if(
 117                     (i.y() > min.y()) && (i.y() < max.y()) &&
 118                     (i.z() > min.z()) && (i.z() < max.z())
 119                 )
 120                     return true;
 121         }
 122     }
 123
 124     if( mag(v.y()) > SMALL)
 125     {
 126         if(
 127             ((p0_.y() < min.y()) && (p1_.y() < min.y())) ||
 128             ((p0_.y() > max.y()) && (p1_.y() > max.y()))
 129         )
 130             return false;
 131
 132         {
 133             //- y-min face
 134             const vector n(0, -1, 0);
 135             const scalar t = (n & (min - p0_)) / (n & v);
 136             const point i = p0_ + t * v;
 137             if(
 138                 (t > -SMALL) && (t < (1.0+SMALL))
 139             )
 140                 if(
 141                     (i.x() > min.x()) && (i.x() < max.x()) &&
 142                     (i.z() > min.z()) && (i.z() < max.z())
 143                 )
 144                     return true;
 145         }
 146         {
 147             //- y-max face
 148             const vector n(0, 1, 0);
 149             const scalar t = (n & (max - p0_)) / (n & v);
 150             const point i = p0_ + t * v;
 151             if(
 152                 (t > -SMALL) && (t < (1.0+SMALL))
 153             )
 154                 if(
 155                     (i.x() > min.x()) && (i.x() < max.x()) &&
 156                     (i.z() > min.z()) && (i.z() < max.z())
 157                 )
 158                     return true;
 159         }
 160     }
 161     if( mag(v.z()) > SMALL )
 162     {
 163         if(
 164             ((p0_.z() < min.z()) && (p1_.z() < min.z())) ||
 165             ((p0_.z() > max.z()) && (p1_.z() > max.z()))
 166         )
 167             return false;
 168
 169         {
 170             //- z-min face
 171             const vector n(0, 0, -1);
 172             const scalar t = (n & (min - p0_)) / (n & v);
 173             const point i = p0_ + t * v;
 174             if(
 175                 (t > -SMALL) && (t < (1.0+SMALL)) &&
 176                 (i.x() > min.x()) && (i.x() < max.x()) &&
 177                 (i.y() > min.y()) && (i.y() < max.y())
 178             )
 179                 return true;
 180         }
 181         {
 182             //- z-min face
 183             const vector n(0, 0, 1);
 184             const scalar t = (n & (max - p0_)) / (n & v);
 185             const point i = p0_ + t * v;
 186             if(
 187                 (t > -SMALL) && (t < (1.0+SMALL)) &&
 188                 (i.x() > min.x()) && (i.x() < max.x()) &&
 189                 (i.y() > min.y()) && (i.y() < max.y())
 190             )
 191                 return true;
 192         }
 193     }
 194
 195     if(
 196         (p0_.x() > min.x()) && (p0_.x() < max.x()) &&
 197         (p0_.y() > min.y()) && (p0_.y() < max.y()) &&
 198         (p0_.z() > min.z()) && (p0_.z() < max.z())
 199     )
 200         return true;
 201
 202     return false;
 203 }
 204
 205 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 206
 207 dictionary lineRefinement::dict(bool ignoreType) const
 208 {
 209     dictionary dict;
 210
 211     dict.add("cellSize", cellSize());
 212     dict.add("type", type());
 213
 214     dict.add("p0", p0_);
 215     dict.add("p1", p1_);
 216
 217     return dict;
 218 }
 219
 220 void lineRefinement::write(Ostream& os) const
 221 {
 222     os  << " type:   " << type()
 223         << " p0: " << p0_
 224         << " p1: " << p1_;
 225 }
 226
 227 void lineRefinement::writeDict(Ostream& os, bool subDict) const
 228 {
 229     if( subDict )
 230     {
 231         os << indent << token::BEGIN_BLOCK << incrIndent << nl;
 232     }
 233
 234     os.writeKeyword("cellSize") << cellSize() << token::END_STATEMENT << nl;
 235
 236     // only write type for derived types
 237     if( type() != typeName_() )
 238     {
 239         os.writeKeyword("type") << type() << token::END_STATEMENT << nl;
 240     }
 241
 242     os.writeKeyword("p0") << p0_ << token::END_STATEMENT << nl;
 243     os.writeKeyword("p1") << p1_ << token::END_STATEMENT << nl;
 244
 245     if( subDict )
 246     {
 247         os << decrIndent << indent << token::END_BLOCK << endl;
 248     }
 249 }
 250
 251 void lineRefinement::operator=(const dictionary& d)
 252 {
 253     // allow as embedded sub-dictionary "coordinateSystem"
 254     const dictionary& dict =
 255     (
 256         d.found(typeName_())
 257       ? d.subDict(typeName_())
 258       : d
 259     );
 260
 261     // unspecified centre is (0 0 0)
 262     if( dict.found("p0") )
 263     {
 264         dict.lookup("p0") >> p0_;
 265     }
 266     else
 267     {
 268         FatalErrorIn
 269         (
 270             "void lineRefinement::operator=(const dictionary& d)"
 271         ) << "Entry p0 is not specified!" << exit(FatalError);
 272         p0_ = vector::zero;
 273     }
 274
 275     // specify radius
 276     if( dict.found("p1") )
 277     {
 278         dict.lookup("p1") >> p1_;
 279     }
 280     else
 281     {
 282         FatalErrorIn
 283         (
 284             "void lineRefinement::operator=(const dictionary& d)"
 285         ) << "Entry p1 is not specified!" << exit(FatalError);
 286         p1_ = vector::zero;
 287     }
 288 }
 289
 290 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 291
 292 Ostream& lineRefinement::operator<<(Ostream& os) const
 293 {
 294     os << "name " << name() << nl;
 295     os << "cell size " << cellSize() << nl;
 296     write(os);
 297     return os;
 298 }
 299
 300 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 301
 302 } // End namespace Foam
 303
 304 // ************************************************************************* //