src/sampling/sampledSurface/writers/raw/rawSurfaceWriter.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM 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 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM 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 OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "rawSurfaceWriter.H"
  28
  29 #include "OFstream.H"
  30 #include "OSspecific.H"
  31 #include "IOmanip.H"
  32
  33 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  34
  35 template<class Type>
  36 void Foam::rawSurfaceWriter<Type>::writeGeometry
  37 (
  38     const pointField& points,
  39     const label pointI,
  40     Ostream& os
  41 )
  42 {
  43     const point& pt = points[pointI];
  44
  45     os << pt.x() << ' ' << pt.y() << ' ' << pt.z() << ' ';
  46 }
  47
  48
  49 template<class Type>
  50 void Foam::rawSurfaceWriter<Type>::writeGeometry
  51 (
  52     const pointField& points,
  53     const faceList& faces,
  54     const label faceI,
  55     Ostream& os
  56 )
  57 {
  58     const point& ct = faces[faceI].centre(points);
  59
  60     os << ct.x() << ' ' << ct.y() << ' ' << ct.z() << ' ';
  61 }
  62
  63
  64 // Write scalarField in raw format
  65 template<class Type>
  66 void Foam::rawSurfaceWriter<Type>::writeData
  67 (
  68     const fileName& fieldName,
  69     const pointField& points,
  70     const faceList& faces,
  71     const scalarField& values,
  72     Ostream& os
  73 )
  74 {
  75     // header
  76     os  << "#  x  y  z  " << fieldName << endl;
  77
  78     // Write data
  79     if (values.size() == points.size())
  80     {
  81         forAll(values, elemI)
  82         {
  83             writeGeometry(points, elemI, os);
  84             os << values[elemI] << nl;
  85         }
  86     }
  87     else
  88     {
  89         forAll(values, elemI)
  90         {
  91             writeGeometry(points, faces, elemI, os);
  92             os << values[elemI] << nl;
  93         }
  94     }
  95
  96     os << nl;
  97 }
  98
  99
 100 // Write vectorField in raw format
 101 template<class Type>
 102 void Foam::rawSurfaceWriter<Type>::writeData
 103 (
 104     const fileName& fieldName,
 105     const pointField& points,
 106     const faceList& faces,
 107     const vectorField& values,
 108     Ostream& os
 109 )
 110 {
 111     // header
 112     os  << "#  x  y  z  "
 113         << fieldName << "_x  "
 114         << fieldName << "_y  "
 115         << fieldName << "_z  "
 116         << endl;
 117
 118     // Write data
 119     if (values.size() == points.size())
 120     {
 121         forAll(values, elemI)
 122         {
 123             writeGeometry(points, elemI, os);
 124
 125             const vector& v = values[elemI];
 126             os << v[0] << ' ' << v[1] << ' ' << v[2] << nl;
 127         }
 128     }
 129     else
 130     {
 131         forAll(values, elemI)
 132         {
 133             writeGeometry(points, faces, elemI, os);
 134
 135             const vector& v = values[elemI];
 136             os << v[0] << ' ' << v[1] << ' ' << v[2] << nl;
 137         }
 138     }
 139
 140 }
 141
 142
 143 // Write sphericalTensorField in raw format
 144 template<class Type>
 145 void Foam::rawSurfaceWriter<Type>::writeData
 146 (
 147     const fileName& fieldName,
 148     const pointField& points,
 149     const faceList& faces,
 150     const sphericalTensorField& values,
 151     Ostream& os
 152 )
 153 {
 154     // header
 155     os  << "#  ii  ";
 156     os << fieldName << "_ii" << endl;
 157
 158     // Write data
 159     if (values.size() == points.size())
 160     {
 161         forAll(values, elemI)
 162         {
 163             writeGeometry(points, elemI, os);
 164
 165             const sphericalTensor& v = values[elemI];
 166             os  << v[0] << nl;
 167         }
 168     }
 169     else
 170     {
 171         forAll(values, elemI)
 172         {
 173             writeGeometry(points, faces, elemI, os);
 174
 175             const sphericalTensor& v = values[elemI];
 176             os  << v[0] << nl;
 177         }
 178     }
 179 }
 180
 181
 182 // Write symmTensorField in raw format
 183 template<class Type>
 184 void Foam::rawSurfaceWriter<Type>::writeData
 185 (
 186     const fileName& fieldName,
 187     const pointField& points,
 188     const faceList& faces,
 189     const symmTensorField& values,
 190     Ostream& os
 191 )
 192 {
 193     // header
 194     os  << "#  xx  xy  xz  yy  yz ";
 195     for(int i=0; i<6; i++)
 196     {
 197         os << fieldName << "_" << i << "  ";
 198     }
 199     os << endl;
 200
 201     // Write data
 202     if (values.size() == points.size())
 203     {
 204         forAll(values, elemI)
 205         {
 206             writeGeometry(points, elemI, os);
 207
 208             const symmTensor& v = values[elemI];
 209
 210             os  << v[0] << ' ' << v[1] << ' ' << v[2] << ' '
 211                 << v[3] << ' ' << v[4] << ' ' << v[5] << ' '
 212                 << nl;
 213         }
 214     }
 215     else
 216     {
 217         forAll(values, elemI)
 218         {
 219             writeGeometry(points, faces, elemI, os);
 220
 221             const symmTensor& v = values[elemI];
 222
 223             os  << v[0] << ' ' << v[1] << ' ' << v[2] << ' '
 224                 << v[3] << ' ' << v[4] << ' ' << v[5] << ' '
 225                 << nl;
 226         }
 227     }
 228 }
 229
 230
 231 // Write tensorField in raw format
 232 template<class Type>
 233 void Foam::rawSurfaceWriter<Type>::writeData
 234 (
 235     const fileName& fieldName,
 236     const pointField& points,
 237     const faceList& faces,
 238     const tensorField& values,
 239     Ostream& os
 240 )
 241 {
 242     // header
 243     os  << "#  xx  xy  xz  yx  yy  yz  zx  zy  zz";
 244     for (int i=0; i<9; ++i)
 245     {
 246         os << fieldName << "_" << i << "  ";
 247     }
 248     os << endl;
 249
 250     // Write data
 251     if (values.size() == points.size())
 252     {
 253         forAll(values, elemI)
 254         {
 255             writeGeometry(points, elemI, os);
 256
 257             const tensor& v = values[elemI];
 258             os  << v[0] << ' ' << v[1] << ' ' << v[2] << ' '
 259                 << v[3] << ' ' << v[4] << ' ' << v[5] << ' '
 260                 << v[6] << ' ' << v[7] << ' ' << v[8] << nl;
 261         }
 262     }
 263     else
 264     {
 265         forAll(values, elemI)
 266         {
 267             writeGeometry(points, faces, elemI, os);
 268
 269             const tensor& v = values[elemI];
 270             os  << v[0] << ' ' << v[1] << ' ' << v[2] << ' '
 271                 << v[3] << ' ' << v[4] << ' ' << v[5] << ' '
 272                 << v[6] << ' ' << v[7] << ' ' << v[8] << nl;
 273         }
 274     }
 275 }
 276
 277
 278 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 279
 280 template<class Type>
 281 Foam::rawSurfaceWriter<Type>::rawSurfaceWriter()
 282 :
 283     surfaceWriter<Type>()
 284 {}
 285
 286
 287 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 288
 289 template<class Type>
 290 Foam::rawSurfaceWriter<Type>::~rawSurfaceWriter()
 291 {}
 292
 293
 294 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 295
 296 template<class Type>
 297 void Foam::rawSurfaceWriter<Type>::write
 298 (
 299     const fileName& outputDir,
 300     const fileName& surfaceName,
 301     const pointField& points,
 302     const faceList& faces,
 303     const bool verbose
 304 ) const
 305 {
 306     if (!isDir(outputDir))
 307     {
 308         mkDir(outputDir);
 309     }
 310
 311     OFstream os
 312     (
 313         outputDir/surfaceName + ".raw"
 314     );
 315
 316     if (verbose)
 317     {
 318         Info<< "Writing geometry to " << os.name() << endl;
 319     }
 320
 321
 322     // header
 323     os  << "# geometry NO_DATA " << faces.size() << nl
 324         << "#  x  y  z" << endl;
 325
 326     // Write faces
 327     forAll(faces, elemI)
 328     {
 329         writeGeometry(points, faces, elemI, os);
 330         os << nl;
 331     }
 332
 333     os << nl;
 334 }
 335
 336
 337 namespace Foam
 338 {
 339     // bool fields aren't supported
 340     template<>
 341     void Foam::rawSurfaceWriter<bool>::write
 342     (
 343         const fileName& outputDir,
 344         const fileName& surfaceName,
 345         const pointField& points,
 346         const faceList& faces,
 347         const fileName& fieldName,
 348         const Field<bool>& values,
 349         const bool verbose
 350     ) const
 351     {}
 352 }
 353
 354
 355 template<class Type>
 356 void Foam::rawSurfaceWriter<Type>::write
 357 (
 358     const fileName& outputDir,
 359     const fileName& surfaceName,
 360     const pointField& points,
 361     const faceList& faces,
 362     const fileName& fieldName,
 363     const Field<Type>& values,
 364     const bool verbose
 365 ) const
 366 {
 367     if (!isDir(outputDir))
 368     {
 369         mkDir(outputDir);
 370     }
 371
 372     OFstream os
 373     (
 374         outputDir/fieldName + '_' + surfaceName + ".raw"
 375     );
 376
 377     if (verbose)
 378     {
 379         Info<< "Writing field " << fieldName << " to " << os.name() << endl;
 380     }
 381
 382
 383     // header
 384     os  << "# " << fieldName;
 385     if (values.size() == points.size())
 386     {
 387         os  << "  POINT_DATA ";
 388     }
 389     else
 390     {
 391         os  << "  FACE_DATA ";
 392     }
 393
 394     os  << values.size() << nl;
 395
 396     writeData(fieldName, points, faces, values, os);
 397 }
 398
 399
 400 // ************************************************************************* //