added NS flow stegger-warming and van-leer solvers and van-leer solver for inviscid flow (dcf7c201) · Commits · TNL / tnl-dev

examples/CMakeLists.txt

+2 −0

Original line number	Diff line number	Diff line
		@@ -12,6 +12,8 @@ add_subdirectory( navier-stokes )

		add_subdirectory( inviscid-flow )
		add_subdirectory( inviscid-flow-sw )
		add_subdirectory( inviscid-flow-vl )
		#add_subdirectory( mean-curvature-flow )
		add_subdirectory( flow )
		add_subdirectory( flow-sw )
		add_subdirectory( flow-vl )

examples/flow-vl/BoundaryConditionsBoiler.h

0 → 100644

+137 −0

Original line number	Diff line number	Diff line
		#include <TNL/Functions/FunctionAdapter.h>

		#include "DensityBoundaryConditionBoiler.h"
		#include "MomentumXBoundaryConditionBoiler.h"
		#include "MomentumYBoundaryConditionBoiler.h"
		#include "MomentumZBoundaryConditionBoiler.h"
		#include "EnergyBoundaryConditionBoiler.h"

		namespace TNL {

		template< typename Mesh,
		typename Function,
		typename Real = typename Mesh::RealType,
		typename Index = typename Mesh::IndexType >
		class BoundaryConditionsBoiler
		{
		public:
		typedef Mesh MeshType;
		typedef Real RealType;
		typedef Index IndexType;
		typedef Function FunctionType;
		typedef Functions::MeshFunction< Mesh > MeshFunctionType;
		typedef typename Mesh::DeviceType DeviceType;

		typedef TNL::Operators::DensityBoundaryConditionsBoiler< MeshType, FunctionType, RealType, IndexType > DensityBoundaryConditionsType;
		typedef TNL::Operators::MomentumXBoundaryConditionsBoiler< MeshType, FunctionType, RealType, IndexType > MomentumXBoundaryConditionsType;
		typedef TNL::Operators::MomentumYBoundaryConditionsBoiler< MeshType, FunctionType, RealType, IndexType > MomentumYBoundaryConditionsType;
		typedef TNL::Operators::MomentumZBoundaryConditionsBoiler< MeshType, FunctionType, RealType, IndexType > MomentumZBoundaryConditionsType;
		typedef TNL::Operators::EnergyBoundaryConditionsBoiler< MeshType, FunctionType, RealType, IndexType > EnergyBoundaryConditionsType;
		typedef CompressibleConservativeVariables< MeshType > CompressibleConservativeVariablesType;

		typedef SharedPointer< DensityBoundaryConditionsType > DensityBoundaryConditionsTypePointer;
		typedef SharedPointer< MomentumXBoundaryConditionsType > MomentumXBoundaryConditionsTypePointer;
		typedef SharedPointer< MomentumYBoundaryConditionsType > MomentumYBoundaryConditionsTypePointer;
		typedef SharedPointer< MomentumZBoundaryConditionsType > MomentumZBoundaryConditionsTypePointer;
		typedef SharedPointer< EnergyBoundaryConditionsType > EnergyBoundaryConditionsTypePointer;
		typedef SharedPointer< CompressibleConservativeVariablesType > CompressibleConservativeVariablesPointer;
		typedef SharedPointer< MeshType > MeshPointer;
		typedef SharedPointer< MeshFunctionType, DeviceType > MeshFunctionPointer;

		static void configSetup( Config::ConfigDescription& config,
		const String& prefix = "" )
		{
		}

		bool setup( const MeshPointer& meshPointer,
		const Config::ParameterContainer& parameters,
		const String& prefix = "" )
		{
		this->densityBoundaryConditionsPointer->setup( meshPointer, parameters, prefix);
		this->momentumXBoundaryConditionsPointer->setup( meshPointer, parameters, prefix);
		this->momentumYBoundaryConditionsPointer->setup( meshPointer, parameters, prefix);
		this->momentumZBoundaryConditionsPointer->setup( meshPointer, parameters, prefix);
		this->energyBoundaryConditionsPointer->setup( meshPointer, parameters, prefix);
		return true;
		}

		void setCompressibleConservativeVariables(const CompressibleConservativeVariablesPointer& compressibleConservativeVariables)
		{
		this->densityBoundaryConditionsPointer->setCompressibleConservativeVariables(compressibleConservativeVariables);
		this->momentumXBoundaryConditionsPointer->setCompressibleConservativeVariables(compressibleConservativeVariables);
		this->momentumYBoundaryConditionsPointer->setCompressibleConservativeVariables(compressibleConservativeVariables);
		this->momentumZBoundaryConditionsPointer->setCompressibleConservativeVariables(compressibleConservativeVariables);
		this->energyBoundaryConditionsPointer->setCompressibleConservativeVariables(compressibleConservativeVariables);
		}

		void setTimestep(const RealType timestep)
		{
		this->densityBoundaryConditionsPointer->setTimestep(timestep);
		this->momentumXBoundaryConditionsPointer->setTimestep(timestep);
		this->momentumYBoundaryConditionsPointer->setTimestep(timestep);
		this->momentumZBoundaryConditionsPointer->setTimestep(timestep);
		this->energyBoundaryConditionsPointer->setTimestep(timestep);
		}

		void setGamma(const RealType gamma)
		{
		this->densityBoundaryConditionsPointer->setGamma(gamma);
		this->momentumXBoundaryConditionsPointer->setGamma(gamma);
		this->momentumYBoundaryConditionsPointer->setGamma(gamma);
		this->momentumZBoundaryConditionsPointer->setGamma(gamma);
		this->energyBoundaryConditionsPointer->setGamma(gamma);
		}

		void setPressure(const MeshFunctionPointer& pressure)
		{
		this->densityBoundaryConditionsPointer->setPressure(pressure);
		this->momentumXBoundaryConditionsPointer->setPressure(pressure);
		this->momentumYBoundaryConditionsPointer->setPressure(pressure);
		this->momentumZBoundaryConditionsPointer->setPressure(pressure);
		this->energyBoundaryConditionsPointer->setPressure(pressure);
		}

		void setSpeed(const RealType cavitySpeed)
		{
		this->momentumXBoundaryConditionsPointer->setCavitySpeed(cavitySpeed);
		this->momentumYBoundaryConditionsPointer->setCavitySpeed(cavitySpeed);
		this->momentumZBoundaryConditionsPointer->setCavitySpeed(cavitySpeed);
		this->energyBoundaryConditionsPointer->setCavitySpeed(cavitySpeed);
		}

		DensityBoundaryConditionsTypePointer& getDensityBoundaryCondition()
		{
		return this->densityBoundaryConditionsPointer;
		}

		MomentumXBoundaryConditionsTypePointer& getMomentumXBoundaryCondition()
		{
		return this->momentumXBoundaryConditionsPointer;
		}

		MomentumYBoundaryConditionsTypePointer& getMomentumYBoundaryCondition()
		{
		return this->momentumYBoundaryConditionsPointer;
		}

		MomentumZBoundaryConditionsTypePointer& getMomentumZBoundaryCondition()
		{
		return this->momentumZBoundaryConditionsPointer;
		}

		EnergyBoundaryConditionsTypePointer& getEnergyBoundaryCondition()
		{
		return this->energyBoundaryConditionsPointer;
		}


		protected:
		DensityBoundaryConditionsTypePointer densityBoundaryConditionsPointer;
		MomentumXBoundaryConditionsTypePointer momentumXBoundaryConditionsPointer;
		MomentumYBoundaryConditionsTypePointer momentumYBoundaryConditionsPointer;
		MomentumZBoundaryConditionsTypePointer momentumZBoundaryConditionsPointer;
		EnergyBoundaryConditionsTypePointer energyBoundaryConditionsPointer;

		};

		} //namespace TNL

examples/flow-vl/BoundaryConditionsCavity.h

0 → 100644

+137 −0

Original line number	Diff line number	Diff line
		#include <TNL/Functions/FunctionAdapter.h>

		#include "DensityBoundaryConditionCavity.h"
		#include "MomentumXBoundaryConditionCavity.h"
		#include "MomentumYBoundaryConditionCavity.h"
		#include "MomentumZBoundaryConditionCavity.h"
		#include "EnergyBoundaryConditionCavity.h"

		namespace TNL {

		template< typename Mesh,
		typename Function,
		typename Real = typename Mesh::RealType,
		typename Index = typename Mesh::IndexType >
		class BoundaryConditionsCavity
		{
		public:
		typedef Mesh MeshType;
		typedef Real RealType;
		typedef Index IndexType;
		typedef Function FunctionType;
		typedef Functions::MeshFunction< Mesh > MeshFunctionType;
		typedef typename Mesh::DeviceType DeviceType;

		typedef TNL::Operators::DensityBoundaryConditionsCavity< MeshType, FunctionType, RealType, IndexType > DensityBoundaryConditionsType;
		typedef TNL::Operators::MomentumXBoundaryConditionsCavity< MeshType, FunctionType, RealType, IndexType > MomentumXBoundaryConditionsType;
		typedef TNL::Operators::MomentumYBoundaryConditionsCavity< MeshType, FunctionType, RealType, IndexType > MomentumYBoundaryConditionsType;
		typedef TNL::Operators::MomentumZBoundaryConditionsCavity< MeshType, FunctionType, RealType, IndexType > MomentumZBoundaryConditionsType;
		typedef TNL::Operators::EnergyBoundaryConditionsCavity< MeshType, FunctionType, RealType, IndexType > EnergyBoundaryConditionsType;
		typedef CompressibleConservativeVariables< MeshType > CompressibleConservativeVariablesType;

		typedef SharedPointer< DensityBoundaryConditionsType > DensityBoundaryConditionsTypePointer;
		typedef SharedPointer< MomentumXBoundaryConditionsType > MomentumXBoundaryConditionsTypePointer;
		typedef SharedPointer< MomentumYBoundaryConditionsType > MomentumYBoundaryConditionsTypePointer;
		typedef SharedPointer< MomentumZBoundaryConditionsType > MomentumZBoundaryConditionsTypePointer;
		typedef SharedPointer< EnergyBoundaryConditionsType > EnergyBoundaryConditionsTypePointer;
		typedef SharedPointer< CompressibleConservativeVariablesType > CompressibleConservativeVariablesPointer;
		typedef SharedPointer< MeshType > MeshPointer;
		typedef SharedPointer< MeshFunctionType, DeviceType > MeshFunctionPointer;

		static void configSetup( Config::ConfigDescription& config,
		const String& prefix = "" )
		{
		}

		bool setup( const MeshPointer& meshPointer,
		const Config::ParameterContainer& parameters,
		const String& prefix = "" )
		{
		this->densityBoundaryConditionsPointer->setup( meshPointer, parameters, prefix);
		this->momentumXBoundaryConditionsPointer->setup( meshPointer, parameters, prefix);
		this->momentumYBoundaryConditionsPointer->setup( meshPointer, parameters, prefix);
		this->momentumZBoundaryConditionsPointer->setup( meshPointer, parameters, prefix);
		this->energyBoundaryConditionsPointer->setup( meshPointer, parameters, prefix);
		return true;
		}

		void setCompressibleConservativeVariables(const CompressibleConservativeVariablesPointer& compressibleConservativeVariables)
		{
		this->densityBoundaryConditionsPointer->setCompressibleConservativeVariables(compressibleConservativeVariables);
		this->momentumXBoundaryConditionsPointer->setCompressibleConservativeVariables(compressibleConservativeVariables);
		this->momentumYBoundaryConditionsPointer->setCompressibleConservativeVariables(compressibleConservativeVariables);
		this->momentumZBoundaryConditionsPointer->setCompressibleConservativeVariables(compressibleConservativeVariables);
		this->energyBoundaryConditionsPointer->setCompressibleConservativeVariables(compressibleConservativeVariables);
		}

		void setTimestep(const RealType timestep)
		{
		this->densityBoundaryConditionsPointer->setTimestep(timestep);
		this->momentumXBoundaryConditionsPointer->setTimestep(timestep);
		this->momentumYBoundaryConditionsPointer->setTimestep(timestep);
		this->momentumZBoundaryConditionsPointer->setTimestep(timestep);
		this->energyBoundaryConditionsPointer->setTimestep(timestep);
		}

		void setGamma(const RealType gamma)
		{
		this->densityBoundaryConditionsPointer->setGamma(gamma);
		this->momentumXBoundaryConditionsPointer->setGamma(gamma);
		this->momentumYBoundaryConditionsPointer->setGamma(gamma);
		this->momentumZBoundaryConditionsPointer->setGamma(gamma);
		this->energyBoundaryConditionsPointer->setGamma(gamma);
		}

		void setPressure(const MeshFunctionPointer& pressure)
		{
		this->densityBoundaryConditionsPointer->setPressure(pressure);
		this->momentumXBoundaryConditionsPointer->setPressure(pressure);
		this->momentumYBoundaryConditionsPointer->setPressure(pressure);
		this->momentumZBoundaryConditionsPointer->setPressure(pressure);
		this->energyBoundaryConditionsPointer->setPressure(pressure);
		}

		void setSpeed(const RealType cavitySpeed)
		{
		this->momentumXBoundaryConditionsPointer->setCavitySpeed(cavitySpeed);
		this->momentumYBoundaryConditionsPointer->setCavitySpeed(cavitySpeed);
		this->momentumZBoundaryConditionsPointer->setCavitySpeed(cavitySpeed);
		this->energyBoundaryConditionsPointer->setCavitySpeed(cavitySpeed);
		}

		DensityBoundaryConditionsTypePointer& getDensityBoundaryCondition()
		{
		return this->densityBoundaryConditionsPointer;
		}

		MomentumXBoundaryConditionsTypePointer& getMomentumXBoundaryCondition()
		{
		return this->momentumXBoundaryConditionsPointer;
		}

		MomentumYBoundaryConditionsTypePointer& getMomentumYBoundaryCondition()
		{
		return this->momentumYBoundaryConditionsPointer;
		}

		MomentumZBoundaryConditionsTypePointer& getMomentumZBoundaryCondition()
		{
		return this->momentumZBoundaryConditionsPointer;
		}

		EnergyBoundaryConditionsTypePointer& getEnergyBoundaryCondition()
		{
		return this->energyBoundaryConditionsPointer;
		}


		protected:
		DensityBoundaryConditionsTypePointer densityBoundaryConditionsPointer;
		MomentumXBoundaryConditionsTypePointer momentumXBoundaryConditionsPointer;
		MomentumYBoundaryConditionsTypePointer momentumYBoundaryConditionsPointer;
		MomentumZBoundaryConditionsTypePointer momentumZBoundaryConditionsPointer;
		EnergyBoundaryConditionsTypePointer energyBoundaryConditionsPointer;

		};

		} //namespace TNL

examples/flow-vl/CMakeLists.txt

0 → 100644

+23 −0

Original line number	Diff line number	Diff line
		set( tnl_flow_vl_HEADERS
		CompressibleConservativeVariables.h )

		set( tnl_flow_vl_SOURCES
		navierStokes.cpp
		navierStokes.cu )

		IF( BUILD_CUDA )
		CUDA_ADD_EXECUTABLE(tnl-navier-stokes-vl${debugExt} navierStokes.cu)
		target_link_libraries (tnl-navier-stokes-vl${debugExt} tnl${debugExt}-${tnlVersion} ${CUSPARSE_LIBRARY} )
		ELSE( BUILD_CUDA )
		ADD_EXECUTABLE(tnl-navier-stokes-vl${debugExt} navierStokes.cpp)
		target_link_libraries (tnl-navier-stokes-vl${debugExt} tnl${debugExt}-${tnlVersion} )
		ENDIF( BUILD_CUDA )


		INSTALL( TARGETS tnl-navier-stokes-vl${debugExt}
		RUNTIME DESTINATION bin
		PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE )

		INSTALL( FILES run-navier-stokes-vl
		${tnl_inviscid_flow_SOURCES}
		DESTINATION share/tnl-${tnlVersion}/examples/navier-stokes-vl )

examples/flow-vl/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