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/analytical/frameChangeF2D.h | 171 +++++++++++++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 src/functors/analytical/frameChangeF2D.h (limited to 'src/functors/analytical/frameChangeF2D.h') diff --git a/src/functors/analytical/frameChangeF2D.h b/src/functors/analytical/frameChangeF2D.h new file mode 100644 index 0000000..52fcbb1 --- /dev/null +++ b/src/functors/analytical/frameChangeF2D.h @@ -0,0 +1,171 @@ +/* This file is part of the OpenLB library + * + * Copyright (C) 2014-2015 Mathias J. Krause, Marie-Luise Maier + * 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 ANALYTICAL_FRAME_CHANGE_F_2D_H +#define ANALYTICAL_FRAME_CHANGE_F_2D_H + +#include +#include +#include +#include"math.h" + +#include "functors/genericF.h" +#include "analyticalF.h" +#include "core/superLattice2D.h" + +/** \file + This file contains two different classes of functors, in the FIRST part + - for simulations in a rotating frame + - different functors for + velocity (3d, RotatingLinear3D), + pressure (1d, RotatingQuadratic1D) and + force (3d, RotatingForceField3D) + The functors return the displacement of a point x in a fixed amount of time. + + The ones in the SECOND part are useful to set Poiseuille velocity profiles on + - pipes with round cross-section and + - pipes with square-shaped cross-section. +*/ + +/** To enable simulations in a rotating frame, the axis is set in the + * constructor with axisPoint and axisDirection. The axisPoint can be the + * coordinate of any point on the axis. The axisDirection has to be a normed to + * 1. The pulse w is in rad/s. It determines the pulse speed by its norm while + * the trigonometric or clockwise direction is determined by its sign: When the + * axisDirection is pointing "towards you", a positive pulse makes it turn in + * the trigonometric way. It has to be noticed that putting both axisDirection + * into -axisDirection and w into -w yields an exactly identical situation. + */ + + +namespace olb { + +template +class PowerLaw2D : public AnalyticalF2D { +protected: + std::vector _axisPoint; + std::vector _axisDirection; + T _maxVelocity; + T _radius; + T _exponent; + +public: + PowerLaw2D(std::vector axisPoint, std::vector axisDirection, T maxVelocity, T radius, T exponent); + /// construct from material number, note: untested + PowerLaw2D(SuperGeometry2D& superGeometry, int material, T maxVelocity, T distance2Wall, T exponent); + bool operator()(T output[], const T input[]) override; +}; + +template +class Poiseuille2D : public PowerLaw2D { + +public: + Poiseuille2D(std::vector axisPoint, std::vector axisDirection, T maxVelocity, T radius); + /// construct from material number, note: untested + Poiseuille2D(SuperGeometry2D& superGeometry, int material, T maxVelocity, T distance2Wall); + //bool operator()(T output[], const T x[]); +}; + + +template +class PoiseuilleStrainRate2D : public AnalyticalF2D { +protected: + T _lengthY; + T _maxVelocity; + +public: + PoiseuilleStrainRate2D(UnitConverter const& converter, T ly); + bool operator()(T output[], const S input[]) override; +}; + +/// Analytical solution of porous media channel flow with low Reynolds number +/// See Spaid and Phelan (doi:10.1063/1.869392) +template +class AnalyticalPorousVelocity2D : public AnalyticalF2D { +protected: + std::vector axisDirection; + T K, mu, gradP, radius; + T eps; +public: + AnalyticalPorousVelocity2D(std::vector axisDirection_, T K_, T mu_, T gradP_, T radius_, T eps_=T(1)); + T getPeakVelocity(); + bool operator()(T output[], const T input[]) override; +}; + + +////////// Polar & Cartesian /////////////// + + +/// This class converts polar coordinates of point x (x[0] = radius, x[1] = phi) +/// to Cartesian coordinates (wrote into output field). +/// Initial situation for the Cartesian coordinate system is that angle phi +/// lies in the x-y-plane and turns round the _polarOrigin in math. pos sense. +template +class PolarToCartesian2D : public AnalyticalF2D { +protected: + /// origin of the polar coordinate system to which point x is related + std::vector _polarOrigin; + // std::vector _normalToPlane; +public: + /// constructor to obtain Cartesian coordinates of polar coordinates + PolarToCartesian2D(std::vector polarOrigin); + /// operator writes Cartesian coordinates of polar coordinates + /// x[0] = radius >= 0, x[1] = phi in [0, 2*Pi) into output field + bool operator()(T output[], const S x[]) override; +}; + + +/// This class converts Cartesian coordinates of point x to polar coordinates +/// wrote into output field +/// (output[0] = radius>= 0, output[1] = phi in [0, 2Pi). +/// Initial situation for the polar coordinate system is that angle phi +/// lies in plane perpendicular to the _axisDirection and turns around +/// the _cartesianOrigin. The radius is the distance of point x to the +/// _axisDirection. +template +class CartesianToPolar2D : public AnalyticalF2D { +protected: + /// origin of the Cartesian coordinate system + std::vector _cartesianOrigin; + /// direction of the axis along which the polar coordinates are calculated + std::vector _axisDirection; + /// direction to know orientation for math positive to obtain angle phi + /// of Cartesian point x + std::vector _orientation; +public: + CartesianToPolar2D(std::vector cartesianOrigin, + std::vector axisDirection, + std::vector orientation = {T(1),T(),T()}); + CartesianToPolar2D(T cartesianOriginX, T cartesianOriginY, + T cartesianOriginZ, + T axisDirectionX, T axisDirectionY, T axisDirectionZ, + T orientationX = T(1), T orientationY = T(), + T orientationZ = T()); + /// operator writes polar coordinates of Cartesian point x into output + /// field, + /// returns output[0] = radius ( >= 0 ), output[1] = phi in [0, 2Pi) + bool operator()(T output[], const S x[]) override; +}; + +} // end namespace olb +#endif -- cgit v1.2.3