Commit 2dd7ca43 authored by Tomáš Oberhuber's avatar Tomáš Oberhuber
Browse files

Implementing heat equation benchmark.

parent cf2da4ee

tests/benchmarks/heat-equation-benchmark/HeatEquationBenchmarkProblem_impl.h

+55 −1
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 
#include <solvers/pde/tnlExplicitUpdater.h>

#include <solvers/pde/tnlLinearSystemAssembler.h>

#include <solvers/pde/tnlBackwardTimeDiscretisation.h>

#include "TestGridEntity.h"



template< typename Mesh,

          typename BoundaryCondition,
@@ -270,6 +271,51 @@ boundaryConditionsTemplatedCompact( const GridType grid, 
   }   

}



/*template< typename Grid,

          int EntityDimensions = 2,

          typename Config = tnlGridEntityNoStencilStorage >

struct TestEntity

{      

      typedef Grid GridType;

      typedef GridType MeshType;

      typedef typename GridType::RealType RealType;

      typedef typename GridType::IndexType IndexType;

      typedef typename GridType::CoordinatesType CoordinatesType;

      typedef Config ConfigType;

      

      static const int meshDimensions = GridType::meshDimensions;

      

      static const int entityDimensions = EntityDimensions;

            

      constexpr static int getDimensions() { return EntityDimensions; };

      

      constexpr static int getMeshDimensions() { return meshDimensions; };

   

      typedef TestEntity< GridType, EntityDimensions, Config > ThisType;

      typedef tnlNeighbourGridEntitiesStorage< ThisType > NeighbourGridEntitiesStorageType;

   

   

   __cuda_callable__ TestEntity(  const GridType& grid,

               const CoordinatesType& coordinates,

               const CoordinatesType& entityOrientation,

               const CoordinatesType& entityBasis )

      : grid( grid ), coordinates( coordinates ),

      entityOrientation( 0  ),

      entityBasis( 1 ),

      neighbourEntitiesStorage( *this )

   {

      

   }

      

       const GridType& grid;

   

   CoordinatesType coordinates;

   CoordinatesType entityOrientation;

   CoordinatesType entityBasis;

      

   NeighbourGridEntitiesStorageType neighbourEntitiesStorage;   

};*/



template< typename GridType,

          typename GridEntity,

          typename DifferentialOperator,
@@ -314,8 +360,10 @@ heatEquationTemplatedCompact( const GridType grid, 
      }

   }*/

      

   GridEntity entity( grid, coordinates, entityOrientation, entityBasis );

   //GridEntity entity( grid, coordinates, entityOrientation, entityBasis );

   //printf( "size = %d ", sizeof( GridEntity ) );

   //entity.refresh();

   TestGridEntity< GridType, 2, tnlGridEntityCrossStencilStorage< 1 > > entity( grid, coordinates, entityOrientation, entityBasis );

   

   const IndexType tidX = begin.x() + ( gridXIdx * tnlCuda::getMaxGridSize() + blockIdx.x ) * blockDim.x + threadIdx.x;

   const IndexType tidY = begin.y() + ( gridYIdx * tnlCuda::getMaxGridSize() + blockIdx.y ) * blockDim.y + threadIdx.y;
@@ -374,6 +422,12 @@ getExplicitRHS( const RealType& time, 
         fu[ ( gridYSize - 1 ) * gridXSize + i ] = 0.0; //u[ ( gridYSize - 2 ) * gridXSize + i ];

      }

      

      /*typedef typename MeshType::Cell CellType;

      typedef typename CellType::CoordinatesType CoordinatesType;

      CoordinatesType coordinates( 0, 0 ), entityOrientation( 0,0 ), entityBasis( 0, 0 );*/

      

      //CellType entity( mesh, coordinates, entityOrientation, entityBasis );



      for( IndexType j = 1; j < gridYSize - 1; j++ )

         for( IndexType i = 1; i < gridXSize - 1; i++ )

         {

tests/benchmarks/heat-equation-benchmark/TestGridEntity.h

0 → 100644
+420 −0
Original line number Diff line number Diff line 
/***************************************************************************

                          TestGridEntity.h  -  description

                             -------------------

    begin                : Nov 13, 2015

    copyright            : (C) 2015 by Tomas Oberhuber

    email                : tomas.oberhuber@fjfi.cvut.cz

 ***************************************************************************/



/***************************************************************************

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 *                                                                         *

 ***************************************************************************/



#pragma once



#include <mesh/grids/tnlNeighbourGridEntitiesStorage.h>

//#include "TestNeighbourGridEntitiesStorage.h"



template< typename GridEntity,

          int NeighbourEntityDimensions,

          typename StencilStorage >

class tnlNeighbourGridEntityGetter;



template< typename GridEntityType >

class tnlBoundaryGridEntityChecker;



template< typename GridEntityType >

class TestGridEntityCenterGetter;





template< typename Grid,          

          int EntityDimensions,

          typename Config >

class TestGridEntity

{

};





template< int Dimensions,

          typename Real,

          typename Device,

          typename Index,          

          int EntityDimensions,

          typename Config >

class TestGridEntity< tnlGrid< Dimensions, Real, Device, Index >, EntityDimensions, Config >

{

   public:

      

      typedef tnlGrid< Dimensions, Real, Device, Index > GridType;

      typedef GridType MeshType;

      typedef typename GridType::RealType RealType;

      typedef typename GridType::IndexType IndexType;

      typedef typename GridType::CoordinatesType CoordinatesType;

      typedef Config ConfigType;

      

      static const int meshDimensions = GridType::meshDimensions;

      

      static const int entityDimensions = EntityDimensions;

            

      constexpr static int getDimensions() { return EntityDimensions; };

      

      constexpr static int getMeshDimensions() { return meshDimensions; };

      

      typedef tnlStaticVector< meshDimensions, IndexType > EntityOrientationType;

      typedef tnlStaticVector< meshDimensions, IndexType > EntityBasisType;

      typedef TestGridEntity< GridType, entityDimensions, Config > ThisType;

      typedef typename GridType::VertexType VertexType;

      

      typedef tnlNeighbourGridEntitiesStorage< ThisType > NeighbourGridEntitiesStorageType;

      

      template< int NeighbourEntityDimensions = entityDimensions >

      using NeighbourEntities = 

         tnlNeighbourGridEntityGetter<

            TestGridEntity< tnlGrid< Dimensions, Real, Device, Index >,

                           EntityDimensions,

                           Config >,

            NeighbourEntityDimensions >;

      

      __cuda_callable__ inline

      TestGridEntity( const GridType& grid );

      

      __cuda_callable__ inline

      TestGridEntity( const GridType& grid,

                     const CoordinatesType& coordinates,

                     const EntityOrientationType& orientation,

                     const EntityBasisType& basis );

      

      __cuda_callable__ inline

      const CoordinatesType& getCoordinates() const;

      

      __cuda_callable__ inline

      CoordinatesType& getCoordinates();

      

      __cuda_callable__ inline

      void setCoordinates( const CoordinatesType& coordinates );



      /***

       * Call this method every time the coordinates are changed

       * to recompute the mesh entity index. The reason for this strange

       * mechanism is a performance.

       */

      __cuda_callable__ inline

      //void setIndex( IndexType entityIndex );

      void refresh();



      __cuda_callable__ inline

      Index getIndex() const;

      

      __cuda_callable__ inline

      const EntityOrientationType& getOrientation() const;

      

      __cuda_callable__ inline

      void setOrientation( const EntityOrientationType& orientation );

      

      __cuda_callable__ inline

      const EntityBasisType& getBasis() const;

      

      __cuda_callable__ inline

      EntityBasisType& getBasis();

      

      __cuda_callable__ inline

      void setBasis( const EntityBasisType& basis );

      

      template< int NeighbourEntityDimensions = entityDimensions >

      __cuda_callable__ inline

      const NeighbourEntities< NeighbourEntityDimensions >&

      getNeighbourEntities() const;

      

      __cuda_callable__ inline

      bool isBoundaryEntity() const;

      

      __cuda_callable__ inline

      VertexType getCenter() const;

      

      __cuda_callable__ inline

      const RealType& getMeasure() const;

      

      __cuda_callable__ inline

      const GridType& getMesh() const;

      

   protected:

      

      const GridType& grid;

      

      IndexType entityIndex;

      

      CoordinatesType coordinates;

      

      EntityOrientationType orientation;

      

      EntityBasisType basis;

      

      NeighbourGridEntitiesStorageType neighbourEntitiesStorage;

      

      //__cuda_callable__ inline

      //TestGridEntity();

      

      friend class tnlBoundaryGridEntityChecker< ThisType >;

      

      friend class TestGridEntityCenterGetter< ThisType >;

};



/****

 * Specializations for cells

 */

template< int Dimensions,

          typename Real,

          typename Device,

          typename Index,

          typename Config >

class TestGridEntity< tnlGrid< Dimensions, Real, Device, Index >, Dimensions, Config >

{

   public:

      

      typedef tnlGrid< Dimensions, Real, Device, Index > GridType;

      typedef GridType MeshType;

      typedef typename GridType::RealType RealType;

      typedef typename GridType::IndexType IndexType;

      typedef typename GridType::CoordinatesType CoordinatesType;

      typedef typename GridType::VertexType VertexType;

      typedef Config ConfigType;

      

      static const int meshDimensions = GridType::meshDimensions;

      

      static const int entityDimensions = meshDimensions;



      constexpr static int getDimensions() { return entityDimensions; };

      

      constexpr static int getMeshDimensions() { return meshDimensions; };

      

      

      typedef tnlStaticVector< meshDimensions, IndexType > EntityOrientationType;

      typedef tnlStaticVector< meshDimensions, IndexType > EntityBasisType;

      typedef TestGridEntity< GridType, entityDimensions, Config > ThisType;

      typedef tnlNeighbourGridEntitiesStorage< ThisType > NeighbourGridEntitiesStorageType;

      

      template< int NeighbourEntityDimensions = entityDimensions >

      using NeighbourEntities = 

         tnlNeighbourGridEntityGetter<

            TestGridEntity< tnlGrid< Dimensions, Real, Device, Index >,

                           entityDimensions,

                           Config >,

            NeighbourEntityDimensions >;





      __cuda_callable__ inline

      TestGridEntity( const GridType& grid );

      

      __cuda_callable__ inline

      TestGridEntity( const GridType& grid,

                     const CoordinatesType& coordinates,

                     const EntityOrientationType& orientation = EntityOrientationType( 0 ),

                     const EntityBasisType& basis = EntityBasisType( 1 ) );

      

      __cuda_callable__ inline

      const CoordinatesType& getCoordinates() const;      

      

      __cuda_callable__ inline

      CoordinatesType& getCoordinates();  

      

      __cuda_callable__ inline

      void setCoordinates( const CoordinatesType& coordinates );



      /***

       * Call this method every time the coordinates are changed

       * to recompute the mesh entity index. The reason for this strange

       * mechanism is a performance.

       */

      __cuda_callable__ inline

      //void setIndex( IndexType entityIndex );

      void refresh();



      __cuda_callable__ inline

      Index getIndex() const;

            

      __cuda_callable__ inline

      const EntityOrientationType getOrientation() const;

      

      __cuda_callable__ inline

      void setOrientation( const EntityOrientationType& orientation ){};

      

      __cuda_callable__ inline

      const EntityBasisType getBasis() const;

      

      __cuda_callable__ inline

      void setBasis( const EntityBasisType& basis ){};

      

      template< int NeighbourEntityDimensions = Dimensions >

      __cuda_callable__ inline

      const NeighbourEntities< NeighbourEntityDimensions >&

      getNeighbourEntities() const;

      

      __cuda_callable__ inline

      bool isBoundaryEntity() const;

      

      __cuda_callable__ inline

      VertexType getCenter() const;

      

      __cuda_callable__ inline

      const RealType& getMeasure() const;      

      

      __cuda_callable__ inline

      const VertexType& getEntityProportions() const;      

      

      __cuda_callable__ inline

      const GridType& getMesh() const;



   protected:

      

      const GridType& grid;

      

      IndexType entityIndex;      

      

      CoordinatesType coordinates;

      

      EntityOrientationType orientation;

      

      EntityBasisType basis;

      

      NeighbourGridEntitiesStorageType neighbourEntitiesStorage;

      

      //__cuda_callable__ inline

      //TestGridEntity();

      

      friend class tnlBoundaryGridEntityChecker< ThisType >;

      

      friend class TestGridEntityCenterGetter< ThisType >;

};



/****

 * Specialization for vertices

 */

template< int Dimensions,

          typename Real,

          typename Device,

          typename Index,

          typename Config >

class TestGridEntity< tnlGrid< Dimensions, Real, Device, Index >, 0, Config >

{

   public:

      

      typedef tnlGrid< Dimensions, Real, Device, Index > GridType;

      typedef GridType MeshType;

      typedef typename GridType::RealType RealType;

      typedef typename GridType::IndexType IndexType;

      typedef typename GridType::CoordinatesType CoordinatesType;

      typedef typename GridType::VertexType VertexType;

      typedef Config ConfigType;

      

      static const int meshDimensions = GridType::meshDimensions;

      

      static const int entityDimensions = 0;

      

      constexpr static int getDimensions() { return entityDimensions; };

      

      constexpr static int getMeshDimensions() { return meshDimensions; };      

      

      typedef tnlStaticVector< meshDimensions, IndexType > EntityOrientationType;

      typedef tnlStaticVector< meshDimensions, IndexType > EntityBasisType;

      typedef TestGridEntity< GridType, entityDimensions, Config > ThisType;

      typedef tnlNeighbourGridEntitiesStorage< ThisType > NeighbourGridEntitiesStorageType;

      

      template< int NeighbourEntityDimensions = entityDimensions >

      using NeighbourEntities = 

         tnlNeighbourGridEntityGetter<

            TestGridEntity< tnlGrid< Dimensions, Real, Device, Index >,

                           entityDimensions,

                           Config >,

            NeighbourEntityDimensions >;





      __cuda_callable__ inline

      TestGridEntity( const GridType& grid );

      

      __cuda_callable__ inline

      TestGridEntity( const GridType& grid,

                     const CoordinatesType& coordinates,

                     const EntityOrientationType& orientation,

                     const EntityBasisType& basis );

      

      __cuda_callable__ inline

      const CoordinatesType& getCoordinates() const;

      

      __cuda_callable__ inline

      CoordinatesType& getCoordinates();

      

      __cuda_callable__ inline

      void setCoordinates( const CoordinatesType& coordinates );



      /***

       * Call this method every time the coordinates are changed

       * to recompute the mesh entity index. The reason for this strange

       * mechanism is a performance.

       */

      __cuda_callable__ inline

      //void setIndex( IndexType entityIndex );

      void refresh();



      __cuda_callable__ inline

      Index getIndex() const;

            

      __cuda_callable__ inline

      const EntityOrientationType getOrientation() const;     

      

      __cuda_callable__ inline

      void setOrientation( const EntityOrientationType& orientation ){};

      

      __cuda_callable__ inline

      const EntityBasisType getBasis() const;

      

      __cuda_callable__ inline

      void setBasis( const EntityBasisType& basis ){};



      

      template< int NeighbourEntityDimensions = entityDimensions >

      __cuda_callable__ inline

      const NeighbourEntities< NeighbourEntityDimensions >&

      getNeighbourEntities() const;

      

      __cuda_callable__ inline

      bool isBoundaryEntity() const;

      

      __cuda_callable__ inline

      VertexType getCenter() const;



      __cuda_callable__ inline

      const RealType getMeasure() const;      

      

      __cuda_callable__ inline

      VertexType getEntityProportions() const;

      

      __cuda_callable__ inline

      const GridType& getMesh() const;

      

   protected:

      

      const GridType& grid;

      

      IndexType entityIndex;      

      

      CoordinatesType coordinates;

      

      EntityOrientationType orientation;

      

      EntityBasisType basis;

      

      NeighbourGridEntitiesStorageType neighbourEntitiesStorage;

            

      friend class tnlBoundaryGridEntityChecker< ThisType >;

      

      friend class TestGridEntityCenterGetter< ThisType >;

};



#include "TestGridEntity_impl.h"

tests/benchmarks/heat-equation-benchmark/TestGridEntityCenterGetter.h

0 → 100644
+220 −0
Original line number Diff line number Diff line 
/***************************************************************************

                          TestGridEntityCenterGetter.h  -  description

                             -------------------

    begin                : Dec 2, 2015

    copyright            : (C) 2015 by Tomas Oberhuber

    email                : tomas.oberhuber@fjfi.cvut.cz

 ***************************************************************************/



/***************************************************************************

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 *                                                                         *

 ***************************************************************************/





#pragma once



template< typename GridEntity >

class TestGridEntityCenterGetter

{

};



/***

 * 1D grids

 */

template< typename Real,

          typename Device,

          typename Index,

          typename Config >

class TestGridEntityCenterGetter< TestGridEntity< tnlGrid< 1, Real, Device, Index >, 1, Config > >

{

   public:

      

      typedef tnlGrid< 1, Real, Device, Index > GridType;

      typedef TestGridEntity< GridType, 1, Config > GridEntityType;

      typedef typename GridType::VertexType VertexType;

      

      __cuda_callable__ inline

      static VertexType getEntityCenter( const GridEntityType& entity )

      {

         const GridType& grid = entity.grid;

         return VertexType(

            grid.getOrigin().x() + ( entity.getCoordinates().x() + 0.5 ) * grid.getSpaceSteps().x() );

      }

};



template< typename Real,

          typename Device,

          typename Index,

          typename Config >

class TestGridEntityCenterGetter< TestGridEntity< tnlGrid< 1, Real, Device, Index >, 0, Config > >

{

   public:

      

      typedef tnlGrid< 1, Real, Device, Index > GridType;

      typedef TestGridEntity< GridType, 0, Config > GridEntityType;

      typedef typename GridType::VertexType VertexType;

      

      __cuda_callable__ inline

      static VertexType getEntityCenter( const GridEntityType& entity )

      {

         const GridType& grid = entity.grid;

         return VertexType(

            grid.getOrigin().x() + ( entity.getCoordinates().x() ) * grid.getSpaceSteps().x() );

      }

};



/****

 * 2D grids

 */

template< typename Real,

          typename Device,

          typename Index,

          typename Config >

class TestGridEntityCenterGetter< TestGridEntity< tnlGrid< 2, Real, Device, Index >, 2, Config > >

{

   public:

      

      typedef tnlGrid< 2, Real, Device, Index > GridType;

      typedef TestGridEntity< GridType, 2, Config > GridEntityType;

      typedef typename GridType::VertexType VertexType;

      

      __cuda_callable__ inline

      static VertexType getEntityCenter( const GridEntityType& entity )

      {

         const GridType& grid = entity.grid;

         return VertexType(

            grid.getOrigin().x() + ( entity.getCoordinates().x() + 0.5 ) * grid.getSpaceSteps().x(),

            grid.getOrigin().y() + ( entity.getCoordinates().y() + 0.5 ) * grid.getSpaceSteps().y() );

      }

};



template< typename Real,

          typename Device,

          typename Index,

          typename Config >

class TestGridEntityCenterGetter< TestGridEntity< tnlGrid< 2, Real, Device, Index >, 1, Config > >

{

   public:

      

      typedef tnlGrid< 2, Real, Device, Index > GridType;

      typedef TestGridEntity< GridType, 1, Config > GridEntityType;

      typedef typename GridType::VertexType VertexType;

      

      __cuda_callable__ inline

      static VertexType getEntityCenter( const GridEntityType& entity )

      {

         const GridType& grid = entity.grid;

         return VertexType(

            grid.getOrigin().x() + 

               ( entity.getCoordinates().x() + 0.5 * entity.getBasis().x() ) * grid.getSpaceSteps().x(),

            grid.getOrigin().y() + 

               ( entity.getCoordinates().y() + 0.5 * entity.getBasis().y() ) * grid.getSpaceSteps().y() );

      }

};





template< typename Real,

          typename Device,

          typename Index,

          typename Config >

class TestGridEntityCenterGetter< TestGridEntity< tnlGrid< 2, Real, Device, Index >, 0, Config > >

{

   public:

      

      typedef tnlGrid< 2, Real, Device, Index > GridType;

      typedef TestGridEntity< GridType, 0, Config > GridEntityType;

      typedef typename GridType::VertexType VertexType;

      

      __cuda_callable__ inline

      static VertexType getEntityCenter( const GridEntityType& entity )

      {

         const GridType& grid = entity.grid;

         return VertexType(

            grid.getOrigin().x() + entity.getCoordinates().x() * grid.getSpaceSteps().x(),

            grid.getOrigin().y() + entity.getCoordinates().y() * grid.getSpaceSteps().y() );

      }

};





/***

 * 3D grid

 */

template< typename Real,

          typename Device,

          typename Index,

          int EntityDimensions,

          typename Config >

class TestGridEntityCenterGetter< TestGridEntity< tnlGrid< 3, Real, Device, Index >, EntityDimensions, Config > >

{

   public:

      

      typedef tnlGrid< 3, Real, Device, Index > GridType;

      typedef TestGridEntity< GridType, EntityDimensions, Config > GridEntityType;

      typedef typename GridType::VertexType VertexType;

      

      __cuda_callable__ inline

      static VertexType getEntityCenter( const GridEntityType& entity )

      {

         const GridType& grid = entity.grid;

         return VertexType(

            grid.getOrigin().x() + 

               ( entity.getCoordinates().x() + 0.5 * entity.getBasis().x() ) * grid.getSpaceSteps().x(),

            grid.getOrigin().y() + 

               ( entity.getCoordinates().y() + 0.5 * entity.getBasis().y() ) * grid.getSpaceSteps().y(),

            grid.getOrigin().z() + 

               ( entity.getCoordinates().z() + 0.5 * entity.getBasis().z() ) * grid.getSpaceSteps().z() );

      }

};



template< typename Real,

          typename Device,

          typename Index,

          typename Config  >

class TestGridEntityCenterGetter< TestGridEntity< tnlGrid< 3, Real, Device, Index >, 3, Config > >

{

   public:

      

      typedef tnlGrid< 3, Real, Device, Index > GridType;

      typedef TestGridEntity< GridType, 3, Config > GridEntityType;

      typedef typename GridType::VertexType VertexType;

      

      __cuda_callable__ inline

      static VertexType getEntityCenter( const GridEntityType& entity )

      {

         const GridType& grid = entity.grid;

         return VertexType(

            grid.getOrigin().x() + ( entity.getCoordinates().x() + 0.5 ) * grid.getSpaceSteps().x(),

            grid.getOrigin().y() + ( entity.getCoordinates().y() + 0.5 ) * grid.getSpaceSteps().y(),

            grid.getOrigin().z() + ( entity.getCoordinates().z() + 0.5 ) * grid.getSpaceSteps().z() );

      }

};



template< typename Real,

          typename Device,

          typename Index,

          typename Config  >

class TestGridEntityCenterGetter< TestGridEntity< tnlGrid< 3, Real, Device, Index >, 0, Config > >

{

   public:

      

      typedef tnlGrid< 3, Real, Device, Index > GridType;

      typedef TestGridEntity< GridType, 0, Config > GridEntityType;

      typedef typename GridType::VertexType VertexType;

      

      __cuda_callable__ inline

      static VertexType getEntityCenter( const GridEntityType& entity )

      {

         const GridType& grid = entity.grid;

         return VertexType(

            grid.getOrigin().x() + ( entity.getCoordinates().x() ) * grid.getSpaceSteps().x(),

            grid.getOrigin().y() + ( entity.getCoordinates().y() ) * grid.getSpaceSteps().y(),

            grid.getOrigin().z() + ( entity.getCoordinates().z() ) * grid.getSpaceSteps().z() );

      }

};

tests/benchmarks/heat-equation-benchmark/TestGridEntityConfig.h

0 → 100644
+74 −0

File added.

Preview size limit exceeded, changes collapsed.

tests/benchmarks/heat-equation-benchmark/TestGridEntityGetter.h

0 → 100644
+33 −0

File added.

Preview size limit exceeded, changes collapsed.