Commit 6b5a96a6 authored by Jakub Klinkovský's avatar Jakub Klinkovský
Browse files

Refactored detail sub-namespace for mesh writers

parent a80a4912

src/TNL/Meshes/Writers/VTKWriter.h

+0 −13
Original line number Diff line number Diff line
@@ -19,13 +19,6 @@ namespace Meshes { 
//! \brief Namespace for mesh writers.

namespace Writers {



namespace details {



template< typename Mesh, int EntityDimension > struct MeshEntitiesVTKWriter;

template< typename Mesh, int EntityDimension > struct MeshEntityTypesVTKWriter;



} // namespace details



template< typename Mesh >

class VTKWriter

{
@@ -33,12 +26,6 @@ class VTKWriter 
   // TODO: check also space dimension when grids allow it

//   static_assert( Mesh::getSpaceDimension() <= 3, "The VTK format supports only 1D, 2D and 3D meshes." );



   template< int EntityDimension >

   using EntitiesWriter = details::MeshEntitiesVTKWriter< Mesh, EntityDimension >;



   template< int EntityDimension >

   using EntityTypesWriter = details::MeshEntityTypesVTKWriter< Mesh, EntityDimension >;



public:



   VTKWriter() = delete;

src/TNL/Meshes/Writers/VTKWriter.hpp

+9 −394
Original line number Diff line number Diff line
@@ -13,399 +13,14 @@ 
#include <limits>



#include <TNL/Meshes/Writers/VTKWriter.h>

#include <TNL/Meshes/Writers/VerticesPerEntity.h>

#include <TNL/Meshes/Writers/EntitiesListSize.h>

#include <TNL/Meshes/Writers/detail/VTKEntitiesListSize.h>

#include <TNL/Meshes/Writers/detail/VTKMeshEntitiesWriter.h>

#include <TNL/Meshes/Grid.h>

#include <TNL/Endianness.h>



namespace TNL {

namespace Meshes {

namespace Writers {



namespace details {



// legacy VTK files do not support 64-bit integers, even in the BINARY format

inline void

writeInt( VTK::FileFormat format, std::ostream& str, std::int32_t value )

{

   if( format == VTK::FileFormat::binary ) {

      value = forceBigEndian( value );

      str.write( reinterpret_cast<const char*>(&value), sizeof(std::int32_t) );

   }

   else {

      str << value << " ";

   }

}



template< typename Real >

void

writeReal( VTK::FileFormat format, std::ostream& str, Real value )

{

   if( format == VTK::FileFormat::binary ) {

      value = forceBigEndian( value );

      str.write( reinterpret_cast<const char*>(&value), sizeof(Real) );

   }

   else {

      str.precision( std::numeric_limits< Real >::digits10 );

      str << value << " ";

   }

}





// TODO: specialization for disabled entities

// Unstructured meshes, entities

template< typename Mesh, int EntityDimension >

struct MeshEntitiesVTKWriter

{

   static void exec( const Mesh& mesh, std::ostream& str, VTK::FileFormat format )

   {

      using EntityType = typename Mesh::template EntityType< EntityDimension >;

      using Index = typename Mesh::GlobalIndexType;



      const Index entitiesCount = mesh.template getEntitiesCount< EntityType >();

      for( Index i = 0; i < entitiesCount; i++ ) {

         const auto& entity = mesh.template getEntity< EntityType >( i );

         const int verticesPerEntity = entity.template getSubentitiesCount< 0 >();

         writeInt( format, str, verticesPerEntity );

         for( int j = 0; j < verticesPerEntity; j++ )

            writeInt( format, str, entity.template getSubentityIndex< 0 >( j ) );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



// Unstructured meshes, vertices

template< typename Mesh >

struct MeshEntitiesVTKWriter< Mesh, 0 >

{

   static void exec( const Mesh& mesh, std::ostream& str, VTK::FileFormat format )

   {

      using EntityType = typename Mesh::template EntityType< 0 >;

      using Index = typename Mesh::GlobalIndexType;



      const Index entitiesCount = mesh.template getEntitiesCount< EntityType >();

      const int verticesPerEntity = 1;

      for( Index i = 0; i < entitiesCount; i++ )

      {

         writeInt( format, str, verticesPerEntity );

         writeInt( format, str, i );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



// 1D grids, cells

template< typename MeshReal,

          typename Device,

          typename MeshIndex >

struct MeshEntitiesVTKWriter< Meshes::Grid< 1, MeshReal, Device, MeshIndex >, 1 >

{

   using MeshType = Meshes::Grid< 1, MeshReal, Device, MeshIndex >;



   static void exec( const MeshType& mesh, std::ostream& str, VTK::FileFormat format )

   {

      for( MeshIndex i = 0; i < mesh.getDimensions().x(); i++ )

      {

         writeInt( format, str, 2 );

         writeInt( format, str, i );

         writeInt( format, str, i+1 );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



// 1D grids, vertices

template< typename MeshReal,

          typename Device,

          typename MeshIndex >

struct MeshEntitiesVTKWriter< Meshes::Grid< 1, MeshReal, Device, MeshIndex >, 0 >

{

   using MeshType = Meshes::Grid< 1, MeshReal, Device, MeshIndex >;



   static void exec( const MeshType& mesh, std::ostream& str, VTK::FileFormat format )

   {

      for( MeshIndex i = 0; i < mesh.getDimensions().x() + 1; i++ )

      {

         writeInt( format, str, 1 );

         writeInt( format, str, i );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



// 2D grids, cells

template< typename MeshReal,

          typename Device,

          typename MeshIndex >

struct MeshEntitiesVTKWriter< Meshes::Grid< 2, MeshReal, Device, MeshIndex >, 2 >

{

   using MeshType = Meshes::Grid< 2, MeshReal, Device, MeshIndex >;



   static void exec( const MeshType& mesh, std::ostream& str, VTK::FileFormat format )

   {

      for( MeshIndex j = 0; j < mesh.getDimensions().y(); j++ )

      for( MeshIndex i = 0; i < mesh.getDimensions().x(); i++ )

      {

         writeInt( format, str, 4 );

         writeInt( format, str, j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, j * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         writeInt( format, str, (j+1) * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, (j+1) * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



// 2D grids, faces

template< typename MeshReal,

          typename Device,

          typename MeshIndex >

struct MeshEntitiesVTKWriter< Meshes::Grid< 2, MeshReal, Device, MeshIndex >, 1 >

{

   using MeshType = Meshes::Grid< 2, MeshReal, Device, MeshIndex >;



   static void exec( const MeshType& mesh, std::ostream& str, VTK::FileFormat format )

   {

      for( MeshIndex j = 0; j < mesh.getDimensions().y(); j++ )

      for( MeshIndex i = 0; i < ( mesh.getDimensions().x() + 1 ); i++ )

      {

         writeInt( format, str, 2 );

         writeInt( format, str, j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, (j+1) * ( mesh.getDimensions().x() + 1 ) + i );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }



      for( MeshIndex j = 0; j < (mesh.getDimensions().y()+1); j++ )

      for( MeshIndex i = 0; i < mesh.getDimensions().x(); i++ )

      {

         writeInt( format, str, 2 );

         writeInt( format, str, j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, j * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



// 2D grids, vertices

template< typename MeshReal,

          typename Device,

          typename MeshIndex >

struct MeshEntitiesVTKWriter< Meshes::Grid< 2, MeshReal, Device, MeshIndex >, 0 >

{

   using MeshType = Meshes::Grid< 2, MeshReal, Device, MeshIndex >;



   static void exec( const MeshType& mesh, std::ostream& str, VTK::FileFormat format )

   {

      for( MeshIndex j = 0; j < ( mesh.getDimensions().y() + 1 ); j++ )

      for( MeshIndex i = 0; i < ( mesh.getDimensions().x() + 1 ); i++ )

      {

         writeInt( format, str, 1 );

         writeInt( format, str, j * mesh.getDimensions().x() + i );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



// 3D grids, cells

template< typename MeshReal,

          typename Device,

          typename MeshIndex >

struct MeshEntitiesVTKWriter< Meshes::Grid< 3, MeshReal, Device, MeshIndex >, 3 >

{

   using MeshType = Meshes::Grid< 3, MeshReal, Device, MeshIndex >;



   static void exec( const MeshType& mesh, std::ostream& str, VTK::FileFormat format )

   {

      for( MeshIndex k = 0; k < mesh.getDimensions().z(); k++ )

      for( MeshIndex j = 0; j < mesh.getDimensions().y(); j++ )

      for( MeshIndex i = 0; i < mesh.getDimensions().x(); i++ )

      {

         writeInt( format, str, 8 );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + (j+1) * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + (j+1) * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         writeInt( format, str, (k+1) * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, (k+1) * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         writeInt( format, str, (k+1) * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + (j+1) * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, (k+1) * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + (j+1) * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



// 3D grids, faces

template< typename MeshReal,

          typename Device,

          typename MeshIndex >

struct MeshEntitiesVTKWriter< Meshes::Grid< 3, MeshReal, Device, MeshIndex >, 2 >

{

   using MeshType = Meshes::Grid< 3, MeshReal, Device, MeshIndex >;



   static void exec( const MeshType& mesh, std::ostream& str, VTK::FileFormat format )

   {

      for( MeshIndex k = 0; k < mesh.getDimensions().z(); k++ )

      for( MeshIndex j = 0; j < mesh.getDimensions().y(); j++ )

      for( MeshIndex i = 0; i <= mesh.getDimensions().x(); i++ )

      {

         writeInt( format, str, 4 );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + (j+1) * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, (k+1) * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, (k+1) * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + (j+1) * ( mesh.getDimensions().x() + 1 ) + i );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }



      for( MeshIndex k = 0; k < mesh.getDimensions().z(); k++ )

      for( MeshIndex j = 0; j <= mesh.getDimensions().y(); j++ )

      for( MeshIndex i = 0; i < mesh.getDimensions().x(); i++ )

      {

         writeInt( format, str, 4 );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         writeInt( format, str, (k+1) * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, (k+1) * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }



      for( MeshIndex k = 0; k <= mesh.getDimensions().z(); k++ )

      for( MeshIndex j = 0; j < mesh.getDimensions().y(); j++ )

      for( MeshIndex i = 0; i < mesh.getDimensions().x(); i++ )

      {

         writeInt( format, str, 4 );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + (j+1) * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + (j+1) * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



// 3D grids, edges

template< typename MeshReal,

          typename Device,

          typename MeshIndex >

struct MeshEntitiesVTKWriter< Meshes::Grid< 3, MeshReal, Device, MeshIndex >, 1 >

{

   using MeshType = Meshes::Grid< 3, MeshReal, Device, MeshIndex >;



   static void exec( const MeshType& mesh, std::ostream& str, VTK::FileFormat format )

   {

      for( MeshIndex k = 0; k <= mesh.getDimensions().z(); k++ )

      for( MeshIndex j = 0; j <= mesh.getDimensions().y(); j++ )

      for( MeshIndex i = 0; i < mesh.getDimensions().x(); i++ )

      {

         writeInt( format, str, 2 );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i + 1 );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }



      for( MeshIndex k = 0; k <= mesh.getDimensions().z(); k++ )

      for( MeshIndex j = 0; j < mesh.getDimensions().y(); j++ )

      for( MeshIndex i = 0; i <= mesh.getDimensions().x(); i++ )

      {

         writeInt( format, str, 2 );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + (j+1) * ( mesh.getDimensions().x() + 1 ) + i );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }



      for( MeshIndex k = 0; k < mesh.getDimensions().z(); k++ )

      for( MeshIndex j = 0; j <= mesh.getDimensions().y(); j++ )

      for( MeshIndex i = 0; i <= mesh.getDimensions().x(); i++ )

      {

         writeInt( format, str, 2 );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         writeInt( format, str, (k+1) * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



// 3D grids, vertices

template< typename MeshReal,

          typename Device,

          typename MeshIndex >

struct MeshEntitiesVTKWriter< Meshes::Grid< 3, MeshReal, Device, MeshIndex >, 0 >

{

   using MeshType = Meshes::Grid< 3, MeshReal, Device, MeshIndex >;



   static void exec( const MeshType& mesh, std::ostream& str, VTK::FileFormat format )

   {

      for( MeshIndex k = 0; k < ( mesh.getDimensions().z() + 1 ); k++ )

      for( MeshIndex j = 0; j < ( mesh.getDimensions().y() + 1 ); j++ )

      for( MeshIndex i = 0; i < ( mesh.getDimensions().x() + 1 ); i++ )

      {

         writeInt( format, str, 1 );

         writeInt( format, str, k * ( mesh.getDimensions().y() + 1 ) * ( mesh.getDimensions().x() + 1 ) + j * ( mesh.getDimensions().x() + 1 ) + i );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};





// TODO: specialization for disabled entities

template< typename Mesh, int EntityDimension >

struct MeshEntityTypesVTKWriter

{

   static void exec( const Mesh& mesh, std::ostream& str, VTK::FileFormat format )

   {

      using EntityType = typename Mesh::template EntityType< EntityDimension >;

      using Index = typename Mesh::GlobalIndexType;



      const Index entitiesCount = mesh.template getEntitiesCount< EntityType >();

      for( Index i = 0; i < entitiesCount; i++ ) {

         const int type = (int) VTK::TopologyToEntityShape< typename EntityType::EntityTopology >::shape;

         writeInt( format, str, type );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



template< int Dimension,

          typename MeshReal,

          typename Device,

          typename MeshIndex,

          int EntityDimension >

struct MeshEntityTypesVTKWriter< Grid< Dimension, MeshReal, Device, MeshIndex >, EntityDimension >

{

   using MeshType = Grid< Dimension, MeshReal, Device, MeshIndex >;



   static void exec( const MeshType& mesh, std::ostream& str, VTK::FileFormat format )

   {

      using EntityType = typename MeshType::template EntityType< EntityDimension >;



      const MeshIndex entitiesCount = mesh.template getEntitiesCount< EntityType >();

      for( MeshIndex i = 0; i < entitiesCount; i++ ) {

         const int type = (int) VTK::GridEntityShape< EntityType >::shape;

         writeInt( format, str, type );

         if( format == VTK::FileFormat::ascii )

            str << "\n";

      }

   }

};



} // namespace details



template< typename Mesh >

void

VTKWriter< Mesh >::writeMetadata( int cycle, double time )
@@ -422,12 +37,12 @@ VTKWriter< Mesh >::writeMetadata( int cycle, double time ) 
      str << "FIELD FieldData " << n_metadata << "\n";

   if( cycle >= 0 ) {

      str << "CYCLE 1 1 int\n";

      details::writeInt( format, str, cycle );

      detail::writeInt( format, str, cycle );

      str << "\n";

   }

   if( time >= 0 ) {

      str << "TIME 1 1 double\n";

      details::writeReal( format, str, time );

      detail::writeReal( format, str, time );

      str << "\n";

   }

}
@@ -443,13 +58,13 @@ VTKWriter< Mesh >::writeEntities( const Mesh& mesh ) 


   using EntityType = typename Mesh::template EntityType< EntityDimension >;

   cellsCount = mesh.template getEntitiesCount< EntityType >();

   const std::uint64_t cellsListSize = EntitiesListSize< Mesh, EntityDimension >::getSize( mesh );

   const std::uint64_t cellsListSize = detail::VTKEntitiesListSize< Mesh, EntityDimension >::getSize( mesh );



   str << std::endl << "CELLS " << cellsCount << " " << cellsListSize << std::endl;

   EntitiesWriter< EntityDimension >::exec( mesh, str, format );

   detail::VTKMeshEntitiesWriter< Mesh, EntityDimension >::exec( mesh, str, format );



   str << std::endl << "CELL_TYPES " << cellsCount << std::endl;

   EntityTypesWriter< EntityDimension >::exec( mesh, str, format );

   detail::VTKMeshEntityTypesWriter< Mesh, EntityDimension >::exec( mesh, str, format );

}



template< typename Mesh >
@@ -529,7 +144,7 @@ VTKWriter< Mesh >::writeDataArray( const Array& array, 
      str << "VECTORS " << name << " " << getType< typename Array::ValueType >() << " 1" << std::endl;

   }



   using Meshes::Writers::details::writeReal;

   using detail::writeReal;

   for( typename Array::IndexType i = 0; i < array.getSize(); i++ ) {

      writeReal( format, str, array[i] );

      if( format == VTK::FileFormat::ascii )
@@ -541,7 +156,7 @@ template< typename Mesh > 
void

VTKWriter< Mesh >::writePoints( const Mesh& mesh )

{

   using details::writeReal;

   using detail::writeReal;

   pointsCount = mesh.template getEntitiesCount< typename Mesh::Vertex >();

   str << "POINTS " << pointsCount << " " << getType< typename Mesh::RealType >() << std::endl;

   for( std::uint64_t i = 0; i < pointsCount; i++ ) {

src/TNL/Meshes/Writers/VTUWriter.h

+0 −9
Original line number Diff line number Diff line
@@ -20,12 +20,6 @@ namespace TNL { 
namespace Meshes {

namespace Writers {



namespace details {



template< typename Mesh, int EntityDimension > struct MeshEntitiesVTUCollector;



} // namespace details



template< typename Mesh >

class VTUWriter

{
@@ -33,9 +27,6 @@ class VTUWriter 
   // TODO: check also space dimension when grids allow it

//   static_assert( Mesh::getSpaceDimension() <= 3, "The VTK format supports only 1D, 2D and 3D meshes." );



   template< int EntityDimension >

   using EntitiesCollector = details::MeshEntitiesVTUCollector< Mesh, EntityDimension >;



   using HeaderType = std::uint64_t;

public:

src/TNL/Meshes/Writers/VTUWriter.hpp

+5 −398

File changed.

Preview size limit exceeded, changes collapsed.

src/TNL/Meshes/Writers/EntitiesListSize.h→src/TNL/Meshes/Writers/detail/VTKEntitiesListSize.h

+10 −9
Original line number Diff line number Diff line 
#pragma once



#include <TNL/Meshes/Writers/VerticesPerEntity.h>

#include <TNL/Meshes/Writers/detail/VerticesPerEntity.h>



namespace TNL {

namespace Meshes {

namespace Writers {

namespace detail {



template< typename Mesh,

          int EntityDimension,

          typename EntityType = typename Mesh::template EntityType< EntityDimension > 

        >

struct EntitiesListSize

          typename EntityType = typename Mesh::template EntityType< EntityDimension > >

struct VTKEntitiesListSize

{

   using IndexType = typename Mesh::GlobalIndexType;



   static IndexType getSize( const Mesh& mesh )

   {

      IndexType entitiesCount = mesh.template getEntitiesCount< EntityType >();

      IndexType verticesPerEntity = VerticesPerEntity< EntityType >::count;

      const IndexType entitiesCount = mesh.template getEntitiesCount< EntityType >();

      const IndexType verticesPerEntity = VerticesPerEntity< EntityType >::count;

      return entitiesCount * ( verticesPerEntity + 1 );

   }

};
@@ -26,13 +26,13 @@ template< typename Mesh, 
          int EntityDimension,

          typename MeshConfig,

          typename Device >

struct EntitiesListSize< Mesh, EntityDimension, MeshEntity< MeshConfig, Device, Topologies::Polygon > >

struct VTKEntitiesListSize< Mesh, EntityDimension, MeshEntity< MeshConfig, Device, Topologies::Polygon > >

{

   using IndexType = typename Mesh::GlobalIndexType;



   static IndexType getSize( const Mesh& mesh )

   {

      IndexType entitiesCount = mesh.template getEntitiesCount< EntityDimension >();

      const IndexType entitiesCount = mesh.template getEntitiesCount< EntityDimension >();

      IndexType entitiesListSize = entitiesCount;

      for(IndexType index = 0; index < entitiesCount; index++)

         entitiesListSize += mesh.template getSubentitiesCount< EntityDimension, 0 >( index );
@@ -40,6 +40,7 @@ struct EntitiesListSize< Mesh, EntityDimension, MeshEntity< MeshConfig, Device, 
   }

};



} // namespace detail

} // namespace Writers

} // namespace Meshes

} // namespace TNL