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

added navier-stokes, euler in 2d works, added riemann initial condition choice

parent 41ce55f0

examples/CMakeLists.txt

+1 −1
Original line number Diff line number Diff line
@@ -12,4 +12,4 @@ add_subdirectory( navier-stokes ) 


add_subdirectory( inviscid-flow )

#add_subdirectory( mean-curvature-flow )

add_subdirectory( flow )

examples/flow/CMakeLists.txt

0 → 100644
+23 −0
Original line number Diff line number Diff line 
set( tnl_flow_HEADERS

     CompressibleConservativeVariables.h )



set( tnl_flow_SOURCES     

     navierStokes.cpp

     navierStokes.cu )

               

IF( BUILD_CUDA )

   CUDA_ADD_EXECUTABLE(tnl-navier-stokes${debugExt} navierStokes.cu)

   target_link_libraries (tnl-navier-stokes${debugExt} tnl${debugExt}-${tnlVersion}  ${CUSPARSE_LIBRARY} )

ELSE(  BUILD_CUDA )               

   ADD_EXECUTABLE(tnl-navier-stokes${debugExt} navierStokes.cpp)     

   target_link_libraries (tnl-navier-stokes${debugExt} tnl${debugExt}-${tnlVersion} )

ENDIF( BUILD_CUDA )





INSTALL( TARGETS tnl-navier-stokes${debugExt}

         RUNTIME DESTINATION bin

         PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE )

        

INSTALL( FILES run-navier-stokes

               ${tnl_inviscid_flow_SOURCES}

         DESTINATION share/tnl-${tnlVersion}/examples/flow )

examples/flow/CompressibleConservativeVariables.h

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

                          CompressibleConservativeVariables.h  -  description

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

    begin                : Feb 12, 2017

    copyright            : (C) 2017 by Tomas Oberhuber

    email                : tomas.oberhuber@fjfi.cvut.cz

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



/* See Copyright Notice in tnl/Copyright */





#pragma once



#include <TNL/Functions/MeshFunction.h>

#include <TNL/Functions/VectorField.h>

#include <TNL/SharedPointer.h>



namespace TNL {



template< typename Mesh >

class CompressibleConservativeVariables

{

   public:

      typedef Mesh MeshType;

      static const int Dimensions = MeshType::getMeshDimension();

      typedef typename MeshType::RealType RealType;

      typedef typename MeshType::DeviceType DeviceType;

      typedef typename MeshType::IndexType IndexType;

      typedef Functions::MeshFunction< Mesh > MeshFunctionType;

      typedef Functions::VectorField< Dimensions, MeshFunctionType > VelocityFieldType;

      typedef SharedPointer< MeshType > MeshPointer;      

      typedef SharedPointer< MeshFunctionType > MeshFunctionPointer;

      typedef SharedPointer< VelocityFieldType > MomentumFieldPointer;

      

      CompressibleConservativeVariables(){};

      

      CompressibleConservativeVariables( const MeshPointer& meshPointer )

      : density( meshPointer ),

        momentum( meshPointer ),

        //pressure( meshPointer ),

        energy( meshPointer ){};

        

      void setMesh( const MeshPointer& meshPointer )

      {

         this->density->setMesh( meshPointer );

         this->momentum->setMesh( meshPointer );

         //this->pressure.setMesh( meshPointer );

         this->energy->setMesh( meshPointer );

      }

      

      template< typename Vector >

      void bind( const MeshPointer& meshPointer,

                 const Vector& data,

                 IndexType offset = 0 )

      {

         IndexType currentOffset( offset );

         this->density->bind( meshPointer, data, currentOffset );

         currentOffset += this->density->getDofs( meshPointer );

         for( IndexType i = 0; i < Dimensions; i++ )

         {

            ( *this->momentum )[ i ]->bind( meshPointer, data, currentOffset );

            currentOffset += ( *this->momentum )[ i ]->getDofs( meshPointer );

         }

         this->energy->bind( meshPointer, data, currentOffset );

      }

      

      IndexType getDofs( const MeshPointer& meshPointer ) const

      {

         return this->density->getDofs( meshPointer ) + 

            this->momentum->getDofs( meshPointer ) +

            this->energy->getDofs( meshPointer );

      }

      

      MeshFunctionPointer& getDensity()

      {

         return this->density;

      }



      const MeshFunctionPointer& getDensity() const

      {

         return this->density;

      }

      

      void setDensity( MeshFunctionPointer& density )

      {

         this->density = density;

      }

      

      MomentumFieldPointer& getMomentum()

      {

         return this->momentum;

      }

      

      const MomentumFieldPointer& getMomentum() const

      {

         return this->momentum;

      }

      

      void setMomentum( MomentumFieldPointer& momentum )

      {

         this->momentum = momentum;

      }

      

      /*MeshFunctionPointer& getPressure()

      {

         return this->pressure;

      }

      

      const MeshFunctionPointer& getPressure() const

      {

         return this->pressure;

      }

      

      void setPressure( MeshFunctionPointer& pressure )

      {

         this->pressure = pressure;

      }*/

      

      MeshFunctionPointer& getEnergy()

      {

         return this->energy;

      }

      

      const MeshFunctionPointer& getEnergy() const

      {

         return this->energy;

      }

      

      void setEnergy( MeshFunctionPointer& energy )

      {

         this->energy = energy;

      }

      

      void getVelocityField( VelocityFieldType& velocityField )

      {

         

      }



   protected:

      

      MeshFunctionPointer density;

      MomentumFieldPointer momentum;

      MeshFunctionPointer energy;

      

};



} // namespace TN
 
 No newline at end of file

examples/flow/LaxFridrichs.h

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

                          LaxFridrichs.h  -  description

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

    begin                : Feb 18, 2017

    copyright            : (C) 2017 by Tomas Oberhuber

    email                : tomas.oberhuber@fjfi.cvut.cz

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



/* See Copyright Notice in tnl/Copyright */





#pragma once



#include <TNL/Containers/Vector.h>

#include <TNL/Meshes/Grid.h>

#include <TNL/Functions/VectorField.h>



#include "LaxFridrichsContinuity.h"

#include "LaxFridrichsEnergy.h"

#include "LaxFridrichsMomentumX.h"

#include "LaxFridrichsMomentumY.h"

#include "LaxFridrichsMomentumZ.h"



namespace TNL {



template< typename Mesh,

          typename Real = typename Mesh::RealType,

          typename Index = typename Mesh::IndexType >

class LaxFridrichs

{

   public:

      typedef Mesh MeshType;

      typedef Real RealType;

      typedef typename Mesh::DeviceType DeviceType;

      typedef Index IndexType;

      typedef Functions::MeshFunction< Mesh > MeshFunctionType;

      static const int Dimensions = Mesh::getMeshDimension();

      typedef Functions::VectorField< Dimensions, MeshFunctionType > VectorFieldType;

 

      typedef LaxFridrichsContinuity< Mesh, Real, Index > ContinuityOperatorType;

      typedef LaxFridrichsMomentumX< Mesh, Real, Index > MomentumXOperatorType;

      typedef LaxFridrichsMomentumY< Mesh, Real, Index > MomentumYOperatorType;

      typedef LaxFridrichsMomentumZ< Mesh, Real, Index > MomentumZOperatorType;

      typedef LaxFridrichsEnergy< Mesh, Real, Index > EnergyOperatorType;



      typedef SharedPointer< MeshFunctionType > MeshFunctionPointer;

      typedef SharedPointer< VectorFieldType > VectorFieldPointer;

      typedef SharedPointer< MeshType > MeshPointer;

      

      typedef SharedPointer< ContinuityOperatorType > ContinuityOperatorPointer;

      typedef SharedPointer< MomentumXOperatorType > MomentumXOperatorPointer;

      typedef SharedPointer< MomentumYOperatorType > MomentumYOperatorPointer;      

      typedef SharedPointer< MomentumZOperatorType > MomentumZOperatorPointer;      

      typedef SharedPointer< EnergyOperatorType > EnergyOperatorPointer;



      static void configSetup( Config::ConfigDescription& config,

                               const String& prefix = "" )

      {

         config.addEntry< double >( prefix + "numerical-viscosity", "Value of artificial (numerical) viscosity in the Lax-Fridrichs scheme", 1.0 );

         config.addEntry< double >( prefix + "dynamical-viscosity", "Value of dynamical (real) viscosity in the Navier-Stokes equation", 1.0 );

      }

      

      LaxFridrichs()

         : artificialViscosity( 1.0 ) {}

      

      bool setup( const MeshPointer& meshPointer,

                  const Config::ParameterContainer& parameters,

                  const String& prefix = "" )

      {

         this->dynamicalViscosity = parameters.getParameter< double >( prefix + "dynamical-viscosity" );

         this->momentumXOperatorPointer->setDynamicalViscosity( artificialViscosity );

         this->momentumYOperatorPointer->setDynamicalViscosity( artificialViscosity );

         this->momentumZOperatorPointer->setDynamicalViscosity( artificialViscosity );

         this->energyOperatorPointer->setDynamicalViscosity( artificialViscosity );

         this->artificialViscosity = parameters.getParameter< double >( prefix + "numerical-viscosity" );

         this->continuityOperatorPointer->setArtificialViscosity( artificialViscosity );

         this->momentumXOperatorPointer->setArtificialViscosity( artificialViscosity );

         this->momentumYOperatorPointer->setArtificialViscosity( artificialViscosity );

         this->momentumZOperatorPointer->setArtificialViscosity( artificialViscosity );

         this->energyOperatorPointer->setArtificialViscosity( artificialViscosity );

         

         return true;

      }

      

      void setTau( const RealType& tau )

      {

         this->continuityOperatorPointer->setTau( tau );

         this->momentumXOperatorPointer->setTau( tau );

         this->momentumYOperatorPointer->setTau( tau );

         this->momentumZOperatorPointer->setTau( tau );

         this->energyOperatorPointer->setTau( tau );

      }

      

      void setPressure( const MeshFunctionPointer& pressure )

      {

         this->momentumXOperatorPointer->setPressure( pressure );

         this->momentumYOperatorPointer->setPressure( pressure );

         this->momentumZOperatorPointer->setPressure( pressure );

         this->energyOperatorPointer->setPressure( pressure );

      }

      

      void setVelocity( const VectorFieldPointer& velocity )

      {

         this->continuityOperatorPointer->setVelocity( velocity );

         this->momentumXOperatorPointer->setVelocity( velocity );

         this->momentumYOperatorPointer->setVelocity( velocity );

         this->momentumZOperatorPointer->setVelocity( velocity );

         this->energyOperatorPointer->setVelocity( velocity );

      }

      

      const ContinuityOperatorPointer& getContinuityOperator() const

      {

         return this->continuityOperatorPointer;

      }

      

      const MomentumXOperatorPointer& getMomentumXOperator() const

      {

         return this->momentumXOperatorPointer;

      }



      const MomentumYOperatorPointer& getMomentumYOperator() const

      {

         return this->momentumYOperatorPointer;

      }

      

      const MomentumZOperatorPointer& getMomentumZOperator() const

      {

         return this->momentumZOperatorPointer;

      }

      

      const EnergyOperatorPointer& getEnergyOperator() const

      {

         return this->energyOperatorPointer;

      }



   protected:

      

      ContinuityOperatorPointer continuityOperatorPointer;

      MomentumXOperatorPointer momentumXOperatorPointer;

      MomentumYOperatorPointer momentumYOperatorPointer;

      MomentumZOperatorPointer momentumZOperatorPointer;

      EnergyOperatorPointer energyOperatorPointer;  

      

      RealType artificialViscosity;

      RealType dynamicalViscosity;

};



} //namespace TNL

examples/flow/LaxFridrichsContinuity.h

0 → 100644
+290 −0

File added.

Preview size limit exceeded, changes collapsed.