Commit a1f8dd04 authored by Vít Hanousek's avatar Vít Hanousek Committed by Jakub Klinkovský
Browse files

issue #15 - Between commit 

   -rename directions to ZvYvXv, where v is m,z,p
   -correct y direction in 2D
parent 9402d6cd

src/TNL/Meshes/DistributedMeshes/Directions.h

+27 −10
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ namespace DistributedMeshes { 
//  -> 0 - not used, 1 negative direction, 2 positive direction

//finaly we subtrackt 1 because we dont need (0,0,0) aka 0 aka no direction



enum Directions2D { Left = 0 , Right = 1 , Up = 2, UpLeft =3, UpRight=4, Down=5, DownLeft=6, DownRight=7 }; 

//enum Directions2D { Left = 0 , Right = 1 , Up = 2, UpLeft =3, UpRight=4, Down=5, DownLeft=6, DownRight=7 }; 



/*MEH - osa zed je zdola nahoru, asi---

enum Directions3D { West = 0 , East = 1 ,
@@ -28,16 +28,33 @@ enum Directions3D { West = 0 , East = 1 , 
                    BottomSouth = 23, BottomSouthWest = 24, BottomSouthEast = 25,

                  };*/



enum Directions3D { West = 0 , East = 1 , 

                    North = 2, NorthWest = 3, NorthEast = 4,

                    South = 5, SouthWest = 6, SouthEast = 7,

                    Bottom = 8 ,BottomWest = 9 , BottomEast = 10 , 

                    BottomNorth = 11, BottomNorthWest = 12, BottomNorthEast = 13,

                    BottomSouth = 14, BottomSouthWest = 15, BottomSouthEast = 16,

                    Top = 17, TopWest = 18, TopEast =19,

                    TopNorth = 20, TopNorthWest = 21, TopNorthEast = 22,

                    TopSouth = 23, TopSouthWest = 24,TopSouthEast = 25,

/*

with self

enum Directions3D { 

                    ZzYzXz =  0, ZzYzXm =  1, ZzYzXp =  2, 

                    ZzYmXz =  3, ZzYmXm =  4, ZzYmXp =  5,

                    ZzYpXz =  6, ZzYpXm =  7, ZzYpXp =  8,                    

                    ZmYzXz =  9, ZmYzXm = 10, ZmYzXp = 11, 

                    ZmYmXz = 12, ZmYmXm = 13, ZmYmXp = 14,

                    ZmYpXz = 15, ZmYpXm = 16, ZmYpXp = 17,

                    ZpYzXz = 18, ZpYzXm = 19, ZpYzXp = 20, 

                    ZpYmXz = 21, ZpYmXm = 22, ZpYmXp = 23,

                    ZpYpXz = 24, ZpYpXm = 25, ZpYpXp = 26

                  };

*/



enum Directions3D { 

                    ZzYzXm =  0, ZzYzXp =  1, 

                    ZzYmXz =  2, ZzYmXm =  3, ZzYmXp =  4,

                    ZzYpXz =  5, ZzYpXm =  6, ZzYpXp =  7,                    

                    ZmYzXz =  8, ZmYzXm =  9, ZmYzXp = 10, 

                    ZmYmXz = 11, ZmYmXm = 12, ZmYmXp = 13,

                    ZmYpXz = 14, ZmYpXm = 15, ZmYpXp = 16,

                    ZpYzXz = 17, ZpYzXm = 18, ZpYzXp = 19, 

                    ZpYmXz = 20, ZpYmXm = 21, ZpYmXp = 22,

                    ZpYpXz = 23, ZpYpXm = 24, ZpYpXp = 25

                  };





class Directions {

src/TNL/Meshes/DistributedMeshes/DistributedGridSynchronizer_1D.h

+28 −28
Original line number Diff line number Diff line
@@ -68,10 +68,10 @@ class DistributedMeshSynchronizer< Functions::MeshFunction< Grid< 1, GridReal, D 
         const CoordinatesType& localGridSize = this->distributedGrid->getLocalGridSize();

         



         sendBuffers[ Left ].setSize( lowerOverlap.x() );

         sendBuffers[ Right ].setSize( upperOverlap.x() );

         receiveBuffers[ Left ].setSize( lowerOverlap.x() );

         receiveBuffers[ Right ].setSize( upperOverlap.x() );         

         sendBuffers[ ZzYzXm ].setSize( lowerOverlap.x() );

         sendBuffers[ ZzYzXp ].setSize( upperOverlap.x() );

         receiveBuffers[ ZzYzXm ].setSize( lowerOverlap.x() );

         receiveBuffers[ ZzYzXp ].setSize( upperOverlap.x() );         



      };
@@ -102,9 +102,9 @@ class DistributedMeshSynchronizer< Functions::MeshFunction< Grid< 1, GridReal, D 
         

         if( periodicBoundaries )

         {

            if( neighbors[ Left ] == -1 )

            if( neighbors[ ZzYzXm ] == -1 )

               swap( leftSource, leftDestination );

            if( neighbors[ Right ] == -1 )

            if( neighbors[ ZzYzXp ] == -1 )

               swap( rightSource, rightDestination );

         }
@@ -122,34 +122,34 @@ class DistributedMeshSynchronizer< Functions::MeshFunction< Grid< 1, GridReal, D 
         int requestsCount( 0 );

         

         //send everything, recieve everything 

         if( neighbors[ Left ] != -1 )

         if( neighbors[ ZzYzXm ] != -1 )

         {

            TNL_ASSERT_GE( sendBuffers[ Left ].getSize(), lowerOverlap.x(), "" );

            TNL_ASSERT_GE( receiveBuffers[ Left ].getSize(), lowerOverlap.x(), "" );

            requests[ requestsCount++ ] = CommunicatorType::ISend( sendBuffers[ Left ].getData(), lowerOverlap.x(), neighbors[ Left ], 0, group );

            requests[ requestsCount++ ] = CommunicatorType::IRecv( receiveBuffers[ Left ].getData(), lowerOverlap.x(), neighbors[ Left ], 0, group );

            TNL_ASSERT_GE( sendBuffers[ ZzYzXm ].getSize(), lowerOverlap.x(), "" );

            TNL_ASSERT_GE( receiveBuffers[ ZzYzXm ].getSize(), lowerOverlap.x(), "" );

            requests[ requestsCount++ ] = CommunicatorType::ISend( sendBuffers[ ZzYzXm ].getData(), lowerOverlap.x(), neighbors[ ZzYzXm ],0, group );

            requests[ requestsCount++ ] = CommunicatorType::IRecv( receiveBuffers[ ZzYzXm ].getData(), lowerOverlap.x(), neighbors[ ZzYzXm ],0, group );

         }

         else if( periodicBoundaries )

         {

            TNL_ASSERT_GE( sendBuffers[ Left ].getSize(), lowerOverlap.x(), "" );

            TNL_ASSERT_GE( receiveBuffers[ Left ].getSize(), lowerOverlap.x(), "" );            

            requests[ requestsCount++ ] = CommunicatorType::ISend( sendBuffers[ Left ].getData(), lowerOverlap.x(), periodicNeighbors[ Left ], 1, group );

            requests[ requestsCount++ ] = CommunicatorType::IRecv( receiveBuffers[ Left ].getData(), lowerOverlap.x(), periodicNeighbors[ Left ], 1, group );

            TNL_ASSERT_GE( sendBuffers[ ZzYzXm ].getSize(), lowerOverlap.x(), "" );

            TNL_ASSERT_GE( receiveBuffers[ ZzYzXm ].getSize(), lowerOverlap.x(), "" );            

            requests[ requestsCount++ ] = CommunicatorType::ISend( sendBuffers[ ZzYzXm ].getData(), lowerOverlap.x(), periodicNeighbors[ ZzYzXm ],1, group );

            requests[ requestsCount++ ] = CommunicatorType::IRecv( receiveBuffers[ ZzYzXm ].getData(), lowerOverlap.x(), periodicNeighbors[ ZzYzXm ],1, group );

         }        



         if( neighbors[ Right ] != -1 )

         if( neighbors[ ZzYzXp ] != -1 )

         {

            TNL_ASSERT_GE( sendBuffers[ Right ].getSize(), upperOverlap.x(), "" );

            TNL_ASSERT_GE( receiveBuffers[ Right ].getSize(), upperOverlap.x(), "" );

            requests[ requestsCount++ ] = CommunicatorType::ISend( sendBuffers[ Right ].getData(), upperOverlap.x(), neighbors[ Right ], 0, group );

            requests[ requestsCount++ ] = CommunicatorType::IRecv( receiveBuffers[ Right ].getData(), upperOverlap.x(), neighbors[ Right ], 0, group );

            TNL_ASSERT_GE( sendBuffers[ ZzYzXp ].getSize(), upperOverlap.x(), "" );

            TNL_ASSERT_GE( receiveBuffers[ ZzYzXp ].getSize(), upperOverlap.x(), "" );

            requests[ requestsCount++ ] = CommunicatorType::ISend( sendBuffers[ ZzYzXp ].getData(), upperOverlap.x(), neighbors[ ZzYzXp ], 0, group );

            requests[ requestsCount++ ] = CommunicatorType::IRecv( receiveBuffers[ ZzYzXp ].getData(), upperOverlap.x(), neighbors[ ZzYzXp ], 0, group );

         }

         else if( periodicBoundaries )

         {

            TNL_ASSERT_GE( sendBuffers[ Right ].getSize(), upperOverlap.x(), "" );

            TNL_ASSERT_GE( receiveBuffers[ Right ].getSize(), upperOverlap.x(), "" );

            requests[ requestsCount++ ] = CommunicatorType::ISend( sendBuffers[ Right ].getData(), upperOverlap.x(), periodicNeighbors[ Right ], 1, group );

            requests[ requestsCount++ ] = CommunicatorType::IRecv( receiveBuffers[ Right ].getData(), upperOverlap.x(), periodicNeighbors[ Right ], 1, group );

            TNL_ASSERT_GE( sendBuffers[ ZzYzXp ].getSize(), upperOverlap.x(), "" );

            TNL_ASSERT_GE( receiveBuffers[ ZzYzXp ].getSize(), upperOverlap.x(), "" );

            requests[ requestsCount++ ] = CommunicatorType::ISend( sendBuffers[ ZzYzXp ].getData(), upperOverlap.x(), periodicNeighbors[ ZzYzXp ], 1, group );

            requests[ requestsCount++ ] = CommunicatorType::IRecv( receiveBuffers[ ZzYzXp ].getData(), upperOverlap.x(), periodicNeighbors[ ZzYzXp ], 1, group );

         }

         

         //wait until send and receive is done
@@ -181,12 +181,12 @@ class DistributedMeshSynchronizer< Functions::MeshFunction< Grid< 1, GridReal, D 
      

      {

         typedef BufferEntitiesHelper< MeshFunctionType, PeriodicBoundariesMaskPointer, 1, Real_, Device > Helper;

         bool leftIsBoundary = ( neighbors[ Left ] == -1 );

         bool rightIsBoundary = ( neighbors[ Right ] == -1 );

         bool leftIsBoundary = ( neighbors[ ZzYzXm ] == -1 );

         bool rightIsBoundary = ( neighbors[ ZzYzXp ] == -1 );

         if( ! leftIsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ Left ].getData(), leftIsBoundary, left, lowerOverlap.x(), toBuffer );

            Helper::BufferEntities( meshFunction, mask, buffers[ ZzYzXm ].getData(), leftIsBoundary, left, lowerOverlap.x(), toBuffer );

         if( ! rightIsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ Right ].getData(), rightIsBoundary, right, upperOverlap.x(), toBuffer );

            Helper::BufferEntities( meshFunction, mask, buffers[ ZzYzXp ].getData(), rightIsBoundary, right, upperOverlap.x(), toBuffer );

      }



      Containers::Array<RealType, Device> sendBuffers[ 2 ], receiveBuffers[ 2 ];

src/TNL/Meshes/DistributedMeshes/DistributedGridSynchronizer_2D.h

+59 −61
Original line number Diff line number Diff line
@@ -68,15 +68,14 @@ class DistributedMeshSynchronizer< Functions::MeshFunction< Grid< 2, GridReal, D 
         const CoordinatesType& localSize = distributedGrid->getLocalSize(); 

         const CoordinatesType& localGridSize = this->distributedGrid->getLocalGridSize();

         

         // TODO: SWAP up and down

         sizes[ Left ]      = localSize.y()    * lowerOverlap.x();

         sizes[ Right ]     = localSize.y()    * upperOverlap.x();

         sizes[ Up ]        = localSize.x()    * lowerOverlap.y();

         sizes[ Down ]      = localSize.x()    * upperOverlap.y();

         sizes[ UpLeft ]    = lowerOverlap.x() * lowerOverlap.y();

         sizes[ DownLeft ]  = lowerOverlap.x() * upperOverlap.y();

         sizes[ UpRight ]   = upperOverlap.x() * lowerOverlap.y();

         sizes[ DownRight ] = upperOverlap.x() * upperOverlap.y();

         sizes[ ZzYzXm ]      = localSize.y()    * lowerOverlap.x();

         sizes[ ZzYzXp ]     = localSize.y()    * upperOverlap.x();

         sizes[ ZzYmXz ]        = localSize.x()    * lowerOverlap.y();

         sizes[ ZzYpXz ]      = localSize.x()    * upperOverlap.y();

         sizes[ ZzYmXm ]    = lowerOverlap.x() * lowerOverlap.y();

         sizes[ ZzYpXm ]  = lowerOverlap.x() * upperOverlap.y();

         sizes[ ZzYmXp ]   = upperOverlap.x() * lowerOverlap.y();

         sizes[ ZzYpXp ] = upperOverlap.x() * upperOverlap.y();

          

         for(int i=0;i<8;i++)

         {
@@ -104,36 +103,36 @@ class DistributedMeshSynchronizer< Functions::MeshFunction< Grid< 2, GridReal, D 
         const CoordinatesType& localSize = distributedGrid->getLocalSize();

         const CoordinatesType& localGridSize = this->distributedGrid->getLocalGridSize();

         

         leftSource  = lowerOverlap.x();

         rightSource = localGridSize.x() - 2 * upperOverlap.x();

         upSource    = lowerOverlap.y();                             // TODO: SWAP up and down

         downSource  = localGridSize.y() - 2 * upperOverlap.y();     // TODO: SWAP up and down

         ZzYzXm_Source  = lowerOverlap.x();

         ZzYzXp_Source = localGridSize.x() - 2 * upperOverlap.x();

         ZzYmXz_Source    = lowerOverlap.y();                             

         ZzYpXz_Source  = localGridSize.y() - 2 * upperOverlap.y();     



         xCenter  = lowerOverlap.x();

         yCenter  = lowerOverlap.y();



         leftDestination  = 0;

         rightDestination = localGridSize.x() - upperOverlap.x();

         upDestination    = 0;

         downDestination  = localGridSize.y() - upperOverlap.y();                       

         ZzYzXm_Destination  = 0;

         ZzYzXp_Destination = localGridSize.x() - upperOverlap.x();

         ZzYmXz_Destination    = 0;

         ZzYpXz_Destination  = localGridSize.y() - upperOverlap.y();                       

         

         const int *neighbors = distributedGrid->getNeighbors();

         const int *periodicNeighbors = distributedGrid->getPeriodicNeighbors();

         

         if( periodicBoundaries )

         {

            if( neighbors[ Left ] == -1 )

               swap( leftSource, leftDestination );

            if( neighbors[ Right ] == -1 )

               swap( rightSource, rightDestination );

            if( neighbors[ Up ] == -1 )

               swap( upSource, upDestination );

            if( neighbors[ Down ] == -1 )

               swap( downSource, downDestination );

            if( neighbors[ ZzYzXm ] == -1 )

               swap( ZzYzXm_Source, ZzYzXm_Destination );

            if( neighbors[ ZzYzXp ] == -1 )

               swap( ZzYzXp_Source, ZzYzXp_Destination );

            if( neighbors[ ZzYmXz ] == -1 )

               swap( ZzYmXz_Source, ZzYmXz_Destination );

            if( neighbors[ ZzYpXz ] == -1 )

               swap( ZzYpXz_Source, ZzYpXz_Destination );

         }

         

         copyBuffers(meshFunction, sendBuffers, true,

            leftSource, rightSource, upSource, downSource,

            ZzYzXm_Source, ZzYzXp_Source, ZzYmXz_Source, ZzYpXz_Source,

            xCenter, yCenter,

            lowerOverlap, upperOverlap, localSize,

            neighbors,
@@ -166,7 +165,7 @@ class DistributedMeshSynchronizer< Functions::MeshFunction< Grid< 2, GridReal, D 


         //copy data from receive buffers

         copyBuffers(meshFunction, receiveBuffers, false,

              leftDestination, rightDestination, upDestination, downDestination,

              ZzYzXm_Destination, ZzYzXp_Destination, ZzYmXz_Destination, ZzYpXz_Destination,

              xCenter, yCenter,

              lowerOverlap, upperOverlap, localSize,

              neighbors,
@@ -183,7 +182,7 @@ class DistributedMeshSynchronizer< Functions::MeshFunction< Grid< 2, GridReal, D 
         MeshFunctionType& meshFunction,

         Containers::Array<Real_, Device, Index>* buffers,

         bool toBuffer,

         int left, int right, int up, int down,

         int ZzYzXm_Position, int ZzYzXp_Position, int ZzYmXz_Position, int ZzYpXz_Position,

         int xcenter, int ycenter,

         const CoordinatesType& lowerOverlap,

         const CoordinatesType& upperOverlap,
@@ -192,33 +191,32 @@ class DistributedMeshSynchronizer< Functions::MeshFunction< Grid< 2, GridReal, D 
         bool periodicBoundaries,

         const PeriodicBoundariesMaskPointer& mask )

      {

         // TODO: SWAP up and down

         bool leftIsBoundary = ( neighbors[ Left ] == -1 );

         bool rightIsBoundary = ( neighbors[ Right ] == -1 );

         bool upIsBoundary = ( neighbors[ Up ] == -1 );

         bool downIsBoundary = ( neighbors[ Down ] == -1 );

         bool upLeftIsBoundary = ( neighbors[ UpLeft ] == -1 );

         bool upRightIsBoundary = ( neighbors[ UpRight ] == -1 );

         bool downLeftIsBoundary = ( neighbors[ DownLeft ] == -1 );

         bool downRightIsBoundary = ( neighbors[ DownRight ] == -1 );

         bool ZzYzXm_IsBoundary = ( neighbors[ ZzYzXm ] == -1 );

         bool ZzYzXp_IsBoundary = ( neighbors[ ZzYzXp ] == -1 );

         bool ZzYmXz_IsBoundary = ( neighbors[ ZzYmXz ] == -1 );

         bool ZzYpXz_IsBoundary = ( neighbors[ ZzYpXz ] == -1 );

         bool ZzYmXm_IsBoundary = ( neighbors[ ZzYmXm ] == -1 );

         bool ZzYmXp_IsBoundary = ( neighbors[ ZzYmXp ] == -1 );

         bool ZzYpXm_IsBoundary = ( neighbors[ ZzYpXm ] == -1 );

         bool ZzYpXp_IsBoundary = ( neighbors[ ZzYpXp ] == -1 );

         

         using Helper = BufferEntitiesHelper< MeshFunctionType, PeriodicBoundariesMaskPointer, 2, Real_, Device >;

         if( ! leftIsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ Left      ].getData(), leftIsBoundary,      left,    ycenter, lowerOverlap.x(), localSize.y(),    toBuffer );

         if( ! rightIsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ Right     ].getData(), rightIsBoundary,     right,   ycenter, upperOverlap.x(), localSize.y(),    toBuffer );

         if( ! upIsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ Up        ].getData(), upIsBoundary,        xcenter, up,      localSize.x(),    lowerOverlap.y(), toBuffer );

         if( ! downIsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ Down      ].getData(), downIsBoundary,      xcenter, down,    localSize.x(),    upperOverlap.y(), toBuffer );

         if( ! upLeftIsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ UpLeft    ].getData(), upLeftIsBoundary,    left,    up,      lowerOverlap.x(), lowerOverlap.y(), toBuffer );

         if( ! upRightIsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ UpRight   ].getData(), upRightIsBoundary,   right,   up,      upperOverlap.x(), lowerOverlap.y(), toBuffer );

         if( ! downLeftIsBoundary || periodicBoundaries )        

            Helper::BufferEntities( meshFunction, mask, buffers[ DownLeft  ].getData(), downLeftIsBoundary,  left,    down,    lowerOverlap.x(), upperOverlap.y(), toBuffer );

         if( ! downRightIsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ DownRight ].getData(), downRightIsBoundary, right,   down,    upperOverlap.x(), upperOverlap.y(), toBuffer );

         if( ! ZzYzXm_IsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ ZzYzXm      ].getData(), ZzYzXm_IsBoundary,      ZzYzXm_Position,    ycenter, lowerOverlap.x(), localSize.y(),    toBuffer );

         if( ! ZzYzXp_IsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ ZzYzXp     ].getData(), ZzYzXp_IsBoundary,     ZzYzXp_Position,   ycenter, upperOverlap.x(), localSize.y(),    toBuffer );

         if( ! ZzYmXz_IsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ ZzYmXz        ].getData(), ZzYmXz_IsBoundary,        xcenter, ZzYmXz_Position,      localSize.x(),    lowerOverlap.y(), toBuffer );

         if( ! ZzYpXz_IsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ ZzYpXz      ].getData(), ZzYpXz_IsBoundary,      xcenter, ZzYpXz_Position,    localSize.x(),    upperOverlap.y(), toBuffer );

         if( ! ZzYmXm_IsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ ZzYmXm    ].getData(), ZzYmXm_IsBoundary,    ZzYzXm_Position,    ZzYmXz_Position,      lowerOverlap.x(), lowerOverlap.y(), toBuffer );

         if( ! ZzYmXp_IsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ ZzYmXp   ].getData(), ZzYmXp_IsBoundary,   ZzYzXp_Position,   ZzYmXz_Position,      upperOverlap.x(), lowerOverlap.y(), toBuffer );

         if( ! ZzYpXm_IsBoundary || periodicBoundaries )        

            Helper::BufferEntities( meshFunction, mask, buffers[ ZzYpXm  ].getData(), ZzYpXm_IsBoundary,  ZzYzXm_Position,    ZzYpXz_Position,    lowerOverlap.x(), upperOverlap.y(), toBuffer );

         if( ! ZzYpXp_IsBoundary || periodicBoundaries )

            Helper::BufferEntities( meshFunction, mask, buffers[ ZzYpXp ].getData(), ZzYpXp_IsBoundary, ZzYzXp_Position,   ZzYpXz_Position,    upperOverlap.x(), upperOverlap.y(), toBuffer );

      }

      

      DistributedGridType *distributedGrid;
@@ -227,16 +225,16 @@ class DistributedMeshSynchronizer< Functions::MeshFunction< Grid< 2, GridReal, D 
      Containers::Array<RealType, Device, Index> receiveBuffers[8];

      Containers::StaticArray< 8, int > sizes;



      int leftSource;

      int rightSource;

      int upSource;

      int downSource;

      int ZzYzXm_Source;

      int ZzYzXp_Source;

      int ZzYmXz_Source;

      int ZzYpXz_Source;

      int xCenter;

      int yCenter;

      int leftDestination;

      int rightDestination;

      int upDestination;

      int downDestination;

      int ZzYzXm_Destination;

      int ZzYzXp_Destination;

      int ZzYmXz_Destination;

      int ZzYpXz_Destination;



      bool isSet;      

};

src/TNL/Meshes/DistributedMeshes/DistributedGridSynchronizer_3D.h

+144 −143

File changed.

Preview size limit exceeded, changes collapsed.

src/TNL/Meshes/GridDetails/Traverser_Grid1D_impl.h

+4 −4
Original line number Diff line number Diff line
@@ -48,7 +48,7 @@ processBoundaryEntities( const GridPointer& gridPointer, 
   else //Distributed

   {

       const int* neighbors=distributedGrid->getNeighbors(); 

       if( neighbors[ Meshes::DistributedMeshes::Left ] == -1 )

       if( neighbors[ Meshes::DistributedMeshes::ZzYzXm ] == -1 )

       {

          GridTraverser< GridType >::template processEntities< GridEntity, EntitiesProcessor, UserData, false >(

              gridPointer,
@@ -57,7 +57,7 @@ processBoundaryEntities( const GridPointer& gridPointer, 
              userData );

       }

       

       if( neighbors[ Meshes::DistributedMeshes::Right ] == -1 )

       if( neighbors[ Meshes::DistributedMeshes::ZzYzXp ] == -1 )

       {

          GridTraverser< GridType >::template processEntities< GridEntity, EntitiesProcessor, UserData, false >(

              gridPointer,
@@ -100,10 +100,10 @@ processInteriorEntities( const GridPointer& gridPointer, 
      CoordinatesType end( gridPointer->getDimensions() - distributedGrid->getUpperOverlap() - CoordinatesType( 1 ) );

      

      const int* neighbors = distributedGrid->getNeighbors(); 

      if( neighbors[ Meshes::DistributedMeshes::Left ] == -1 )

      if( neighbors[ Meshes::DistributedMeshes::ZzYzXm ] == -1 )

         begin += CoordinatesType( 1 );

       

      if( neighbors[ Meshes::DistributedMeshes::Right ] == -1 )

      if( neighbors[ Meshes::DistributedMeshes::ZzYzXp ] == -1 )

         end -= CoordinatesType( 1 );

      

      /*