conversion.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_GEOMETRY_GENERICGEOMETRY_CONVERSION_HH
#define DUNE_GEOMETRY_GENERICGEOMETRY_CONVERSION_HH

#include <dune/common/visibility.hh>

#include <dune/geometry/type.hh>
#include <dune/geometry/genericgeometry/topologytypes.hh>
#include <dune/geometry/genericgeometry/subtopologies.hh>

namespace Dune
{

  namespace GenericGeometry
  {

    // DuneGeometryType
    // ----------------

    template< class Topology, GeometryType::BasicType linetype >
    class DuneGeometryType;

    template< GeometryType::BasicType linetype >
    class DuneGeometryType< Point, linetype >
    {
      static_assert((linetype == GeometryType::simplex)
                     || (linetype == GeometryType::cube),
                    "Parameter linetype may only be a simplex or a cube.");

    public:
      static const unsigned int dimension = 0;
      static const GeometryType::BasicType basicType = linetype;
    };

    template< class BaseTopology, GeometryType::BasicType linetype >
    class DuneGeometryType< Prism< BaseTopology >, linetype >
    {
      typedef DuneGeometryType< BaseTopology, linetype > DuneBaseGeometryType;

      static_assert((linetype == GeometryType::simplex)
                     || (linetype == GeometryType::cube),
                          "Parameter linetype may only be a simplex or a cube.");

      static_assert((DuneBaseGeometryType::basicType == GeometryType::simplex)
                     || (DuneBaseGeometryType::basicType == GeometryType::cube),
                    "Only prisms over simplices or cubes can be converted.");

    public:
      static const unsigned int dimension = DuneBaseGeometryType::dimension + 1;
      static const GeometryType::BasicType basicType
        = ((dimension == 1)
           ? linetype
           : ((dimension == 2) || (DuneBaseGeometryType::basicType == GeometryType::cube))
           ? GeometryType::cube
           : GeometryType::prism);
    };

    template< class BaseTopology, GeometryType::BasicType linetype >
    class DuneGeometryType< Pyramid< BaseTopology >, linetype >
    {
      typedef DuneGeometryType< BaseTopology, linetype > DuneBaseGeometryType;

      static_assert((linetype == GeometryType::simplex)
                     || (linetype == GeometryType::cube),
                    "Parameter linetype may only be a simplex or a cube.");

      static_assert((DuneBaseGeometryType::basicType == GeometryType::simplex)
                     || (DuneBaseGeometryType::basicType == GeometryType::cube),
                    "Only pyramids over simplices or cubes can be converted.");

    public:
      static const unsigned int dimension = DuneBaseGeometryType::dimension + 1;
      static const GeometryType::BasicType basicType
        = ((dimension == 1)
           ? linetype
           : ((dimension == 2) || (DuneBaseGeometryType::basicType == GeometryType::simplex))
           ? GeometryType::simplex
           : GeometryType::pyramid);
    };



    // DuneGeometryTypeProvider
    // ------------------------

    template< unsigned int dim, GeometryType::BasicType linetype >
    struct DuneGeometryTypeProvider
    {
      static const unsigned int dimension = dim;

      static const unsigned int numTopologies = (1 << dimension);

    private:
      GeometryType types_[ (dimension>=1) ? numTopologies / 2 : numTopologies ];

      DUNE_EXPORT static const DuneGeometryTypeProvider &instance ()
      {
        static DuneGeometryTypeProvider inst;
        return inst;
      }

    public:
      static const GeometryType &type ( unsigned int topologyId )
      {
        assert( topologyId < numTopologies );
        return instance().types_[ topologyId / 2 ];
      }
    };


    // Convert
    // -------

    template< GeometryType :: BasicType type, unsigned int dim >
    struct Convert;

    template< unsigned int dim >
    struct Convert< GeometryType :: simplex, dim >
    {
      typedef Pyramid
      < typename Convert< GeometryType :: simplex, dim-1 > :: type >
      type;
    };

    template<>
    struct Convert< GeometryType :: simplex, 0 >
    {
      typedef Point type;
    };

    template<