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

Refactored the way how entity counts and corners counts are passed into MeshBuilder

parent 34f8d975

src/TNL/Meshes/Geometry/getDecomposedMesh.h

+2 −4
Original line number Diff line number Diff line
@@ -62,8 +62,7 @@ decomposeMesh( const Mesh< MeshConfig, Devices::Host >& inMesh ) 
   const auto& reduceResult = indeces[ inCellsCount ];

   const GlobalIndexType outPointsCount = inPointsCount + reduceResult.first;

   const GlobalIndexType outCellsCount = reduceResult.second;

   meshBuilder.setPointsCount( outPointsCount );

   meshBuilder.setCellsCount( outCellsCount );

   meshBuilder.setEntitiesCount( outPointsCount, outCellsCount );



   // Copy the points from inMesh to outMesh

   auto copyPoint = [&] ( GlobalIndexType i ) mutable {
@@ -164,8 +163,7 @@ decomposeMesh( const Mesh< MeshConfig, Devices::Host >& inMesh ) 
   const auto& reduceResult = indeces[ inCellsCount ];

   const GlobalIndexType outPointsCount = inPointsCount + reduceResult.first;

   const GlobalIndexType outCellsCount = reduceResult.second;

   meshBuilder.setPointsCount( outPointsCount );

   meshBuilder.setCellsCount( outCellsCount );

   meshBuilder.setEntitiesCount( outPointsCount, outCellsCount );



   // Copy the points from inMesh to outMesh

   auto copyPoint = [&] ( GlobalIndexType i ) mutable {

src/TNL/Meshes/Geometry/getPlanarMesh.h

+18 −15
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ planarCorrection( const Mesh< MeshConfig, Devices::Host >& inMesh ) 


   using PolygonMesh = Mesh< MeshConfig, Devices::Host >;

   using MeshBuilder = MeshBuilder< PolygonMesh >;

   using NeighborCountsArray = typename MeshBuilder::NeighborCountsArray;

   using GlobalIndexType = typename PolygonMesh::GlobalIndexType;

   using LocalIndexType = typename PolygonMesh::LocalIndexType;

   using PointType = typename PolygonMesh::PointType;
@@ -66,8 +67,7 @@ planarCorrection( const Mesh< MeshConfig, Devices::Host >& inMesh ) 
   const auto& reduceResult = indeces[ inCellsCount ];

   const GlobalIndexType outPointsCount = inPointsCount + reduceResult.first;

   const GlobalIndexType outCellsCount = reduceResult.second;

   meshBuilder.setPointsCount( outPointsCount );

   meshBuilder.setCellsCount( outCellsCount );

   meshBuilder.setEntitiesCount( outPointsCount, outCellsCount );



   // Copy the points from inMesh to outMesh

   auto copyPoint = [&] ( GlobalIndexType i ) mutable {
@@ -76,6 +76,7 @@ planarCorrection( const Mesh< MeshConfig, Devices::Host >& inMesh ) 
   ParallelFor< Devices::Host >::exec( 0, inPointsCount, copyPoint );



   // set corner counts for cells

   NeighborCountsArray cellCornersCounts( outCellsCount );

   auto setCornersCount = [&] ( GlobalIndexType i ) mutable {

      GlobalIndexType cellIndex = indeces[ i ].second;

      const GlobalIndexType nextCellIndex = indeces[ i + 1 ].second;
@@ -84,16 +85,16 @@ planarCorrection( const Mesh< MeshConfig, Devices::Host >& inMesh ) 
      if( cellsCount == 1 ) { // cell is already planar (cell is copied)

         const auto cell = inMesh.template getEntity< CellDimension >( i );

         const auto verticesCount = cell.template getSubentitiesCount< 0 >();

         meshBuilder.setCellCornersCount( cellIndex, verticesCount );

         cellCornersCounts[ cellIndex ] = verticesCount;

      }

      else { // cell is not planar (cell is decomposed)

         for( ; cellIndex < nextCellIndex; cellIndex++ ) {

            meshBuilder.setCellCornersCount( cellIndex, 3 );

            cellCornersCounts[ cellIndex ] = 3;

         }

      }

   };

   ParallelFor< Devices::Host >::exec( 0, inCellsCount, setCornersCount );

   meshBuilder.initializeCellSeeds();

   meshBuilder.setCellCornersCounts( std::move( cellCornersCounts ) );



   // Decompose non-planar cells and copy the rest

   auto decomposeCell = [&] ( GlobalIndexType i ) mutable {
@@ -147,18 +148,19 @@ planarCorrection( const Mesh< MeshConfig, Devices::Host >& inMesh ) 
   using namespace TNL::Algorithms;



   using PolyhedronMesh = Mesh< MeshConfig, Devices::Host >;

   using MeshBuilder = MeshBuilder< PolyhedronMesh >;

   using NeighborCountsArray = typename MeshBuilder::NeighborCountsArray;

   using GlobalIndexType = typename PolyhedronMesh::GlobalIndexType;

   using LocalIndexType = typename PolyhedronMesh::LocalIndexType;

   using PointType = typename PolyhedronMesh::PointType;

   using RealType = typename PolyhedronMesh::RealType;

   using FaceMapArray = Containers::Array< std::pair< GlobalIndexType, GlobalIndexType >, Devices::Host, GlobalIndexType >;

   using EntityDecomposer = EntityDecomposer< MeshConfig, Topologies::Polygon, DecomposerVersion >;

   constexpr int CellDimension = PolyhedronMesh::getMeshDimension();

   constexpr int FaceDimension = CellDimension - 1;



   constexpr RealType precision{ 1e-6 };



   MeshBuilder< PolyhedronMesh > meshBuilder;

   MeshBuilder meshBuilder;



   const GlobalIndexType inPointsCount = inMesh.template getEntitiesCount< 0 >();

   const GlobalIndexType inFacesCount = inMesh.template getEntitiesCount< FaceDimension >();
@@ -186,9 +188,8 @@ planarCorrection( const Mesh< MeshConfig, Devices::Host >& inMesh ) 
   const auto& reduceResult = indeces[ inFacesCount ];

   const GlobalIndexType outPointsCount = inPointsCount + reduceResult.first;

   const GlobalIndexType outFacesCount = reduceResult.second;

   meshBuilder.setPointsCount( outPointsCount );

   meshBuilder.setFacesCount( outFacesCount );

   meshBuilder.setCellsCount( inCellsCount ); // The number of cells stays the same

   const GlobalIndexType outCellsCount = inCellsCount; // The number of cells stays the same

   meshBuilder.setEntitiesCount( outPointsCount, outCellsCount, outFacesCount );



   // Copy the points from inMesh to outMesh

   auto copyPoint = [&] ( GlobalIndexType i ) mutable {
@@ -197,6 +198,7 @@ planarCorrection( const Mesh< MeshConfig, Devices::Host >& inMesh ) 
   ParallelFor< Devices::Host >::exec( 0, inPointsCount, copyPoint );



   // set corner counts for cells

   NeighborCountsArray cellCornersCounts( outCellsCount );

   auto setCellCornersCount = [&] ( GlobalIndexType i ) mutable {

      const auto cell = inMesh.template getEntity< CellDimension >( i );

      const LocalIndexType cellFacesCount = cell.template getSubentitiesCount< FaceDimension >();
@@ -208,10 +210,10 @@ planarCorrection( const Mesh< MeshConfig, Devices::Host >& inMesh ) 
         cornersCount += indeces[ faceIdx + 1 ].second - indeces[ faceIdx ].second;

      }



      meshBuilder.setCellCornersCount( i, cornersCount );

      cellCornersCounts[ i ] = cornersCount;

   };

   ParallelFor< Devices::Host >::exec( 0, inCellsCount, setCellCornersCount );

   meshBuilder.initializeCellSeeds();

   meshBuilder.setCellCornersCounts( std::move( cellCornersCounts ) );



   // Set corner ids for cells

   auto setCellCornersIds = [&] ( GlobalIndexType i ) mutable {
@@ -229,6 +231,7 @@ planarCorrection( const Mesh< MeshConfig, Devices::Host >& inMesh ) 
   ParallelFor< Devices::Host >::exec( 0, inCellsCount, setCellCornersIds );



   // set corner counts for faces

   NeighborCountsArray faceCornersCounts( outFacesCount );

   auto setFaceCornersCount = [&] ( GlobalIndexType i ) mutable {

      GlobalIndexType faceIndex = indeces[ i ].second;

      const GlobalIndexType nextFaceIndex = indeces[ i + 1 ].second;
@@ -236,16 +239,16 @@ planarCorrection( const Mesh< MeshConfig, Devices::Host >& inMesh ) 
      if( facesCount == 1 ) { // face is already planar (it is copied)

         const auto face = inMesh.template getEntity< FaceDimension >( i );

         const auto verticesCount = face.template getSubentitiesCount< 0 >();

         meshBuilder.setFaceCornersCount( faceIndex, verticesCount );

         faceCornersCounts[ faceIndex ] = verticesCount;

      }

      else { // face is not planar (it is decomposed)

         for( ; faceIndex < nextFaceIndex; faceIndex++ ) {

            meshBuilder.setFaceCornersCount( faceIndex, 3 );

            faceCornersCounts[ faceIndex ] = 3;

         }

      }

   };

   ParallelFor< Devices::Host >::exec( 0, inFacesCount, setFaceCornersCount );

   meshBuilder.initializeFaceSeeds();

   meshBuilder.setFaceCornersCounts( std::move( faceCornersCounts ) );



   // Decompose non-planar faces and copy the rest

   auto decomposeFace = [&] ( GlobalIndexType i ) mutable {

src/TNL/Meshes/MeshBuilder.h

+22 −21
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#pragma once



#include <TNL/Containers/Vector.h>

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



namespace TNL {

namespace Meshes {
@@ -35,45 +36,45 @@ public: 
   using CellSeedType       = typename CellSeedMatrixType::EntitySeedMatrixSeed;

   using FaceSeedMatrixType = typename MeshTraitsType::FaceSeedMatrixType;

   using FaceSeedType       = typename FaceSeedMatrixType::EntitySeedMatrixSeed;

   using NeighborCountsArray = typename MeshTraitsType::NeighborCountsArray;

   

   void setPointsCount( const GlobalIndexType& points )

   void setEntitiesCount( const GlobalIndexType& points, 

                          const GlobalIndexType& cells = 0,

                          const GlobalIndexType& faces = 0 )

   {

      this->points.setSize( points );

      this->pointsSet.setSize( points );

      pointsSet.setValue( false );

   }



   void setFacesCount( const GlobalIndexType& facesCount )

      if( std::is_same< CellTopology, Topologies::Polyhedron >::value )

      {

      this->faceSeeds.setDimensions( facesCount, this->points.getSize() );

         this->faceSeeds.setDimensions( faces, points );

         this->cellSeeds.setDimensions( cells, faces );

      }



   void setFaceCornersCount( const GlobalIndexType& faceIndex, const LocalIndexType& cornersCount )

      else // Topologies other than polyhedrons don't use face seeds

      {

      this->faceSeeds.setEntityCornersCount( faceIndex, cornersCount );

         this->cellSeeds.setDimensions( cells, points );

      }

   }



   void initializeFaceSeeds()

   void setFaceCornersCounts( const NeighborCountsArray& counts )

   {

      this->faceSeeds.initializeRows();

      this->faceSeeds.setEntityCornersCounts( counts );

   }



   void setCellsCount( const GlobalIndexType& cellsCount )

   void setFaceCornersCounts( NeighborCountsArray&& counts )

   {

      if( getFacesCount() == 0 ) // faceSeeds aren't used ( cellSeeds store indeces of points )

         this->cellSeeds.setDimensions( cellsCount, getPointsCount() );

      else // faceSeeds are used ( cellSeeds store indeces of faces )

         this->cellSeeds.setDimensions( cellsCount, getFacesCount() );

      this->faceSeeds.setEntityCornersCounts( std::move( counts ) );

   }



   void setCellCornersCount( const GlobalIndexType& cellIndex, const LocalIndexType& cornersCount )

   void setCellCornersCounts( const NeighborCountsArray& counts )

   {

      this->cellSeeds.setEntityCornersCount( cellIndex, cornersCount );

      this->cellSeeds.setEntityCornersCounts( counts );

   }



   void initializeCellSeeds()

   void setCellCornersCounts( NeighborCountsArray&& counts )

   {

      this->cellSeeds.initializeRows();

      this->cellSeeds.setEntityCornersCounts( std::move( counts ) );

   }



   GlobalIndexType getPointsCount() const

src/TNL/Meshes/MeshDetails/initializer/EntitySeedMatrix.h

+18 −12
Original line number Diff line number Diff line
@@ -104,12 +104,14 @@ class EntitySeedMatrix< MeshConfig, EntityTopology, false > 
      }



      // This method is only here for compatibility with specialization for dynamic entity topologies

      void setEntityCornersCount( const GlobalIndexType& entityIndex, const LocalIndexType& count )

      {}

      void setEntityCornersCounts( const NeighborCountsArray& counts )

      {

      }



      // This method is only here for compatibility with specialization for dynamic entity topologies

      void initializeRows()

      {}

      void setEntityCornersCounts( NeighborCountsArray&& counts )

      {

      }



      void reset()

      {
@@ -244,12 +246,14 @@ class EntitySeedMatrix< MeshConfig, Topologies::Vertex, false > 
      }



      // This method is only here for compatibility with specialization for dynamic entity topologies

      void setEntityCornersCount( const GlobalIndexType& entityIndex, const LocalIndexType& count )

      {}

      void setEntityCornersCounts( const NeighborCountsArray& counts )

      {

      }



      // This method is only here for compatibility with specialization for dynamic entity topologies

      void initializeRows()

      {}

      void setEntityCornersCounts( NeighborCountsArray&& counts )

      {

      }



      void reset()

      {
@@ -387,14 +391,16 @@ class EntitySeedMatrix< MeshConfig, EntityTopology, true > 
         matrix.setDimensions( entitiesCount, pointsCount );

      }



      void setEntityCornersCount( const GlobalIndexType& entityIndex, const LocalIndexType& count )

      void setEntityCornersCounts( const NeighborCountsArray& counts_ )

      {

         counts.setElement( entityIndex, count );

         this->counts = counts_;

         matrix.setRowCapacities( this->counts );

      }



      void initializeRows()

      void setEntityCornersCounts( NeighborCountsArray&& counts_ )

      {

         matrix.setRowCapacities( counts );

         this->counts = std::move( counts_ );

         matrix.setRowCapacities( this->counts );

      }



      void reset()

src/TNL/Meshes/Readers/MeshReader.h

+13 −8
Original line number Diff line number Diff line
@@ -167,14 +167,13 @@ public: 
                                            + "of cells used in the file (" + VTK::getShapeName(cellShape) + ")" );



      using MeshBuilder = MeshBuilder< MeshType >;

      using NeighborCountsArray = typename MeshBuilder::NeighborCountsArray;

      using PointType = typename MeshType::PointType;

      using FaceSeedType = typename MeshBuilder::FaceSeedType;

      using CellSeedType = typename MeshBuilder::CellSeedType;



      MeshBuilder meshBuilder;

      meshBuilder.setPointsCount( NumberOfPoints );

      meshBuilder.setFacesCount( NumberOfFaces );

      meshBuilder.setCellsCount( NumberOfCells );

      meshBuilder.setEntitiesCount( NumberOfPoints, NumberOfCells, NumberOfFaces );

 

      // assign points

      visit( [&meshBuilder](auto&& array) {
@@ -198,14 +197,17 @@ public: 
               using mpark::get;

               const auto& offsets = get< std::decay_t<decltype(connectivity)> >( faceOffsetsArray );

               

               // Set corners counts

               NeighborCountsArray cornersCounts( NumberOfFaces );

               std::size_t offsetStart = 0;

               for( std::size_t i = 0; i < NumberOfFaces; i++ ) {

                  const std::size_t offsetEnd = offsets[ i ];

                  meshBuilder.setFaceCornersCount( i, offsetEnd - offsetStart );

                  cornersCounts[ i ] = offsetEnd - offsetStart;

                  offsetStart = offsetEnd;

               }

               meshBuilder.initializeFaceSeeds();

               meshBuilder.setFaceCornersCounts( std::move( cornersCounts ) );



               // Set corner ids

               offsetStart = 0;

               for( std::size_t i = 0; i < NumberOfFaces; i++ ) {

                  FaceSeedType seed = meshBuilder.getFaceSeed( i );
@@ -224,14 +226,17 @@ public: 
               using mpark::get;

               const auto& offsets = get< std::decay_t<decltype(connectivity)> >( cellOffsetsArray );



               // Set corners counts

               NeighborCountsArray cornersCounts( NumberOfCells );

               std::size_t offsetStart = 0;

               for( std::size_t i = 0; i < NumberOfCells; i++ ) {

                  const std::size_t offsetEnd = offsets[ i ];

                  meshBuilder.setCellCornersCount( i, offsetEnd - offsetStart );

                  cornersCounts[ i ] = offsetEnd - offsetStart;

                  offsetStart = offsetEnd;

               }

               meshBuilder.initializeCellSeeds();

               meshBuilder.setCellCornersCounts( std::move( cornersCounts ) );



               // Set corner ids

               offsetStart = 0;

               for( std::size_t i = 0; i < NumberOfCells; i++ ) {

                  CellSeedType seed = meshBuilder.getCellSeed( i );