common.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_GRID_IO_FILE_VTK_COMMON_HH
#define DUNE_GRID_IO_FILE_VTK_COMMON_HH
 
#include <limits>
#include <sstream>
#include <string>
#include <cstdint>
 
#include <dune/common/deprecated.hh>
#include <dune/common/exceptions.hh>
#include <dune/geometry/type.hh>
#include <dune/common/typetraits.hh>
 
namespace Dune
{
 
  namespace VTK {
 
    //
    //  VTKOptions
    //
 
 
    enum OutputType {
      ascii,
      base64,
      appendedraw,
      appendedbase64
      // //! Output to the file is compressed inline binary.
      // binarycompressed,
      // //! Output is compressed and appended to the file.
      // compressedappended
    };
 
    enum DataMode {
 
      conforming,
 
      nonconforming
    };
 
    //
    //  PrintType
    //
 
 
    template<typename T>
    struct PrintType {
      typedef T Type;
    };
 
    template<>
    struct PrintType<unsigned char> {
      typedef unsigned Type;
    };
 
    template<>
    struct PrintType<signed char> {
      typedef int Type;
    };
 
    template<>
    struct PrintType<char> {
      typedef std::conditional<std::numeric_limits<char>::is_signed,
          int, unsigned>::type
      Type;
    };
 
    //
    //  TypeName
    //
 
 
    template<typename T>
    class DUNE_DEPRECATED_MSG("TypeName will be removed after Dune 2.7. Look at VTK::toString and VTK::Precision for substitution.") TypeName {
      static std::string getString() {
        static const unsigned int_sizes[] = { 8, 16, 32, 64, 0 };
        static const unsigned float_sizes[] = { 32, 64, 0 };
        const unsigned* sizes;
 
        std::ostringstream s;
        if(std::numeric_limits<T>::is_integer) {
          if(std::numeric_limits<T>::is_signed)
            s << "Int";
          else
            s << "UInt";
          sizes = int_sizes;
        }
        else {
          // assume float
          s << "Float";
          sizes = float_sizes;
        }
 
        static const unsigned size = 8*sizeof(T);
        while(*sizes != 0 && *sizes <= size) ++sizes;
        --sizes;
        s << *sizes;
 
        return s.str();
      }
 
    public:
 
      const std::string& operator()() const {
        static const std::string s = getString();
        return s;
      }
    };
 
    //
    //  VTK::GeometryType related stuff
    //
 
 
    enum GeometryType {
      vertex = 1,
      line = 3,
      triangle = 5,
      polygon = 7,
      quadrilateral = 9,
      tetrahedron = 10,
      hexahedron = 12,
      prism = 13,
      pyramid = 14,
      polyhedron = 42
    };
 
 
    inline GeometryType geometryType(const Dune::GeometryType& t)
    {
      if (t.isVertex()) return vertex;
      if (t.isLine()) return line;
      if (t.isTriangle()) return triangle;
      if (t.isQuadrilateral()) return quadrilateral;
      if (t.isTetrahedron()) return tetrahedron;
      if (t.isPyramid()) return pyramid;
      if (t.isPrism()) return prism;
      if (t.isHexahedron()) return hexahedron;
 
      if (t.isNone() )
      {
        if( t.dim() == 2 ) return polygon;
        if( t.dim() == 3 ) return polyhedron;
      }
 
      DUNE_THROW(IOError,"VTKWriter: unsupported GeometryType " << t);
    }
 
    //
    //  Functions for transforming the index of a corner inside an entity
    //  between Dune and VTK
    //
 
 
    inline int renumber(const Dune::GeometryType &t, int i)
    {
      static const int quadRenumbering[4] = {0,1,3,2};
      static const int cubeRenumbering[8] = {0,1,3,2,4,5,7,6};
      static const int prismRenumbering[6] = {0,2,1,3,5,4};
      static const int pyramidRenumbering[5] = {0,1,3,2,4};
 
      if (t.isQuadrilateral()) return quadRenumbering[i];
      if (t.isPyramid()) return pyramidRenumbering[i];
      if (t.isPrism()) return prismRenumbering[i];
      if (t.isHexahedron()) return cubeRenumbering[i];
 
      return i;
    }
 
 
    template<typename T>
    int renumber(const T& t, int i)
    {
      return renumber(t.type(), i);
    }
 
    //
    //  Determine Endianness
    //
 
 
    inline std::string getEndiannessString()
    {
      short i = 1;
      if (reinterpret_cast<char*>(&i)[1] == 1)
        return "BigEndian";
      else
        return "LittleEndian";
    }
 
    //
    //  which type of vtkfile to write
    //
 
 
    enum FileType {
      polyData,
      unstructuredGrid
    };
 
 
    //
    //  which precision to use when writing out data
    //
 
 
    enum class Precision {
      int32,
      uint8,
      uint32,
      float32,
      float64
    };
 
    inline std::string toString(Precision p)
    {
      switch(p)
      {
        case Precision::float32:
          return "Float32";
        case Precision::float64:
          return "Float64";
        case Precision::uint32:
          return "UInt32";
        case Precision::uint8:
          return "UInt8";
        case Precision::int32:
          return "Int32";
        default:
          DUNE_THROW(Dune::NotImplemented, "Unknown precision type");
      }
    }
 
    inline std::size_t typeSize(Precision p)
    {
      switch(p)
      {
        case Precision::float32:
          return sizeof(float);
        case Precision::float64:
          return sizeof(double);
        case Precision::uint32:
          return sizeof(std::uint32_t);
        case Precision::uint8:
          return sizeof(std::uint8_t);
        case Precision::int32:
          return sizeof(std::int32_t);
        default:
          DUNE_THROW(Dune::NotImplemented, "Unknown precision type");
      }
    }
 
 
    class FieldInfo
    {
 
    public:
 
      enum class Type {
        scalar,
        vector,
        tensor
      };
 
      FieldInfo(std::string name, Type type, std::size_t size, Precision prec = Precision::float32)
        : _name(name)
        , _type(type)
        , _size(size)
        , _prec(prec)
      {}
 
      std::string name() const
      {
        return _name;
      }
 
      Type type() const
      {
        return _type;
      }
 
      std::size_t size() const
      {
        return _size;
      }
 
      Precision precision() const
      {
        return _prec;
      }
 
    private:
 
      std::string _name;
      Type _type;
      std::size_t _size;
      Precision _prec;
 
    };
 
 
  } // namespace VTK
 
 
} // namespace Dune
 
#endif // DUNE_GRID_IO_FILE_VTK_COMMON_HH