src/meshLibrary/utilities/octrees/meshOctree/refinementControls/objectRefinement/coneRefinement.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 "coneRefinement.H"
  27 #include "addToRunTimeSelectionTable.H"
  28 #include "boundBox.H"
  29
  30 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  31
  32 namespace Foam
  33 {
  34
  35 defineTypeNameAndDebug(coneRefinement, 0);
  36 addToRunTimeSelectionTable(objectRefinement, coneRefinement, dictionary);
  37
  38 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  39
  40 coneRefinement::coneRefinement()
  41 :
  42     objectRefinement(),
  43     p0_(),
  44     r0_(-1.0),
  45     p1_(),
  46     r1_(-1.0)
  47 {}
  48
  49 coneRefinement::coneRefinement
  50 (
  51     const word& name,
  52     const scalar cellSize,
  53     const point& p0,
  54     const scalar radius0,
  55     const point& p1,
  56     const scalar radius1
  57 )
  58 :
  59     objectRefinement(),
  60     p0_(p0),
  61     r0_(radius0),
  62     p1_(p1),
  63     r1_(radius1)
  64 {
  65     setName(name);
  66     setCellSize(cellSize);
  67 }
  68
  69 coneRefinement::coneRefinement
  70 (
  71     const word& name,
  72     const dictionary& dict
  73 )
  74 :
  75     objectRefinement(name, dict)
  76 {
  77     this->operator=(dict);
  78 }
  79
  80 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  81
  82 bool coneRefinement::intersectsObject(const boundBox& bb) const
  83 {
  84     //- check if the centre is inside the cone
  85     const point c = (bb.max() + bb.min()) / 2.0;
  86
  87     const vector v = p1_ - p0_;
  88     const scalar d = magSqr(v);
  89
  90     if( d < VSMALL )
  91         return false;
  92
  93     const scalar t = ((c - p0_) & v) / d;
  94     if( (t > 1.0) || (t < 0.0) )
  95         return false;
  96
  97     const scalar r = r0_ + (r1_ - r0_) * t;
  98
  99     if( mag(p0_ + t * v - c) < r )
 100         return true;
 101
 102     return false;
 103 }
 104
 105 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 106
 107 dictionary coneRefinement::dict(bool ignoreType) const
 108 {
 109     dictionary dict;
 110
 111     dict.add("cellSize", cellSize());
 112     dict.add("type", type());
 113
 114     dict.add("p0", p0_);
 115     dict.add("radius0", r0_);
 116     dict.add("p1", p1_);
 117     dict.add("radius1", r1_);
 118
 119     return dict;
 120 }
 121
 122 void coneRefinement::write(Ostream& os) const
 123 {
 124     os  << " type:   " << type()
 125         << " p0: " << p0_
 126         << " radius0: " << r0_
 127         << " p1: " << p1_
 128         << " radius1: " << r1_;
 129 }
 130
 131 void coneRefinement::writeDict(Ostream& os, bool subDict) const
 132 {
 133     if( subDict )
 134     {
 135         os << indent << token::BEGIN_BLOCK << incrIndent << nl;
 136     }
 137
 138     os.writeKeyword("cellSize") << cellSize() << token::END_STATEMENT << nl;
 139
 140     // only write type for derived types
 141     if( type() != typeName_() )
 142     {
 143         os.writeKeyword("type") << type() << token::END_STATEMENT << nl;
 144     }
 145
 146     os.writeKeyword("p0") << p0_ << token::END_STATEMENT << nl;
 147     os.writeKeyword("radius0") << r0_ << token::END_STATEMENT << nl;
 148     os.writeKeyword("p1") << p1_ << token::END_STATEMENT << nl;
 149     os.writeKeyword("radius1") << r1_ << token::END_STATEMENT << nl;
 150
 151     if( subDict )
 152     {
 153         os << decrIndent << indent << token::END_BLOCK << endl;
 154     }
 155 }
 156
 157 void coneRefinement::operator=(const dictionary& d)
 158 {
 159     // allow as embedded sub-dictionary "coordinateSystem"
 160     const dictionary& dict =
 161     (
 162         d.found(typeName_())
 163       ? d.subDict(typeName_())
 164       : d
 165     );
 166
 167     // unspecified centre is (0 0 0)
 168     if( dict.found("p0") )
 169     {
 170         dict.lookup("p0") >> p0_;
 171     }
 172     else
 173     {
 174         FatalErrorIn
 175         (
 176             "void coneRefinement::operator=(const dictionary& d)"
 177         ) << "Entry p0 is not specified!" << exit(FatalError);
 178         p0_ = vector::zero;
 179     }
 180
 181     // specify radius
 182     if( dict.found("radius0") )
 183     {
 184         r0_ = readScalar(dict.lookup("radius0"));
 185     }
 186     else
 187     {
 188         FatalErrorIn
 189         (
 190             "void coneRefinement::operator=(const dictionary& d)"
 191         ) << "Entry radius0 is not specified!" << exit(FatalError);
 192         r0_ = -1.0;
 193     }
 194
 195     // unspecified centre is (0 0 0)
 196     if( dict.found("p1") )
 197     {
 198         dict.lookup("p1") >> p1_;
 199     }
 200     else
 201     {
 202         FatalErrorIn
 203         (
 204             "void coneRefinement::operator=(const dictionary& d)"
 205         ) << "Entry p1 is not specified!" << exit(FatalError);
 206         p1_ = vector::zero;
 207     }
 208
 209     // specify radius
 210     if( dict.found("radius1") )
 211     {
 212         r1_ = readScalar(dict.lookup("radius1"));
 213     }
 214     else
 215     {
 216         FatalErrorIn
 217         (
 218             "void coneRefinement::operator=(const dictionary& d)"
 219         ) << "Entry radius1 is not specified!" << exit(FatalError);
 220         r1_ = -1.0;
 221     }
 222 }
 223
 224 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 225
 226 Ostream& coneRefinement::operator<<(Ostream& os) const
 227 {
 228     os << "name " << name() << nl;
 229     os << "cell size " << cellSize() << nl;
 230     write(os);
 231     return os;
 232 }
 233
 234 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 235
 236 } // End namespace Foam
 237
 238 // ************************************************************************* //