Commit fb828e69 authored by Jan Schäfer's avatar Jan Schäfer
Browse files

tak nestaci jen commit, musi byt i add. Prdani souboru operatoru

parent 9345cef1

examples/inviscid-flow/1d/EulerPressureGetter.h

0 → 100644
+215 −0
Original line number Diff line number Diff line 
#ifndef EulerPressureGetter_H

#define EulerPressureGetter_H



#include <core/vectors/tnlVector.h>

#include <mesh/tnlGrid.h>



template< typename Mesh,

          typename Real = typename Mesh::RealType,

          typename Index = typename Mesh::IndexType >

class EulerPressureGetter

{

};



template< typename MeshReal,

          typename Device,

          typename MeshIndex,

          typename Real,

          typename Index >

class EulerPressureGetter< tnlGrid< 1,MeshReal, Device, MeshIndex >, Real, Index >

{

   public:

      typedef tnlGrid< 1, MeshReal, Device, MeshIndex > MeshType;

      typedef typename MeshType::CoordinatesType CoordinatesType;

      typedef Real RealType;

      typedef Device DeviceType;

      typedef Index IndexType;

      typedef tnlMeshFunction< MeshType > MeshFunctionType;

      enum { Dimensions = MeshType::getMeshDimensions() };



      static tnlString getType();

      Real gamma;

      MeshFunctionType& velocity;

      MeshFunctionType& rhoVel;

      MeshFunctionType& energy;



      void setGamma(const Real& gamma)

      {

          this->gamma = gamma;

      };



      void setVelocity(const MeshFunctionType& velocity)

      {

          this->velocity = velocity;

      };



      void setRhoVel(const MeshFunctionType& rhoVel)

      {

          this->rhoVel = rhoVel;

      };



      void setEnergy(const MeshFunctionType& energy)

      {

          this->energy = energy;

      };



      template< typename MeshFunction, typename MeshEntity >

      __cuda_callable__

      Real operator()( const MeshFunction& u,

                       const MeshEntity& entity,

                       const RealType& time = 0.0 ) const;



      __cuda_callable__

      template< typename MeshEntity >

      Index getLinearSystemRowLength( const MeshType& mesh,

                                      const IndexType& index,

                                      const MeshEntity& entity ) const;



      template< typename MeshEntity, typename Vector, typename MatrixRow >

      __cuda_callable__

      void updateLinearSystem( const RealType& time,

                               const RealType& tau,

                               const MeshType& mesh,

                               const IndexType& index,

                               const MeshEntity& entity,

                               const MeshFunctionType& u,

                               Vector& b,

                               MatrixRow& matrixRow ) const;

};



template< typename MeshReal,

          typename Device,

          typename MeshIndex,

          typename Real,

          typename Index >

class EulerPressureGetter< tnlGrid< 2,MeshReal, Device, MeshIndex >, Real, Index >

{

   public:

      typedef tnlGrid< 2, MeshReal, Device, MeshIndex > MeshType;

      typedef typename MeshType::CoordinatesType CoordinatesType;

      typedef Real RealType;

      typedef Device DeviceType;

      typedef Index IndexType;

      typedef tnlMeshFunction< MeshType > MeshFunctionType;

      enum { Dimensions = MeshType::getMeshDimensions() };



      static tnlString getType();

      Real gamma;

      MeshFunctionType& velocity;

      MeshFunctionType& rhoVel;

      MeshFunctionType& energy;



      void setGamma(const Real& gamma)

      {

          this->gamma = gamma;

      };



      void setVelocity(const MeshFunctionType& velocity)

      {

          this->velocity = velocity;

      };



      void setRhoVel(const MeshFunctionType& rhoVel)

      {

          this->rhoVel = rhoVel;

      };



      void setEnergy(const MeshFunctionType& energy)

      {

          this->energy = energy;

      };



      template< typename MeshFunction, typename MeshEntity >

      __cuda_callable__

      Real operator()( const MeshFunction& u,

                       const MeshEntity& entity,

                       const RealType& time = 0.0 ) const;



      __cuda_callable__

      template< typename MeshEntity >

      Index getLinearSystemRowLength( const MeshType& mesh,

                                      const IndexType& index,

                                      const MeshEntity& entity ) const;



      template< typename MeshEntity, typename Vector, typename MatrixRow >

      __cuda_callable__

      void updateLinearSystem( const RealType& time,

                               const RealType& tau,

                               const MeshType& mesh,

                               const IndexType& index,

                               const MeshEntity& entity,

                               const MeshFunctionType& u,

                               Vector& b,

                               MatrixRow& matrixRow ) const;

};



template< typename MeshReal,

          typename Device,

          typename MeshIndex,

          typename Real,

          typename Index >

class EulerPressureGetter< tnlGrid< 3,MeshReal, Device, MeshIndex >, Real, Index >

{

   public:

      typedef tnlGrid< 3, MeshReal, Device, MeshIndex > MeshType;

      typedef typename MeshType::CoordinatesType CoordinatesType;

      typedef Real RealType;

      typedef Device DeviceType;

      typedef Index IndexType;

      typedef tnlMeshFunction< MeshType > MeshFunctionType;

      enum { Dimensions = MeshType::getMeshDimensions() };



      static tnlString getType();

      Real gamma;

      MeshFunctionType& velocity;

      MeshFunctionType& rhoVel;

      MeshFunctionType& energy;



      void setGamma(const Real& gamma)

      {

          this->gamma = gamma;

      };



      void setVelocity(const MeshFunctionType& velocity)

      {

          this->velocity = velocity;

      };



      void setRhoVel(const MeshFunctionType& rhoVel)

      {

          this->rhoVel = rhoVel;

      };



      void setEnergy(const MeshFunctionType& energy)

      {

          this->energy = energy;

      };



      template< typename MeshFunction, typename MeshEntity >

      __cuda_callable__

      Real operator()( const MeshFunction& u,

                       const MeshEntity& entity,

                       const RealType& time = 0.0 ) const;



      __cuda_callable__

      template< typename MeshEntity >

      Index getLinearSystemRowLength( const MeshType& mesh,

                                      const IndexType& index,

                                      const MeshEntity& entity ) const;



      template< typename MeshEntity, typename Vector, typename MatrixRow >

      __cuda_callable__

      void updateLinearSystem( const RealType& time,

                               const RealType& tau,

                               const MeshType& mesh,

                               const IndexType& index,

                               const MeshEntity& entity,

                               const MeshFunctionType& u,

                               Vector& b,

                               MatrixRow& matrixRow ) const;

};





#include "EulerPressureGetter_impl.h"



#endif	/* EulerPressureGetter_H */

examples/inviscid-flow/1d/EulerPressureGetter.h~

0 → 100644
+216 −0
Original line number Diff line number Diff line 
#ifndef EulerPressureGetter_H

#define EulerPressureGetter_H



#include <core/vectors/tnlVector.h>

#include <mesh/tnlGrid.h>



template< typename Mesh,

          typename Real = typename Mesh::RealType,

          typename Index = typename Mesh::IndexType >

class EulerPressureGetter

{

};



template< typename MeshReal,

          typename Device,

          typename MeshIndex,

          typename Real,

          typename Index >

class EulerPressureGetter< tnlGrid< 1,MeshReal, Device, MeshIndex >, Real, Index >

{

   public:

      typedef tnlGrid< 1, MeshReal, Device, MeshIndex > MeshType;

      typedef typename MeshType::CoordinatesType CoordinatesType;

      typedef Real RealType;

      typedef Device DeviceType;

      typedef Index IndexType;

      typedef tnlMeshFunction< MeshType > MeshFunctionType;

      enum { Dimensions = MeshType::getMeshDimensions() };



      static tnlString getType();

      Real gamma;

      typedef tnlMeshFunction< MeshType > MeshFunctionType1;

      MeshFunctionType& velocity;

      MeshFunctionType& rhoVel;

      MeshFunctionType& energy;



      void setGamma(const Real& gamma)

      {

          this->gamma = gamma;

      };



      void setVelocity(const MeshFunctionType& velocity)

      {

          this->velocity = velocity;

      };



      void setRhoVel(const MeshFunctionType& rhoVel)

      {

          this->rhoVel = rhoVel;

      };



      void setEnergy(const MeshFunctionType& energy)

      {

          this->energy = energy;

      };



      template< typename MeshFunction, typename MeshEntity >

      __cuda_callable__

      Real operator()( const MeshFunction& u,

                       const MeshEntity& entity,

                       const RealType& time = 0.0 ) const;



      __cuda_callable__

      template< typename MeshEntity >

      Index getLinearSystemRowLength( const MeshType& mesh,

                                      const IndexType& index,

                                      const MeshEntity& entity ) const;



      template< typename MeshEntity, typename Vector, typename MatrixRow >

      __cuda_callable__

      void updateLinearSystem( const RealType& time,

                               const RealType& tau,

                               const MeshType& mesh,

                               const IndexType& index,

                               const MeshEntity& entity,

                               const MeshFunctionType& u,

                               Vector& b,

                               MatrixRow& matrixRow ) const;

};



template< typename MeshReal,

          typename Device,

          typename MeshIndex,

          typename Real,

          typename Index >

class EulerPressureGetter< tnlGrid< 2,MeshReal, Device, MeshIndex >, Real, Index >

{

   public:

      typedef tnlGrid< 2, MeshReal, Device, MeshIndex > MeshType;

      typedef typename MeshType::CoordinatesType CoordinatesType;

      typedef Real RealType;

      typedef Device DeviceType;

      typedef Index IndexType;

      typedef tnlMeshFunction< MeshType > MeshFunctionType;

      enum { Dimensions = MeshType::getMeshDimensions() };



      static tnlString getType();

      Real gamma;

      MeshFunctionType& velocity;

      MeshFunctionType& rhoVel;

      MeshFunctionType& energy;



      void setGamma(const Real& gamma)

      {

          this->gamma = gamma;

      };



      void setVelocity(const MeshFunctionType& velocity)

      {

          this->velocity = velocity;

      };



      void setRhoVel(const MeshFunctionType& rhoVel)

      {

          this->rhoVel = rhoVel;

      };



      void setEnergy(const MeshFunctionType& energy)

      {

          this->energy = energy;

      };



      template< typename MeshFunction, typename MeshEntity >

      __cuda_callable__

      Real operator()( const MeshFunction& u,

                       const MeshEntity& entity,

                       const RealType& time = 0.0 ) const;



      __cuda_callable__

      template< typename MeshEntity >

      Index getLinearSystemRowLength( const MeshType& mesh,

                                      const IndexType& index,

                                      const MeshEntity& entity ) const;



      template< typename MeshEntity, typename Vector, typename MatrixRow >

      __cuda_callable__

      void updateLinearSystem( const RealType& time,

                               const RealType& tau,

                               const MeshType& mesh,

                               const IndexType& index,

                               const MeshEntity& entity,

                               const MeshFunctionType& u,

                               Vector& b,

                               MatrixRow& matrixRow ) const;

};



template< typename MeshReal,

          typename Device,

          typename MeshIndex,

          typename Real,

          typename Index >

class EulerPressureGetter< tnlGrid< 3,MeshReal, Device, MeshIndex >, Real, Index >

{

   public:

      typedef tnlGrid< 3, MeshReal, Device, MeshIndex > MeshType;

      typedef typename MeshType::CoordinatesType CoordinatesType;

      typedef Real RealType;

      typedef Device DeviceType;

      typedef Index IndexType;

      typedef tnlMeshFunction< MeshType > MeshFunctionType;

      enum { Dimensions = MeshType::getMeshDimensions() };



      static tnlString getType();

      Real gamma;

      MeshFunctionType& velocity;

      MeshFunctionType& rhoVel;

      MeshFunctionType& energy;



      void setGamma(const Real& gamma)

      {

          this->gamma = gamma;

      };



      void setVelocity(const MeshFunctionType& velocity)

      {

          this->velocity = velocity;

      };



      void setRhoVel(const MeshFunctionType& rhoVel)

      {

          this->rhoVel = rhoVel;

      };



      void setEnergy(const MeshFunctionType& energy)

      {

          this->energy = energy;

      };



      template< typename MeshFunction, typename MeshEntity >

      __cuda_callable__

      Real operator()( const MeshFunction& u,

                       const MeshEntity& entity,

                       const RealType& time = 0.0 ) const;



      __cuda_callable__

      template< typename MeshEntity >

      Index getLinearSystemRowLength( const MeshType& mesh,

                                      const IndexType& index,

                                      const MeshEntity& entity ) const;



      template< typename MeshEntity, typename Vector, typename MatrixRow >

      __cuda_callable__

      void updateLinearSystem( const RealType& time,

                               const RealType& tau,

                               const MeshType& mesh,

                               const IndexType& index,

                               const MeshEntity& entity,

                               const MeshFunctionType& u,

                               Vector& b,

                               MatrixRow& matrixRow ) const;

};





#include "EulerPressureGetter_impl.h"



#endif	/* EulerPressureGetter_H */

examples/inviscid-flow/1d/EulerPressureGetter_impl.h

0 → 100644
+336 −0

File added.

Preview size limit exceeded, changes collapsed.

examples/inviscid-flow/1d/EulerPressureGetter_impl.h~

0 → 100644
+338 −0

File added.

Preview size limit exceeded, changes collapsed.

examples/inviscid-flow/1d/EulerVelGetter.h

0 → 100644
+181 −0
Original line number Diff line number Diff line 
#ifndef EulerVelGetter_H

#define EulerVelGetter_H



#include <core/vectors/tnlVector.h>

#include <mesh/tnlGrid.h>



template< typename Mesh,

          typename Real = typename Mesh::RealType,

          typename Index = typename Mesh::IndexType >

class EulerVelGetter

{

};



template< typename MeshReal,

          typename Device,

          typename MeshIndex,

          typename Real,

          typename Index >

class EulerVelGetter< tnlGrid< 1,MeshReal, Device, MeshIndex >, Real, Index >

{

   public:

      typedef tnlGrid< 1, MeshReal, Device, MeshIndex > MeshType;

      typedef typename MeshType::CoordinatesType CoordinatesType;

      typedef Real RealType;

      typedef Device DeviceType;

      typedef Index IndexType;

      typedef tnlMeshFunction< MeshType > MeshFunctionType;

      enum { Dimensions = MeshType::getMeshDimensions() };



      static tnlString getType();

      MeshFunctionType& rhoVel;

      MeshFunctionType& rho;



      void setRhoVel(const MeshFunctionType& rhoVel)

      {

          this->rhoVel = rhoVel;

      };



      void setRho(const MeshFunctionType& rho)

      {

          this->rho = rho;

      };



      template< typename MeshFunction, typename MeshEntity >

      __cuda_callable__

      Real operator()( const MeshFunction& u,

                       const MeshEntity& entity,

                       const RealType& time = 0.0 ) const;



      __cuda_callable__

      template< typename MeshEntity >

      Index getLinearSystemRowLength( const MeshType& mesh,

                                      const IndexType& index,

                                      const MeshEntity& entity ) const;



      template< typename MeshEntity, typename Vector, typename MatrixRow >

      __cuda_callable__

      void updateLinearSystem( const RealType& time,

                               const RealType& tau,

                               const MeshType& mesh,

                               const IndexType& index,

                               const MeshEntity& entity,

                               const MeshFunctionType& u,

                               Vector& b,

                               MatrixRow& matrixRow ) const;

};



template< typename MeshReal,

          typename Device,

          typename MeshIndex,

          typename Real,

          typename Index >

class EulerVelGetter< tnlGrid< 2,MeshReal, Device, MeshIndex >, Real, Index >

{

   public:

      typedef tnlGrid< 2, MeshReal, Device, MeshIndex > MeshType;

      typedef typename MeshType::CoordinatesType CoordinatesType;

      typedef Real RealType;

      typedef Device DeviceType;

      typedef Index IndexType;

      typedef tnlMeshFunction< MeshType > MeshFunctionType;

      enum { Dimensions = MeshType::getMeshDimensions() };



      static tnlString getType();

      MeshFunctionType& rhoVel;

      MeshFunctionType& rho;



      void setRhoVel(const MeshFunctionType& rhoVel)

      {

          this->rhoVel = rhoVel;

      };



      void setRho(const MeshFunctionType& rho)

      {

          this->rho = rho;

      };





      template< typename MeshFunction, typename MeshEntity >

      __cuda_callable__

      Real operator()( const MeshFunction& u,

                       const MeshEntity& entity,

                       const RealType& time = 0.0 ) const;



      __cuda_callable__

      template< typename MeshEntity >

      Index getLinearSystemRowLength( const MeshType& mesh,

                                      const IndexType& index,

                                      const MeshEntity& entity ) const;



      template< typename MeshEntity, typename Vector, typename MatrixRow >

      __cuda_callable__

      void updateLinearSystem( const RealType& time,

                               const RealType& tau,

                               const MeshType& mesh,

                               const IndexType& index,

                               const MeshEntity& entity,

                               const MeshFunctionType& u,

                               Vector& b,

                               MatrixRow& matrixRow ) const;

};



template< typename MeshReal,

          typename Device,

          typename MeshIndex,

          typename Real,

          typename Index >

class EulerVelGetter< tnlGrid< 3,MeshReal, Device, MeshIndex >, Real, Index >

{

   public:

      typedef tnlGrid< 3, MeshReal, Device, MeshIndex > MeshType;

      typedef typename MeshType::CoordinatesType CoordinatesType;

      typedef Real RealType;

      typedef Device DeviceType;

      typedef Index IndexType;

      typedef tnlMeshFunction< MeshType > MeshFunctionType;

      enum { Dimensions = MeshType::getMeshDimensions() };



      static tnlString getType();

      MeshFunctionType& rhoVel;

      MeshFunctionType& rho;



      void setRhoVel(const MeshFunctionType& rhoVel)

      {

          this->rhoVel = rhoVel;

      };



      void setRho(const MeshFunctionType& rho)

      {

          this->rho = rho;

      };





      template< typename MeshFunction, typename MeshEntity >

      __cuda_callable__

      Real operator()( const MeshFunction& u,

                       const MeshEntity& entity,

                       const RealType& time = 0.0 ) const;



      __cuda_callable__

      template< typename MeshEntity >

      Index getLinearSystemRowLength( const MeshType& mesh,

                                      const IndexType& index,

                                      const MeshEntity& entity ) const;



      template< typename MeshEntity, typename Vector, typename MatrixRow >

      __cuda_callable__

      void updateLinearSystem( const RealType& time,

                               const RealType& tau,

                               const MeshType& mesh,

                               const IndexType& index,

                               const MeshEntity& entity,

                               const MeshFunctionType& u,

                               Vector& b,

                               MatrixRow& matrixRow ) const;

};





#include "EulerVelGetter_impl.h"



#endif	/* EulerVelGetter_H */