Commit 9bca07db authored by Ján Bobot's avatar Ján Bobot
Browse files

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

parent c3473da6

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 );