applications/utilities/postProcessing/dataConversion/foamToVTK/writeFuns.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 "writeFuns.H"
  28 #include "vtkTopo.H"
  29
  30 #if defined(__mips) && !defined(__SICORTEX__)
  31 #include <standards.h>
  32 #include <sys/endian.h>
  33 #endif
  34
  35 // MacOSX
  36 #ifdef __DARWIN_BYTE_ORDER
  37 #if __DARWIN_BYTE_ORDER==__DARWIN_BIG_ENDIAN
  38 #undef LITTLE_ENDIAN
  39 #else
  40 #undef BIG_ENDIAN
  41 #endif
  42 #endif
  43
  44 #if defined(LITTLE_ENDIAN) \
  45  || defined(_LITTLE_ENDIAN) \
  46  || defined(__LITTLE_ENDIAN)
  47 #   define LITTLEENDIAN 1
  48 #elif defined(BIG_ENDIAN) || defined(_BIG_ENDIAN) || defined(__BIG_ENDIAN)
  49 #   undef LITTLEENDIAN
  50 #else
  51 #   error "Cannot find LITTLE_ENDIAN or BIG_ENDIAN symbol defined."
  52 #   error "Please add to compilation options"
  53 #endif
  54
  55 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  56
  57 void Foam::writeFuns::swapWord(label& word32)
  58 {
  59     char* mem = reinterpret_cast<char*>(&word32);
  60
  61     char a = mem[0];
  62     mem[0] = mem[3];
  63     mem[3] = a;
  64
  65     a = mem[1];
  66     mem[1] = mem[2];
  67     mem[2] = a;
  68 }
  69
  70
  71 void Foam::writeFuns::swapWords(const label nWords, label* words32)
  72 {
  73     for (label i = 0; i < nWords; i++)
  74     {
  75         swapWord(words32[i]);
  76     }
  77 }
  78
  79
  80 void Foam::writeFuns::write
  81 (
  82     std::ostream& os,
  83     const bool binary,
  84     List<floatScalar>& fField
  85 )
  86 {
  87     if (binary)
  88     {
  89 #       ifdef LITTLEENDIAN
  90         swapWords(fField.size(), reinterpret_cast<label*>(fField.begin()));
  91 #       endif
  92         os.write
  93         (
  94             reinterpret_cast<char*>(fField.begin()),
  95             fField.size()*sizeof(float)
  96         );
  97
  98         os << std::endl;
  99     }
 100     else
 101     {
 102         forAll(fField, i)
 103         {
 104             os << fField[i] << ' ';
 105
 106             if (i > 0 && (i % 10) == 0)
 107             {
 108                 os << std::endl;
 109             }
 110         }
 111         os << std::endl;
 112     }
 113 }
 114
 115
 116 void Foam::writeFuns::write
 117 (
 118     std::ostream& os,
 119     const bool binary,
 120     DynamicList<floatScalar>& fField
 121 )
 122 {
 123     List<floatScalar>& fld = fField.shrink();
 124
 125     write(os, binary, fld);
 126 }
 127
 128
 129 void Foam::writeFuns::write
 130 (
 131     std::ostream& os,
 132     const bool binary,
 133     labelList& elems
 134 )
 135 {
 136     if (binary)
 137     {
 138 #       ifdef LITTLEENDIAN
 139         swapWords(elems.size(), reinterpret_cast<label*>(elems.begin()));
 140 #       endif
 141         os.write
 142         (
 143             reinterpret_cast<char*>(elems.begin()),
 144             elems.size()*sizeof(label)
 145         );
 146
 147         os << std::endl;
 148     }
 149     else
 150     {
 151         forAll(elems, i)
 152         {
 153             os << elems[i] << ' ';
 154
 155             if (i > 0 && (i % 10) == 0)
 156             {
 157                 os << std::endl;
 158             }
 159         }
 160         os << std::endl;
 161     }
 162 }
 163
 164
 165 void Foam::writeFuns::write
 166 (
 167     std::ostream& os,
 168     const bool binary,
 169     DynamicList<label>& elems
 170 )
 171 {
 172     labelList& fld = elems.shrink();
 173
 174     write(os, binary, fld);
 175 }
 176
 177
 178 void Foam::writeFuns::writeHeader
 179 (
 180     std::ostream& os,
 181     const bool binary,
 182     const string& name
 183 )
 184 {
 185     os  << "# vtk DataFile Version 2.0" << std::endl
 186         << name << std::endl;
 187
 188     if (binary)
 189     {
 190         os << "BINARY" << std::endl;
 191     }
 192     else
 193     {
 194         os << "ASCII" << std::endl;
 195     }
 196 }
 197
 198
 199 void Foam::writeFuns::writeCellDataHeader
 200 (
 201     std::ostream& os,
 202     const label nCells,
 203     const label nFields
 204 )
 205 {
 206     os  << "CELL_DATA " << nCells << std::endl
 207         << "FIELD attributes " << nFields << std::endl;
 208 }
 209
 210
 211 void Foam::writeFuns::writePointDataHeader
 212 (
 213     std::ostream& os,
 214     const label nPoints,
 215     const label nFields
 216 )
 217 {
 218     os  << "POINT_DATA  " << nPoints << std::endl
 219         << "FIELD attributes " << nFields << std::endl;
 220 }
 221
 222
 223 void Foam::writeFuns::insert(const scalar& pt, DynamicList<floatScalar>& dest)
 224 {
 225     dest.append(float(pt));
 226 }
 227
 228
 229 void Foam::writeFuns::insert(const vector& pt, DynamicList<floatScalar>& dest)
 230 {
 231     for (direction cmpt = 0; cmpt < vector::nComponents; cmpt++)
 232     {
 233         dest.append(float(pt[cmpt]));
 234     }
 235 }
 236
 237
 238 void Foam::writeFuns::insert
 239 (
 240     const sphericalTensor& pt,
 241     DynamicList<floatScalar>& dest
 242 )
 243 {
 244     for (direction cmpt = 0; cmpt < sphericalTensor::nComponents; cmpt++)
 245     {
 246         dest.append(float(pt[cmpt]));
 247     }
 248 }
 249
 250
 251 void Foam::writeFuns::insert
 252 (
 253     const symmTensor& pt,
 254     DynamicList<floatScalar>& dest
 255 )
 256 {
 257     for (direction cmpt = 0; cmpt < symmTensor::nComponents; cmpt++)
 258     {
 259         dest.append(float(pt[cmpt]));
 260     }
 261 }
 262
 263
 264 void Foam::writeFuns::insert(const tensor& pt, DynamicList<floatScalar>& dest)
 265 {
 266     for (direction cmpt = 0; cmpt < tensor::nComponents; cmpt++)
 267     {
 268         dest.append(float(pt[cmpt]));
 269     }
 270 }
 271
 272
 273 void Foam::writeFuns::insert(const labelList& source, DynamicList<label>& dest)
 274 {
 275     forAll(source, i)
 276     {
 277         dest.append(source[i]);
 278     }
 279 }
 280
 281
 282 // ************************************************************************* //