applications/utilities/mesh/manipulation/setSet/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 Description
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "writeFuns.H"
  30
  31 #if defined(__mips) && !defined(__SICORTEX__)
  32 #include <standards.h>
  33 #include <sys/endian.h>
  34 #endif
  35
  36 #if defined(LITTLE_ENDIAN) \
  37  || defined(_LITTLE_ENDIAN) \
  38  || defined(__LITTLE_ENDIAN)
  39 #   define LITTLEENDIAN 1
  40 #elif defined(BIG_ENDIAN) || defined(_BIG_ENDIAN) || defined(__BIG_ENDIAN)
  41 #   undef LITTLEENDIAN
  42 #else
  43 #   error "Cannot find LITTLE_ENDIAN or BIG_ENDIAN symbol defined."
  44 #   error "Please add to compilation options"
  45 #endif
  46
  47 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  48
  49 void Foam::writeFuns::swapWord(label& word32)
  50 {
  51     char* mem =  reinterpret_cast<char*>(&word32);
  52
  53     char a = mem[0];
  54     mem[0] = mem[3];
  55     mem[3] = a;
  56
  57     a = mem[1];
  58     mem[1] = mem[2];
  59     mem[2] = a;
  60 }
  61
  62
  63 void Foam::writeFuns::swapWords(const label nWords, label* words32)
  64 {
  65     for (label i = 0; i < nWords; i++)
  66     {
  67         swapWord(words32[i]);
  68     }
  69 }
  70
  71
  72 void Foam::writeFuns::write
  73 (
  74     std::ostream& os,
  75     const bool binary,
  76     List<floatScalar>& fField
  77 )
  78 {
  79     if (binary)
  80     {
  81 #       ifdef LITTLEENDIAN
  82         swapWords(fField.size(),  reinterpret_cast<label*>(fField.begin()));
  83 #       endif
  84
  85         os.write
  86         (
  87             reinterpret_cast<char*>(fField.begin()),
  88             fField.size()*sizeof(float)
  89         );
  90
  91         os << std::endl;
  92     }
  93     else
  94     {
  95         forAll(fField, i)
  96         {
  97             os << fField[i] << ' ';
  98
  99             if (i > 0 && (i % 10) == 0)
 100             {
 101                 os << std::endl;
 102             }
 103         }
 104         os << std::endl;
 105     }
 106 }
 107
 108
 109 void Foam::writeFuns::write
 110 (
 111     std::ostream& os,
 112     const bool binary,
 113     DynamicList<floatScalar>& fField
 114 )
 115 {
 116     List<floatScalar>& fld = fField.shrink();
 117
 118     write(os, binary, fld);
 119 }
 120
 121
 122 void Foam::writeFuns::write
 123 (
 124     std::ostream& os,
 125     const bool binary,
 126     labelList& elems
 127 )
 128 {
 129     if (binary)
 130     {
 131 #       ifdef LITTLEENDIAN
 132         swapWords(elems.size(),  reinterpret_cast<label*>(elems.begin()));
 133 #       endif
 134         os.write
 135         (
 136             reinterpret_cast<char*>(elems.begin()),
 137             elems.size()*sizeof(label)
 138         );
 139
 140         os << std::endl;
 141     }
 142     else
 143     {
 144         forAll(elems, i)
 145         {
 146             os << elems[i] << ' ';
 147
 148             if (i > 0 && (i % 10) == 0)
 149             {
 150                 os << std::endl;
 151             }
 152         }
 153         os << std::endl;
 154     }
 155 }
 156
 157
 158 void Foam::writeFuns::write
 159 (
 160     std::ostream& os,
 161     const bool binary,
 162     DynamicList<label>& elems
 163 )
 164 {
 165     labelList& fld = elems.shrink();
 166
 167     write(os, binary, fld);
 168 }
 169
 170
 171 // Store vector in dest.
 172 void Foam::writeFuns::insert(const point& pt, DynamicList<floatScalar>& dest)
 173 {
 174     dest.append(float(pt.x()));
 175     dest.append(float(pt.y()));
 176     dest.append(float(pt.z()));
 177 }
 178
 179
 180 // Store labelList in dest.
 181 void Foam::writeFuns::insert(const labelList& source, DynamicList<label>& dest)
 182 {
 183     forAll(source, i)
 184     {
 185         dest.append(source[i]);
 186     }
 187 }
 188
 189
 190 // Store scalarField in dest
 191 void Foam::writeFuns::insert
 192 (
 193     const List<scalar>& source,
 194     DynamicList<floatScalar>& dest
 195 )
 196 {
 197     forAll(source, i)
 198     {
 199         dest.append(float(source[i]));
 200     }
 201 }
 202
 203
 204 // Store scalarField (indexed through map) in dest
 205 void Foam::writeFuns::insert
 206 (
 207     const labelList& map,
 208     const List<scalar>& source,
 209     DynamicList<floatScalar>& dest
 210 )
 211 {
 212     forAll(map, i)
 213     {
 214         dest.append(float(source[map[i]]));
 215     }
 216 }
 217
 218
 219 void Foam::writeFuns::insert
 220 (
 221     const List<point>& source,
 222     DynamicList<floatScalar>& dest
 223 )
 224 {
 225     forAll(source, i)
 226     {
 227        insert(source[i], dest);
 228     }
 229 }
 230
 231 void Foam::writeFuns::insert
 232 (
 233     const labelList& map,
 234     const List<point>& source,
 235     DynamicList<floatScalar>& dest
 236 )
 237 {
 238     forAll(map, i)
 239     {
 240        insert(source[map[i]], dest);
 241     }
 242 }
 243
 244
 245 // ************************************************************************* //