dune-geometry: topologytypes.hh Source File

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_TOPOLOGYTYPES_HH
 #define DUNE_GEOMETRY_GENERICGEOMETRY_TOPOLOGYTYPES_HH
 
 #include <cassert>
 #include <string>
 
 #include <dune/common/static_assert.hh>
 #include <dune/common/typetraits.hh>
 #include <dune/common/unused.hh>
 
 namespace Dune
 {
 
   namespace GenericGeometry
   {
 
     enum TopologyConstruction { pyramidConstruction = 0, prismConstruction = 1 };
 
 
 
     // Basic Topology Types
     // --------------------
 
     struct Point
     {
       static const unsigned int dimension = 0;
       static const unsigned int numCorners = 1;
 
       static const unsigned int id = 0;
 
       static std :: string name ()
       {
         return "p";
       }
     };
 
 
     template< class BaseTopology >
     struct Prism
     {
       static const unsigned int dimension = BaseTopology :: dimension + 1;
       static const unsigned int numCorners = 2 * BaseTopology :: numCorners;
 
       static const unsigned int id = BaseTopology::id | ((unsigned int)prismConstruction << (dimension-1));
 
       static std :: string name ()
       {
         return BaseTopology :: name() + "l";
         // return BaseTopology :: name() + "'";
       }
     };
 
 
     template< class BaseTopology >
     struct Pyramid
     {
       static const unsigned int dimension = BaseTopology :: dimension + 1;
       static const unsigned int numCorners = BaseTopology :: numCorners + 1;
 
       static const unsigned int id = BaseTopology::id | ((unsigned int)pyramidConstruction << (dimension-1));
 
       static std :: string name ()
       {
         return BaseTopology :: name() + "o";
         // return BaseTopology :: name() + "°";
       }
     };
 
 
 
     template< class Topology >
     struct BaseTopology;
 
     template< class Base >
     struct BaseTopology< Prism< Base > >
     {
       typedef Base type;
     };
 
     template< class Base >
     struct BaseTopology< Pyramid< Base > >
     {
       typedef Base type;
     };
 
 
 
     template< class Topology >
     struct IsSimplex
     {
       static const bool value = ((Topology::id >> 1) == 0);
     };
 
     template< class Topology >
     struct IsCube
     {
       static const bool value = ((Topology::id | 1) == (1 << Topology::dimension) - 1);
     };
 
     template< class Topology >
     struct IsHybrid
     {
       static const bool value
         = !(IsSimplex< Topology >::value || IsCube< Topology >::value);
     };
 
     template< class Topology >
     struct IsGeneralizedPrism
     {
       static const bool value = false;
     };
 
     template< class BaseTopology >
     struct IsGeneralizedPrism< Prism< BaseTopology > >
     {
       static const bool value
         = (IsGeneralizedPrism< BaseTopology >::value || IsSimplex< BaseTopology >::value);
     };
 
 
 
     // Dynamic Topology Properties
     // ---------------------------
 
     inline unsigned int numTopologies ( int dim )
     {
       return (1u << dim);
     }
 
     inline bool isPyramid ( unsigned int topologyId, int dim, int codim = 0 )
     {
       assert( (dim > 0) && (topologyId < numTopologies( dim )) );
       assert( (0 <= codim) && (codim < dim) );
       return (((topologyId & ~1) & (1u << (dim-codim-1))) == 0);
     }
 
     inline bool isPrism ( unsigned int topologyId, int dim, int codim = 0 )
     {
       assert( (dim > 0) && (topologyId < numTopologies( dim )) );
       assert( (0 <= codim) && (codim < dim) );
       return (( (topologyId | 1) & (1u << (dim-codim-1))) != 0);
     }
 
     inline bool isTopology ( TopologyConstruction construction, unsigned int topologyId, int dim, int codim = 0 )
     {
       assert( (dim > 0) && (topologyId < numTopologies( dim )) );
       assert( (0 <= codim) && (codim <= dim) );
       return (codim >= (dim-1)) || (((topologyId >> (dim-codim-1)) & 1) == (unsigned int)construction);
     }
 
     inline unsigned int baseTopologyId ( unsigned int topologyId, int dim, int codim = 1 )
     {
       assert( (dim >= 0) && (topologyId < numTopologies( dim )) );
       assert( (0 <= codim) && (codim <= dim) );
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------
 
     template< unsigned int dim >
     struct SimplexTopology
     {
       return topologyId & ((1u << (dim-codim)) - 1);
     }
 
 
 
     // SimplexTopology
     // ---------------