From 94d3e79a8617f88dc0219cfdeedfa3147833719d Mon Sep 17 00:00:00 2001
From: Adrian Kummerlaender
Date: Mon, 24 Jun 2019 14:43:36 +0200
Subject: Initialize at openlb-1-3
---
src/functors/lattice/turbulentF3D.h | 477 ++++++++++++++++++++++++++++++++++++
1 file changed, 477 insertions(+)
create mode 100644 src/functors/lattice/turbulentF3D.h
(limited to 'src/functors/lattice/turbulentF3D.h')
diff --git a/src/functors/lattice/turbulentF3D.h b/src/functors/lattice/turbulentF3D.h
new file mode 100644
index 0000000..bea0dde
--- /dev/null
+++ b/src/functors/lattice/turbulentF3D.h
@@ -0,0 +1,477 @@
+/* This file is part of the OpenLB library
+ *
+ * Copyright (C) 2013-2015 Patrick Nathen, Mathias J. Krause
+ * E-mail contact: info@openlb.net
+ * The most recent release of OpenLB can be downloaded at
+ *
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+*/
+
+#ifndef TURBULENT_F_3D_H
+#define TURBULENT_F_3D_H
+
+#include
+
+#include "blockBaseF3D.h"
+#include "superBaseF3D.h"
+#include "blockLatticeLocalF3D.h"
+#include "superLatticeLocalF3D.h"
+#include "core/unitConverter.h"
+#include "functors/analytical/indicator/indicatorBaseF3D.h"
+
+
+/** These are functors used for turbulent flows. Some like AMD have an execute member
+ * function which writes the data into the external field of a lattice descriptor.
+ */
+
+namespace olb {
+
+/// functor to get pointwise yPlus from rho, shear stress and local density on local lattices
+template
+class SuperLatticeYplus3D : public SuperLatticePhysF3D {
+private:
+ SuperGeometry3D& _superGeometry;
+ IndicatorF3D& _indicator;
+ const int _material;
+public:
+ SuperLatticeYplus3D(SuperLattice3D& sLattice, const UnitConverter& converter,
+ SuperGeometry3D& superGeometry, IndicatorF3D& indicator,
+ const int material );
+ bool operator() (T output[], const int input[]) override;
+};
+
+/// functor to get pointwise explicit filtering on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+/*template
+class BlockLatticeADM3D : public BlockLatticeF3D {
+protected:
+ T _sigma;
+ int _order;
+ bool _adaptive;
+ const UnitConverter& _converter;
+
+public:
+ BlockLatticeADM3D(BlockLatticeStructure3D& blockLattice, T sigma, int order, bool adaptive, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+ void execute(const int input[]);
+ void execute();
+
+};
+
+/// functor to get pointwise ecplicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticeADM3D : public SuperLatticeF3D {
+protected:
+ T _sigma;
+ int _order;
+ bool _adaptive;
+ const UnitConverter& _converter;
+public:
+ SuperLatticeADM3D(SuperLattice3D& sLattice, T sigma, int order, bool adaptive, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+ void execute(SuperGeometry3D& superGeometry, const int material);
+};
+*/
+
+/// functor to get pointwise finite difference Dissipation on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class BlockFiniteDifference3D : public BlockF3D {
+private:
+ BlockGeometryStructure3D& _blockGeometry;
+ BlockF3D& _blockFunctor;
+ std::list& _matNumber;
+ int _targetDim;
+ int _n[3];
+
+public:
+ BlockFiniteDifference3D(BlockGeometryStructure3D& blockGeometry, BlockF3D& blockFunctor, std::list& matNumber);
+ bool operator() (T output[], const int input[]) override;
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperFiniteDifference3D : public SuperF3D {
+private:
+ SuperGeometry3D& _sGeometry;
+ SuperF3D& _sFunctor;
+ std::list& _matNumber;
+public:
+ SuperFiniteDifference3D(SuperGeometry3D& sGeometry, SuperF3D& sFunctor, std::list& matNumber);
+ bool operator() (T output[], const int input[]) override;
+};
+
+template
+class BlockPhysFiniteDifference3D : public BlockF3D {
+private:
+ BlockF3D& _blockFinDiff;
+ int _targetDim;
+ const UnitConverter& _converter;
+public:
+ BlockPhysFiniteDifference3D(BlockF3D& blockFunctor, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]) override;
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperPhysFiniteDifference3D : public SuperF3D {
+private:
+ SuperFiniteDifference3D _sFinDiff;
+ const UnitConverter& _converter;
+public:
+ SuperPhysFiniteDifference3D(SuperGeometry3D& sGeometry, SuperF3D& sFunctor, std::list& matNumber, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]) override;
+};
+
+template
+class BlockLatticeVelocityGradientFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockFinDiff;
+
+public:
+ BlockLatticeVelocityGradientFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor);
+ bool operator() (T output[], const int input[]);
+};
+
+template
+class BlockLatticeExternalVelocityGradientFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockFinDiff;
+
+public:
+ BlockLatticeExternalVelocityGradientFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticeVelocityGradientFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticeVelocity3D _sVelocity;
+ SuperFiniteDifference3D _sFinDiff;
+public:
+ SuperLatticeVelocityGradientFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticeExternalVelocityGradientFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticeExternalVelocity3D _sVelocity;
+ SuperFiniteDifference3D _sFinDiff;
+public:
+ SuperLatticeExternalVelocityGradientFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber);
+ bool operator() (T output[], const int input[]);
+};
+
+
+template
+class BlockLatticePhysVelocityGradientFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockFinDiff;
+ const UnitConverter& _converter;
+public:
+ BlockLatticePhysVelocityGradientFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]) override;
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticePhysVelocityGradientFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticePhysVelocity3D _sVelocity;
+ SuperPhysFiniteDifference3D _sFinDiff;
+ const UnitConverter& _converter;
+public:
+ SuperLatticePhysVelocityGradientFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]) override;
+};
+
+template
+class BlockLatticeStrainRateFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockVeloGrad;
+public:
+ BlockLatticeStrainRateFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticeStrainRateFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticeVelocityGradientFD3D _sVeloGrad;
+public:
+ SuperLatticeStrainRateFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber);
+ bool operator() (T output[], const int input[]);
+};
+
+template
+class BlockLatticePhysStrainRateFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockVeloGrad;
+ const UnitConverter& _converter;
+public:
+ BlockLatticePhysStrainRateFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticePhysStrainRateFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticePhysVelocityGradientFD3D _sVeloGrad;
+ const UnitConverter& _converter;
+public:
+ SuperLatticePhysStrainRateFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+};
+
+template
+class BlockLatticeDissipationFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockVeloGrad;
+ const UnitConverter& _converter;
+public:
+ BlockLatticeDissipationFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticeDissipationFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticeVelocityGradientFD3D _sVeloGrad;
+ const UnitConverter& _converter;
+public:
+ SuperLatticeDissipationFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+};
+
+template
+class BlockLatticePhysDissipationFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockVeloGrad;
+ const UnitConverter& _converter;
+public:
+ BlockLatticePhysDissipationFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor, const UnitConverter& _converter);
+ bool operator() (T output[], const int input[]) override;
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticePhysDissipationFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticePhysVelocityGradientFD3D _sVeloGrad;
+ const UnitConverter& _converter;
+public:
+ SuperLatticePhysDissipationFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]) override;
+};
+
+template
+class BlockLatticeEffectiveDissipationFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockVeloGrad;
+ const UnitConverter& _converter;
+ LESDynamics& _LESdynamics;
+public:
+ BlockLatticeEffectiveDissipationFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor,
+ const UnitConverter& converter, LESDynamics& LESdynamics);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticeEffectiveDissipationFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticeVelocityGradientFD3D _sVeloGrad;
+ const UnitConverter& _converter;
+public:
+ SuperLatticeEffectiveDissipationFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber,
+ const UnitConverter& converter, LESDynamics& LESdynamics);
+ bool operator() (T output[], const int input[]);
+};
+
+template
+class BlockLatticePhysEffectiveDissipationFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockVeloGrad;
+ const UnitConverter& _converter;
+ LESDynamics& _LESdynamics;
+public:
+ BlockLatticePhysEffectiveDissipationFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor,
+ const UnitConverter& converter, LESDynamics& LESdynamics);
+ bool operator() (T output[], const int input[]) override;
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticePhysEffectiveDissipationFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticePhysVelocityGradientFD3D _sVeloGrad;
+ const UnitConverter& _converter;
+public:
+ SuperLatticePhysEffectiveDissipationFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber,
+ const UnitConverter& converter, LESDynamics& LESdynamics);
+ bool operator() (T output[], const int input[]) override;
+};
+
+template
+class BlockLatticeVorticityFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockVeloGrad;
+public:
+ BlockLatticeVorticityFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticeVorticityFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticeVelocityGradientFD3D _sVeloGrad;
+public:
+ SuperLatticeVorticityFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber);
+ bool operator() (T output[], const int input[]);
+};
+
+template
+class BlockLatticePhysVorticityFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockVeloGrad;
+ const UnitConverter& _converter;
+public:
+ BlockLatticePhysVorticityFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticePhysVorticityFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticePhysVelocityGradientFD3D _sVeloGrad;
+ const UnitConverter& _converter;
+public:
+ SuperLatticePhysVorticityFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor that returns pointwise the enstrophy
+template
+class BlockLatticePhysEnstrophyFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockVeloGrad;
+ const UnitConverter& _converter;
+public:
+ BlockLatticePhysEnstrophyFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockVeloGrad, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+};
+
+template
+class SuperLatticePhysEnstrophyFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticePhysVelocityGradientFD3D _sVeloGrad;
+ const UnitConverter& _converter;
+public:
+ SuperLatticePhysEnstrophyFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+};
+
+template
+class BlockLatticePhysStressFD3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockStrainRate;
+ const UnitConverter& _converter;
+public:
+ BlockLatticePhysStressFD3D(BlockLatticeStructure3D& blockLattice, BlockF3D& blockFunctor, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticePhysStressFD3D : public SuperLatticeF3D {
+private:
+ SuperLatticePhysStrainRateFD3D _sStrainRate;
+ const UnitConverter& _converter;
+public:
+ SuperLatticePhysStressFD3D(SuperGeometry3D& sGeometry, SuperLattice3D& sLattice, std::list& matNumber, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor that returns pointwise the turbulent, kinetic energy
+template
+class BlockIsotropicHomogeneousTKE3D : public BlockLatticeF3D {
+private:
+ BlockF3D& _blockVelocity;
+
+public:
+ BlockIsotropicHomogeneousTKE3D(BlockLatticeStructure3D& blockLattice, BlockF3D& f);
+ bool operator() (T output[], const int input[]);
+};
+
+template
+class SuperIsotropicHomogeneousTKE3D : public SuperLatticeF3D {
+private:
+ SuperLatticePhysVelocity3D _sVelocity;
+ const UnitConverter& _converter;
+public:
+ SuperIsotropicHomogeneousTKE3D( SuperLattice3D& sLattice, const UnitConverter& converter);
+ bool operator() (T output[], const int input[]);
+};
+
+/*
+template
+class BlockLatticeSigmaADM3D : public BlockLatticeF3D {
+protected:
+public:
+ BlockLatticeSigmaADM3D(BlockLatticeStructure3D& blockLattice);
+ bool operator() (T output[], const int input[]);
+};
+
+/// functor to get pointwise explicit filter on local lattice, if globIC is not on
+/// the local processor, the returned vector is empty
+template
+class SuperLatticeSigmaADM3D : public SuperLatticeF3D