Commit 9759c6ab authored by Jan Schäfer's avatar Jan Schäfer Committed by Jakub Klinkovský
Browse files

added Prandtl, PrandtlKolmogorov, KOmega and KEpsilon Solvers. Prandtl not working yet

parent 8391172d

src/Examples/CMakeLists.txt

+2 −1
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ add_subdirectory( transport-equation ) 
#add_subdirectory( inviscid-flow-vl )

#add_subdirectory( mean-curvature-flow )

add_subdirectory( flows )

add_subdirectory( turbulent-flows )





ADD_EXECUTABLE( ConfigDescriptionExample ConfigDescriptionExample.cpp )

src/Examples/turbulent-flows/CMakeLists.txt

0 → 100644
+3 −0
Original line number Diff line number Diff line 
#add_subdirectory( zero-equation-model )

add_subdirectory( one-equation-model )

add_subdirectory( two-equation-model )

src/Examples/turbulent-flows/one-equation-model/BoundaryConditions/Boiler/BoundaryConditionsBoiler.h

0 → 100644
+168 −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"

#include "TurbulentEnergyBoundaryConditionBoiler.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 TNL::Operators::TurbulentEnergyBoundaryConditionsBoiler< MeshType, FunctionType, RealType, IndexType > TurbulentEnergyBoundaryConditionsType;

      typedef CompressibleConservativeVariables< MeshType > CompressibleConservativeVariablesType;



      typedef Pointers::SharedPointer< DensityBoundaryConditionsType > DensityBoundaryConditionsTypePointer;

      typedef Pointers::SharedPointer< MomentumXBoundaryConditionsType > MomentumXBoundaryConditionsTypePointer;

      typedef Pointers::SharedPointer< MomentumYBoundaryConditionsType > MomentumYBoundaryConditionsTypePointer;

      typedef Pointers::SharedPointer< MomentumZBoundaryConditionsType > MomentumZBoundaryConditionsTypePointer;

      typedef Pointers::SharedPointer< EnergyBoundaryConditionsType > EnergyBoundaryConditionsTypePointer;

      typedef Pointers::SharedPointer< TurbulentEnergyBoundaryConditionsType > TurbulentEnergyBoundaryConditionsTypePointer;

      typedef Pointers::SharedPointer< CompressibleConservativeVariablesType > CompressibleConservativeVariablesPointer;

      typedef Pointers::SharedPointer< MeshType > MeshPointer;

      typedef Pointers::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);

         this->turbulentEnergyBoundaryConditionsPointer->setCavitySpeed(cavitySpeed);

      }



      void setIntensity(const RealType& intensity)

      {

         this->turbulentEnergyBoundaryConditionsPointer->setIntensity( intensity );

      }



      void setHorizontalThrottleSpeed(const RealType startSpeed,

                                      const RealType finalSpeed,

                                      const RealType time,

                                      const RealType finalTime )

      {



      }



      void setVerticalThrottleSpeed(const RealType startSpeed,

                                    const RealType finalSpeed,

                                    const RealType time,

                                    const RealType finalTime )

      {



      }



      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;

      }



      TurbulentEnergyBoundaryConditionsTypePointer& getTurbulentEnergyBoundaryCondition()

      {

         return this->turbulentEnergyBoundaryConditionsPointer;

      }





   protected:

      DensityBoundaryConditionsTypePointer densityBoundaryConditionsPointer;

      MomentumXBoundaryConditionsTypePointer momentumXBoundaryConditionsPointer;

      MomentumYBoundaryConditionsTypePointer momentumYBoundaryConditionsPointer;

      MomentumZBoundaryConditionsTypePointer momentumZBoundaryConditionsPointer;

      EnergyBoundaryConditionsTypePointer energyBoundaryConditionsPointer;

      TurbulentEnergyBoundaryConditionsTypePointer turbulentEnergyBoundaryConditionsPointer;



};



} //namespace TNL

src/Examples/turbulent-flows/one-equation-model/BoundaryConditions/Boiler/CompressibleConservativeVariables.h

0 → 100644
+156 −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/Pointers/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 Pointers::SharedPointer< MeshType > MeshPointer;      

      typedef Pointers::SharedPointer< MeshFunctionType > MeshFunctionPointer;

      typedef Pointers::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 );

      }

      

      __cuda_callable__

      MeshFunctionPointer& getDensity()

      {

         return this->density;

      }



      __cuda_callable__

      const MeshFunctionPointer& getDensity() const

      {

         return this->density;

      }

      

      void setDensity( MeshFunctionPointer& density )

      {

         this->density = density;

      }

      

      __cuda_callable__

      MomentumFieldPointer& getMomentum()

      {

         return this->momentum;

      }

      

      __cuda_callable__

      const MomentumFieldPointer& getMomentum() const

      {

         return this->momentum;

      }

      

      void setMomentum( MomentumFieldPointer& momentum )

      {

         this->momentum = momentum;

      }

      

      /*

      __cuda_callable__

      MeshFunctionPointer& getPressure()

      {

         return this->pressure;

      }

      

      __cuda_callable__

      const MeshFunctionPointer& getPressure() const

      {

         return this->pressure;

      }

      

      void setPressure( MeshFunctionPointer& pressure )

      {

         this->pressure = pressure;

      }*/

      

      __cuda_callable__

      MeshFunctionPointer& getEnergy()

      {

         return this->energy;

      }

      

      __cuda_callable__

      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 TNL

src/Examples/turbulent-flows/one-equation-model/BoundaryConditions/Boiler/DensityBoundaryConditionBoiler.h

0 → 100644
+542 −0

File added.

Preview size limit exceeded, changes collapsed.