Commit bdbd12c4 authored by Ján Bobot's avatar Ján Bobot Committed by Jakub Klinkovský
Browse files

Extension of Mesh for Polygons 

- added SubentityMatrixType to MeshSubentityTraits and modified SubentityMatrixType in MeshTraits to get SubentityMatrixType from MeshSubentityTraits based on Dimension and Subdimension template arguments
- refactored template argument EntityTopologyDimensionTag of SubentityStorageLayer back to EntityTopology to allow specializing for Polygon
- added Polygon specialization for MeshSubentityTraits that uses different SubentityMatrixType and leaves out any count related defined types
- added Polygon specialization for SubentityStorageLayer, that unlike SubentityStorageLayer used in other cell topologies, additionaly stores subentiesCounts
- added setSubentitiesCounts function to mesh and its storage related parent classes for setting subentitiesCounts in SubentityStorageLayer
- modified getSubentitiesCount function in mesh to pass the unused entityIndex parameter to StorageBaseType::getSubentitiesCount to enable retrieving variable subentitiesCounts from Polygon specialization of SubentityStorageLayer
parent 40aa3f83

src/TNL/Meshes/Mesh.h

+3 −0
Original line number Diff line number Diff line
@@ -281,6 +281,9 @@ class Mesh 


      template< typename Mesh, int Dimension >

      friend struct IndexPermutationApplier;



      template< int EntityDimension, int SubentityDimension >

      void setSubentitiesCounts( const typename MeshTraitsType::NeighborCountsArray& counts );

};



template< typename MeshConfig, typename Device >

src/TNL/Meshes/Mesh.hpp

+9 −1
Original line number Diff line number Diff line
@@ -180,6 +180,14 @@ getPoint( const GlobalIndexType vertexIndex ) 
   return this->points[ vertexIndex ];

}



template< typename MeshConfig, typename Device >

   template< int EntityDimension, int SubentityDimension >

void

Mesh< MeshConfig, Device >::

setSubentitiesCounts( const typename MeshTraitsType::NeighborCountsArray& counts )

{

   StorageBaseType::template setSubentitiesCounts< EntityDimension, SubentityDimension >( counts );

}



template< typename MeshConfig, typename Device >

   template< int EntityDimension, int SubentityDimension >
@@ -188,7 +196,7 @@ constexpr typename Mesh< MeshConfig, Device >::LocalIndexType 
Mesh< MeshConfig, Device >::

getSubentitiesCount( const GlobalIndexType entityIndex ) const

{

   return StorageBaseType::template getSubentitiesCount< EntityDimension, SubentityDimension >();

   return StorageBaseType::template getSubentitiesCount< EntityDimension, SubentityDimension >( entityIndex );

}



template< typename MeshConfig, typename Device >

src/TNL/Meshes/MeshDetails/layers/StorageLayer.h

+23 −9
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ class StorageLayerFamily 
     public DualGraphLayer< MeshConfig, Device >

{

   using MeshTraitsType = MeshTraits< MeshConfig, Device >;

   using GlobalIndexType = typename MeshTraitsType::GlobalIndexType;

   using BaseType       = StorageLayer< MeshConfig, Device, DimensionTag< 0 > >;

   template< int Dimension >

   using EntityTraits = typename MeshTraitsType::template EntityTraits< Dimension >;
@@ -83,23 +84,36 @@ public: 
               DualGraphLayer< MeshConfig, Device >::operator==( layer ) );

   }



   template< int Dimension, int Subdimension >

   void

   setSubentitiesCounts( const typename MeshTraitsType::NeighborCountsArray& counts )

   {

      static_assert( Dimension > Subdimension, "Invalid combination of Dimension and Subdimension." );

      static_assert( SubentityTraits< Dimension, Subdimension >::storageEnabled,

                     "You try to set subentitiesCounts for subentities which are disabled in the mesh configuration." );

      using BaseType = SubentityStorageLayerFamily< MeshConfig,

                                                    Device,

                                                    typename EntityTraits< Dimension >::EntityTopology >;

      BaseType::template setSubentitiesCounts< Subdimension >( counts );

   }



   template< int Dimension, int Subdimension >

   __cuda_callable__

   typename MeshTraitsType::LocalIndexType

   getSubentitiesCount() const

   getSubentitiesCount( const GlobalIndexType entityIndex ) const

   {

      static_assert( Dimension > Subdimension, "Invalid combination of Dimension and Subdimension." );

      static_assert( SubentityTraits< Dimension, Subdimension >::storageEnabled,

                     "You try to get subentities count for subentities which are disabled in the mesh configuration." );

      using BaseType = SubentityStorageLayerFamily< MeshConfig,

                                                    Device,

                                                    DimensionTag< Dimension > >;

      return BaseType::template getSubentitiesCount< Subdimension >();

                                                    typename EntityTraits< Dimension >::EntityTopology >;

      return BaseType::template getSubentitiesCount< Subdimension >( entityIndex );

   }



   template< int Dimension, int Subdimension >

   __cuda_callable__

   typename MeshTraitsType::SubentityMatrixType&

   typename MeshTraitsType::template SubentityMatrixType< Dimension, Subdimension >&

   getSubentitiesMatrix()

   {

      static_assert( Dimension > Subdimension, "Invalid combination of Dimension and Subdimension." );
@@ -107,13 +121,13 @@ public: 
                     "You try to get subentities matrix which is disabled in the mesh configuration." );

      using BaseType = SubentityStorageLayerFamily< MeshConfig,

                                                    Device,

                                                    DimensionTag< Dimension > >;

                                                    typename EntityTraits< Dimension >::EntityTopology >;

      return BaseType::template getSubentitiesMatrix< Subdimension >();

   }



   template< int Dimension, int Subdimension >

   __cuda_callable__

   const typename MeshTraitsType::SubentityMatrixType&

   const typename MeshTraitsType::template SubentityMatrixType< Dimension, Subdimension >&

   getSubentitiesMatrix() const

   {

      static_assert( Dimension > Subdimension, "Invalid combination of Dimension and Subdimension." );
@@ -121,7 +135,7 @@ public: 
                     "You try to get subentities matrix which is disabled in the mesh configuration." );

      using BaseType = SubentityStorageLayerFamily< MeshConfig,

                                                    Device,

                                                    DimensionTag< Dimension > >;

                                                    typename EntityTraits< Dimension >::EntityTopology >;

      return BaseType::template getSubentitiesMatrix< Subdimension >();

   }
@@ -192,7 +206,7 @@ class StorageLayer< MeshConfig, 
                    true >

   : public SubentityStorageLayerFamily< MeshConfig,

                                         Device,

                                         DimensionTag >,

                                         typename MeshTraits< MeshConfig, Device >::template EntityTraits< DimensionTag::value >::EntityTopology >,

     public SubentityOrientationsLayerFamily< MeshConfig,

                                              Device,

                                              typename MeshTraits< MeshConfig, Device >::template EntityTraits< DimensionTag::value >::EntityTopology >,
@@ -208,7 +222,7 @@ public: 
   using EntityTraitsType = typename MeshTraitsType::template EntityTraits< DimensionTag::value >;

   using EntityType       = typename EntityTraitsType::EntityType;

   using EntityTopology   = typename EntityTraitsType::EntityTopology;

   using SubentityStorageBaseType = SubentityStorageLayerFamily< MeshConfig, Device, DimensionTag >;

   using SubentityStorageBaseType = SubentityStorageLayerFamily< MeshConfig, Device, EntityTopology >;

   using SubentityOrientationsBaseType = SubentityOrientationsLayerFamily< MeshConfig, Device, EntityTopology >;

   using SuperentityStorageBaseType = SuperentityStorageLayerFamily< MeshConfig, Device, DimensionTag >;

src/TNL/Meshes/MeshDetails/layers/SubentityStorageLayer.h

+198 −33
Original line number Diff line number Diff line
@@ -20,25 +20,27 @@ 
#include <TNL/Meshes/DimensionTag.h>

#include <TNL/Meshes/MeshDetails/traits/MeshTraits.h>

#include <TNL/Meshes/MeshDetails/traits/WeakStorageTraits.h>

#include <TNL/Meshes/Topologies/Polygon.h>



namespace TNL {

namespace Meshes {



template< typename MeshConfig,

          typename Device,

          typename EntityTopologyDimensionTag,

          typename EntityTopology,

          typename SubdimensionTag,

          bool SubentityStorage = WeakSubentityStorageTrait< MeshConfig, Device, typename MeshTraits< MeshConfig, Device >::template EntityTraits< EntityTopologyDimensionTag::value >::EntityTopology, SubdimensionTag >::storageEnabled >

          bool SubentityStorage = WeakSubentityStorageTrait< MeshConfig, Device, typename MeshTraits< MeshConfig, Device >::template EntityTraits< EntityTopology::dimension >::EntityTopology, SubdimensionTag >::storageEnabled >

class SubentityStorageLayer;



template< typename MeshConfig,

          typename Device,

          typename EntityTopologyDimensionTag >

          typename EntityTopology >

class SubentityStorageLayerFamily

   : public SubentityStorageLayer< MeshConfig, Device, EntityTopologyDimensionTag, DimensionTag< 0 > >

   : public SubentityStorageLayer< MeshConfig, Device, EntityTopology, DimensionTag< 0 > >

{

   using BaseType = SubentityStorageLayer< MeshConfig, Device, EntityTopologyDimensionTag, DimensionTag< 0 > >;

   using BaseType = SubentityStorageLayer< MeshConfig, Device, EntityTopology, DimensionTag< 0 > >;

   using MeshTraitsType = MeshTraits< MeshConfig, Device >;

   using GlobalIndexType = typename MeshTraitsType::GlobalIndexType;



public:

   // inherit constructors and assignment operators (including templated versions)
@@ -46,52 +48,60 @@ public: 
   using BaseType::operator=;



protected:

   template< int Subdimension >

   void

   setSubentitiesCounts( const typename MeshTraitsType::NeighborCountsArray& counts )

   {

      static_assert( EntityTopology::dimension > Subdimension, "Invalid combination of Dimension and Subdimension." );

      BaseType::setSubentitiesCounts( DimensionTag< Subdimension >( ), counts );

   }



   template< int Subdimension >

   __cuda_callable__

   typename MeshTraitsType::LocalIndexType

   getSubentitiesCount() const

   getSubentitiesCount( const GlobalIndexType entityIndex ) const

   {

      static_assert( EntityTopologyDimensionTag::value > Subdimension, "Invalid combination of Dimension and Subdimension." );

      return BaseType::getSubentitiesCount( DimensionTag< Subdimension >() );

      static_assert( EntityTopology::dimension > Subdimension, "Invalid combination of Dimension and Subdimension." );

      return BaseType::getSubentitiesCount( DimensionTag< Subdimension >( ), entityIndex );

   }



   template< int Subdimension >

   __cuda_callable__

   typename MeshTraitsType::SubentityMatrixType&

   typename MeshTraitsType::template SubentityMatrixType< EntityTopology::dimension, Subdimension >&

   getSubentitiesMatrix()

   {

      static_assert( EntityTopologyDimensionTag::value > Subdimension, "Invalid combination of Dimension and Subdimension." );

      static_assert( EntityTopology::dimension > Subdimension, "Invalid combination of Dimension and Subdimension." );

      return BaseType::getSubentitiesMatrix( DimensionTag< Subdimension >() );

   }



   template< int Subdimension >

   __cuda_callable__

   const typename MeshTraitsType::SubentityMatrixType&

   const typename MeshTraitsType::template SubentityMatrixType< EntityTopology::dimension, Subdimension >&

   getSubentitiesMatrix() const

   {

      static_assert( EntityTopologyDimensionTag::value > Subdimension, "Invalid combination of Dimension and Subdimension." );

      static_assert( EntityTopology::dimension > Subdimension, "Invalid combination of Dimension and Subdimension." );

      return BaseType::getSubentitiesMatrix( DimensionTag< Subdimension >() );

   }

};



template< typename MeshConfig,

          typename Device,

          typename EntityTopologyDimensionTag,

          typename EntityTopology,

          typename SubdimensionTag >

class SubentityStorageLayer< MeshConfig,

                             Device,

                             EntityTopologyDimensionTag,

                             EntityTopology,

                             SubdimensionTag,

                             true >

   : public SubentityStorageLayer< MeshConfig, Device, EntityTopologyDimensionTag, typename SubdimensionTag::Increment >

   : public SubentityStorageLayer< MeshConfig, Device, EntityTopology, typename SubdimensionTag::Increment >

{

   using BaseType = SubentityStorageLayer< MeshConfig, Device, EntityTopologyDimensionTag, typename SubdimensionTag::Increment >;

   using BaseType = SubentityStorageLayer< MeshConfig, Device, EntityTopology, typename SubdimensionTag::Increment >;

   using MeshTraitsType      = MeshTraits< MeshConfig, Device >;



protected:

   using GlobalIndexType    = typename MeshTraitsType::GlobalIndexType;

   using LocalIndexType     = typename MeshTraitsType::LocalIndexType;

   using SubentityMatrixType = typename MeshTraitsType::SubentityMatrixType;

   using SubentityMatrixType = typename MeshTraitsType::template SubentityMatrixType< EntityTopology::dimension, SubdimensionTag::value >;



   SubentityStorageLayer() = default;
@@ -101,7 +111,7 @@ protected: 
   }



   template< typename Device_ >

   SubentityStorageLayer( const SubentityStorageLayer< MeshConfig, Device_, EntityTopologyDimensionTag, SubdimensionTag >& other )

   SubentityStorageLayer( const SubentityStorageLayer< MeshConfig, Device_, EntityTopology, SubdimensionTag >& other )

   {

      operator=( other );

   }
@@ -114,7 +124,7 @@ protected: 
   }



   template< typename Device_ >

   SubentityStorageLayer& operator=( const SubentityStorageLayer< MeshConfig, Device_, EntityTopologyDimensionTag, SubdimensionTag >& other )

   SubentityStorageLayer& operator=( const SubentityStorageLayer< MeshConfig, Device_, EntityTopology, SubdimensionTag >& other )

   {

      BaseType::operator=( other );

      matrix = other.matrix;
@@ -125,7 +135,7 @@ protected: 
   void print( std::ostream& str ) const

   {

      BaseType::print( str );

      str << "Adjacency matrix for subentities with dimension " << SubdimensionTag::value << " of entities with dimension " << EntityTopologyDimensionTag::value << " is: " << std::endl;

      str << "Adjacency matrix for subentities with dimension " << SubdimensionTag::value << " of entities with dimension " << EntityTopology::dimension << " is: " << std::endl;

      str << matrix << std::endl;

   }
@@ -136,11 +146,14 @@ protected: 
   }



protected:

   using BaseType::setSubentitiesCounts;

   void setSubentitiesCounts( SubdimensionTag, const typename MeshTraitsType::NeighborCountsArray& counts )

   {}



   using BaseType::getSubentitiesCount;

   __cuda_callable__

   LocalIndexType getSubentitiesCount( SubdimensionTag ) const

   LocalIndexType getSubentitiesCount( SubdimensionTag, const GlobalIndexType entityIndex ) const

   {

      using EntityTopology = typename MeshTraits< MeshConfig, Device >::template EntityTraits< EntityTopologyDimensionTag::value >::EntityTopology;

      using SubentityTraitsType = typename MeshTraitsType::template SubentityTraits< EntityTopology, SubdimensionTag::value >;

      return SubentityTraitsType::count;

   }
@@ -162,22 +175,135 @@ private: 
   SubentityMatrixType matrix;



   // friend class is needed for templated assignment operators

   template< typename MeshConfig_, typename Device_, typename EntityTopologyDimensionTag_, typename SubdimensionTag_, bool Storage_ >

   template< typename MeshConfig_, typename Device_, typename EntityTopology_, typename SubdimensionTag_, bool Storage_ >

   friend class SubentityStorageLayer;

};



template< typename MeshConfig,

          typename Device,

          typename EntityTopologyDimensionTag,

          typename SubdimensionTag >

class SubentityStorageLayer< MeshConfig,

                             Device,

                             EntityTopologyDimensionTag,

                             Topologies::Polygon,

                             SubdimensionTag,

                             true >

   : public SubentityStorageLayer< MeshConfig, Device, Topologies::Polygon, typename SubdimensionTag::Increment >

{

   using EntityTopology = Topologies::Polygon;

   using BaseType       = SubentityStorageLayer< MeshConfig, Device, EntityTopology, typename SubdimensionTag::Increment >;

   using MeshTraitsType = MeshTraits< MeshConfig, Device >;



protected:

   using GlobalIndexType     = typename MeshTraitsType::GlobalIndexType;

   using LocalIndexType      = typename MeshTraitsType::LocalIndexType;

   using NeighborCountsArray = typename MeshTraitsType::NeighborCountsArray;

   using SubentityMatrixType = typename MeshTraitsType::template SubentityMatrixType< EntityTopology::dimension, SubdimensionTag::value >;



   SubentityStorageLayer() = default;



   explicit SubentityStorageLayer( const SubentityStorageLayer& other )

   {

      operator=( other );

   }



   template< typename Device_ >

   SubentityStorageLayer( const SubentityStorageLayer< MeshConfig, Device_, EntityTopology, SubdimensionTag >& other )

   {

      operator=( other );

   }



   SubentityStorageLayer& operator=( const SubentityStorageLayer& other )

   {

      BaseType::operator=( other );

      subentitiesCounts = other.subentitiesCounts;

      matrix = other.matrix;

      return *this;

   }



   template< typename Device_ >

   SubentityStorageLayer& operator=( const SubentityStorageLayer< MeshConfig, Device_, EntityTopology, SubdimensionTag >& other )

   {

      BaseType::operator=( other );

      subentitiesCounts = other.subentitiesCounts;

      matrix = other.matrix;

      return *this;

   }



   void save( File& file ) const

   {

      BaseType::save( file );

      matrix.save( file );

   }



   void load( File& file )

   {

      BaseType::load( file );

      matrix.load( file );

      matrix.getCompressedRowLengths( subentitiesCounts );

   }



   void print( std::ostream& str ) const

   {

      BaseType::print( str );

      str << "Adjacency matrix for subentities with dimension " << SubdimensionTag::value << " of entities with dimension " << EntityTopology::dimension << " is: " << std::endl;

      str << matrix << std::endl;

   }



   bool operator==( const SubentityStorageLayer& layer ) const

   {

      return ( BaseType::operator==( layer ) &&

               subentitiesCounts == layer.subentitiesCounts &&

               matrix == layer.matrix );

   }



protected:

   using BaseType::setSubentitiesCounts;

   void setSubentitiesCounts( SubdimensionTag, const NeighborCountsArray& counts )

   {

      subentitiesCounts = counts;

   }



   using BaseType::getSubentitiesCount;

   __cuda_callable__

   LocalIndexType getSubentitiesCount( SubdimensionTag, const GlobalIndexType entityIndex ) const

   {

      return subentitiesCounts[ entityIndex ];

   }



   using BaseType::getSubentitiesMatrix;

   __cuda_callable__

   SubentityMatrixType& getSubentitiesMatrix( SubdimensionTag )

   {

      return matrix;

   }



   __cuda_callable__

   const SubentityMatrixType& getSubentitiesMatrix( SubdimensionTag ) const

   {

      return matrix;

   }



private:

   NeighborCountsArray subentitiesCounts;

   SubentityMatrixType matrix;

   

   // friend class is needed for templated assignment operators

   template< typename MeshConfig_, typename Device_, typename EntityTopology_, typename SubdimensionTag_, bool Storage_ >

   friend class SubentityStorageLayer;

};



template< typename MeshConfig,

          typename Device,

          typename EntityTopology,

          typename SubdimensionTag >

class SubentityStorageLayer< MeshConfig,

                             Device,

                             EntityTopology,

                             SubdimensionTag,

                             false >

   : public SubentityStorageLayer< MeshConfig, Device, EntityTopologyDimensionTag, typename SubdimensionTag::Increment >

   : public SubentityStorageLayer< MeshConfig, Device, EntityTopology, typename SubdimensionTag::Increment >

{

   using BaseType = SubentityStorageLayer< MeshConfig, Device, EntityTopologyDimensionTag, typename SubdimensionTag::Increment >;

   using BaseType = SubentityStorageLayer< MeshConfig, Device, EntityTopology, typename SubdimensionTag::Increment >;

public:

   // inherit constructors and assignment operators (including templated versions)

   using BaseType::BaseType;
@@ -187,14 +313,52 @@ public: 
// termination of recursive inheritance (everything is reduced to EntityStorage == false thanks to the WeakSubentityStorageTrait)

template< typename MeshConfig,

          typename Device,

          typename EntityTopologyDimensionTag >

          typename EntityTopology >

class SubentityStorageLayer< MeshConfig,

                             Device,

                             EntityTopology,

                             DimensionTag< EntityTopology::dimension >,

                             false >

{

   using MeshTraitsType = MeshTraits< MeshConfig, Device >;

   using SubdimensionTag = DimensionTag< EntityTopology::dimension >;



protected:

   using GlobalIndexType = typename MeshConfig::GlobalIndexType;



   SubentityStorageLayer() = default;

   explicit SubentityStorageLayer( const SubentityStorageLayer& other ) {}

   template< typename Device_ >

   SubentityStorageLayer( const SubentityStorageLayer< MeshConfig, Device_, EntityTopology, SubdimensionTag >& other ) {}

   template< typename Device_ >

   SubentityStorageLayer& operator=( const SubentityStorageLayer< MeshConfig, Device_, EntityTopology, SubdimensionTag >& other ) { return *this; }



   void print( std::ostream& str ) const {}



   bool operator==( const SubentityStorageLayer& layer ) const

   {

      return true;

   }



   void save( File& file ) const {}

   void load( File& file ) {}



   void setSubentitiesCounts( SubdimensionTag, const typename MeshTraitsType::NeighborCountsArray& );

   void getSubentitiesCount( SubdimensionTag ) {}

   void getSubentitiesMatrix( SubdimensionTag ) {}

};



template< typename MeshConfig,

          typename Device >

class SubentityStorageLayer< MeshConfig,

                             Device,

                             EntityTopologyDimensionTag,

                             DimensionTag< EntityTopologyDimensionTag::value >,

                             Topologies::Polygon,

                             DimensionTag< Topologies::Polygon::dimension >,

                             false >

{

   using SubdimensionTag = EntityTopologyDimensionTag;

   using MeshTraitsType = MeshTraits< MeshConfig, Device >;

   using EntityTopology  = Topologies::Polygon;

   using SubdimensionTag = DimensionTag< EntityTopology::dimension >;



protected:

   using GlobalIndexType = typename MeshConfig::GlobalIndexType;
@@ -202,9 +366,9 @@ protected: 
   SubentityStorageLayer() = default;

   explicit SubentityStorageLayer( const SubentityStorageLayer& other ) {}

   template< typename Device_ >

   SubentityStorageLayer( const SubentityStorageLayer< MeshConfig, Device_, EntityTopologyDimensionTag, SubdimensionTag >& other ) {}

   SubentityStorageLayer( const SubentityStorageLayer< MeshConfig, Device_, EntityTopology, SubdimensionTag >& other ) {}

   template< typename Device_ >

   SubentityStorageLayer& operator=( const SubentityStorageLayer< MeshConfig, Device_, EntityTopologyDimensionTag, SubdimensionTag >& other ) { return *this; }

   SubentityStorageLayer& operator=( const SubentityStorageLayer< MeshConfig, Device_, EntityTopology, SubdimensionTag >& other ) { return *this; }



   void print( std::ostream& str ) const {}
@@ -213,6 +377,7 @@ protected: 
      return true;

   }



   void setSubentitiesCounts( SubdimensionTag, const typename MeshTraitsType::NeighborCountsArray& );

   void getSubentitiesCount( SubdimensionTag ) {}

   void getSubentitiesMatrix( SubdimensionTag ) {}

};

src/TNL/Meshes/MeshDetails/traits/MeshSubentityTraits.h

+27 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
#include <TNL/Containers/StaticArray.h>

#include <TNL/Meshes/MeshDetails/traits/MeshEntityTraits.h>

#include <TNL/Meshes/Topologies/SubentityVertexMap.h>

#include <TNL/Meshes/Topologies/Polygon.h>



namespace TNL {

namespace Meshes {
@@ -42,6 +43,9 @@ public: 
   using SubentityTopology = typename MeshEntityTraits< MeshConfig, Device, Dimension >::EntityTopology;

   using SubentityType     = typename MeshEntityTraits< MeshConfig, Device, Dimension >::EntityType;



   // container for storing the subentity indices

   using SubentityMatrixType = Matrices::SparseMatrix< bool, Device, GlobalIndexType, Matrices::GeneralMatrix, EllpackSegments >;



   template< LocalIndexType subentityIndex,

             LocalIndexType subentityVertexIndex >

   struct Vertex
@@ -54,5 +58,28 @@ public: 
   };

};



// Specialization for Polygons

template< typename MeshConfig,

          typename Device,

          int Dimension >

class MeshSubentityTraits<MeshConfig, Device, Topologies::Polygon, Dimension>

{

   using GlobalIndexType = typename MeshConfig::GlobalIndexType;

   using LocalIndexType  = typename MeshConfig::LocalIndexType;

   using EntityTopology = Topologies::Polygon;



public:

   static_assert( 0 <= Dimension && Dimension <= MeshConfig::meshDimension, "invalid dimension" );

   static_assert( EntityTopology::dimension > Dimension, "Subentity dimension must be smaller than the entity dimension." );



   static constexpr bool storageEnabled = MeshConfig::subentityStorage( EntityTopology::dimension, Dimension );



   using SubentityTopology = typename MeshEntityTraits< MeshConfig, Device, Dimension >::EntityTopology;

   using SubentityType     = typename MeshEntityTraits< MeshConfig, Device, Dimension >::EntityType;



   // container for storing the subentity indices

   using SubentityMatrixType = Matrices::SparseMatrix< bool, Device, GlobalIndexType, Matrices::GeneralMatrix, SlicedEllpackSegments >;

};



} // namespace Meshes

} // namespace TNL