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
---
.../advectionDiffusionBoundaryInstantiator2D.h | 523 +++++++++++++++++++++
1 file changed, 523 insertions(+)
create mode 100644 src/boundary/advectionDiffusionBoundaryInstantiator2D.h
(limited to 'src/boundary/advectionDiffusionBoundaryInstantiator2D.h')
diff --git a/src/boundary/advectionDiffusionBoundaryInstantiator2D.h b/src/boundary/advectionDiffusionBoundaryInstantiator2D.h
new file mode 100644
index 0000000..f9c4700
--- /dev/null
+++ b/src/boundary/advectionDiffusionBoundaryInstantiator2D.h
@@ -0,0 +1,523 @@
+/* This file is part of the OpenLB library
+ *
+ * Copyright (C) 2008 Orestis Malaspinas, Andrea Parmigiani
+ * 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.
+*/
+
+/** \file
+ * A helper for initialising 2D boundaries -- header file.
+ */
+
+#ifndef ADVECTION_DIFFUSION_BOUNDARY_INSTANTIATOR_2D_H
+#define ADVECTION_DIFFUSION_BOUNDARY_INSTANTIATOR_2D_H
+
+#include "advectionDiffusionBoundaryCondition2D.h"
+#include "advectionDiffusionBoundaryCondition2D.hh"
+#include "functors/lattice/indicator/blockIndicatorF2D.h"
+
+namespace olb {
+
+template
+class AdvectionDiffusionBoundaryConditionInstantiator2D : public OnLatticeAdvectionDiffusionBoundaryCondition2D {
+public:
+ AdvectionDiffusionBoundaryConditionInstantiator2D( BlockLatticeStructure2D& block_ );
+ ~AdvectionDiffusionBoundaryConditionInstantiator2D() override;
+
+ void addTemperatureBoundary0N(int x0, int x1, int y0, int y1, T omega) override;
+ void addTemperatureBoundary0P(int x0, int x1, int y0, int y1, T omega) override;
+ void addTemperatureBoundary1N(int x0, int x1, int y0, int y1, T omega) override;
+ void addTemperatureBoundary1P(int x0, int x1, int y0, int y1, T omega) override;
+
+ void addTemperatureCornerNN(int x, int y, T omega) override;
+ void addTemperatureCornerNP(int x, int y, T omega) override;
+ void addTemperatureCornerPN(int x, int y, T omega) override;
+ void addTemperatureCornerPP(int x, int y, T omega) override;
+
+ virtual BlockLatticeStructure2D& getBlock();
+ virtual BlockLatticeStructure2D const& getBlock() const;
+
+ void addTemperatureBoundary(BlockIndicatorF2D& indicator, int x0, int x1, int y0, int y1, T omega) override;
+
+ void addRegularizedTemperatureBoundary(BlockIndicatorF2D& indicator, int x0, int x1, int y0, int y1, T omega) override;
+ void addRegularizedTemperatureBoundary(BlockGeometryStructure2D& blockGeometryStructure, int material, int x0, int x1, int y0, int y1, T omega) override;
+ void addRegularizedTemperatureBoundary(BlockIndicatorF2D& indicator, T omega) override;
+ void addRegularizedTemperatureBoundary(BlockGeometryStructure2D& blockGeometryStructure, int material, T omega) override;
+
+ void addRegularizedHeatFluxBoundary(BlockIndicatorF2D& indicator, int x0, int x1, int y0, int y1, T omega, T *heatFlux) override;
+ void addRegularizedHeatFluxBoundary(BlockGeometryStructure2D& blockGeometryStructure, int material, int x0, int x1, int y0, int y1, T omega, T *heatFlux) override;
+ void addRegularizedHeatFluxBoundary(BlockIndicatorF2D& indicator, T omega, T *heatFlux) override;
+ void addRegularizedHeatFluxBoundary(BlockGeometryStructure2D& blockGeometryStructure, int material, T omega, T *heatFlux) override;
+
+private:
+ template
+ void addTemperatureBoundary(int x0, int x1, int y0, int y1, T omega);
+ template
+ void addTemperatureCorner(int x, int y, T omega);
+
+ template
+ void addRegularizedTemperatureBoundary(int x0, int x1, int y0, int y1, T omega);
+ template
+ void addRegularizedTemperatureCorner(int x, int y, T omega);
+
+ template
+ void addRegularizedHeatFluxBoundary(int x0, int x1, int y0, int y1, T omega, T *heatFlux);
+ template
+ void addRegularizedHeatFluxCorner(int x, int y, T omega);
+
+ BlockLatticeStructure2D& block;
+ std::vector*> momentaVector;
+ std::vector*> dynamicsVector;
+};
+
+///////// class AdvectionDiffusionBoundaryConditionInstantiator2D ////////////////////////
+
+template
+AdvectionDiffusionBoundaryConditionInstantiator2D::AdvectionDiffusionBoundaryConditionInstantiator2D (
+ BlockLatticeStructure2D& block_)
+ : block(block_)
+{ }
+
+template
+AdvectionDiffusionBoundaryConditionInstantiator2D::~AdvectionDiffusionBoundaryConditionInstantiator2D()
+{
+ for (unsigned iDynamics=0; iDynamics
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addTemperatureBoundary(int x0, int x1, int y0, int y1, T omega)
+{
+ OLB_PRECONDITION(x0==x1 || y0==y1);
+
+ for (int iX=x0; iX<=x1; ++iX) {
+ for (int iY=y0; iY<=y1; ++iY) {
+ Momenta* momenta
+ = BoundaryManager::template getTemperatureBoundaryMomenta();
+ Dynamics* dynamics
+ = BoundaryManager::template getTemperatureBoundaryDynamics(omega, *momenta);
+ this->getBlock().defineDynamics(iX,iX,iY,iY, dynamics);
+ momentaVector.push_back(momenta);
+ dynamicsVector.push_back(dynamics);
+ }
+ }
+
+ PostProcessorGenerator2D* postProcessor
+ = BoundaryManager::template getTemperatureBoundaryProcessor(x0,x1, y0,y1);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+template
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addTemperatureCorner(int x, int y, T omega)
+{
+ Momenta* momenta
+ = BoundaryManager::template getTemperatureCornerMomenta();
+ Dynamics* dynamics
+ = BoundaryManager::template getTemperatureCornerDynamics(omega, *momenta);
+
+ this->getBlock().defineDynamics(x,x,y,y, dynamics);
+
+ PostProcessorGenerator2D* postProcessor
+ = BoundaryManager::template getTemperatureCornerProcessor(x, y);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+
+
+
+template
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedTemperatureBoundary(int x0, int x1, int y0, int y1, T omega)
+{
+ OLB_PRECONDITION(x0==x1 || y0==y1);
+
+ for (int iX=x0; iX<=x1; ++iX) {
+ for (int iY=y0; iY<=y1; ++iY) {
+ Momenta* momenta
+ = BoundaryManager::template getRegularizedTemperatureBoundaryMomenta();
+ Dynamics* dynamics
+ = BoundaryManager::template getRegularizedTemperatureBoundaryDynamics(omega, *momenta);
+ this->getBlock().defineDynamics(iX,iX,iY,iY, dynamics);
+ momentaVector.push_back(momenta);
+ dynamicsVector.push_back(dynamics);
+ }
+ }
+
+ PostProcessorGenerator2D* postProcessor
+ = BoundaryManager::template getRegularizedTemperatureBoundaryProcessor(x0,x1, y0,y1);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+template
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedTemperatureCorner(int x, int y, T omega)
+{
+ Momenta* momenta
+ = BoundaryManager::template getRegularizedTemperatureCornerMomenta();
+ Dynamics* dynamics
+ = BoundaryManager::template getRegularizedTemperatureCornerDynamics(omega, *momenta);
+
+ this->getBlock().defineDynamics(x,x,y,y, dynamics);
+
+ PostProcessorGenerator2D* postProcessor
+ = BoundaryManager::template getRegularizedTemperatureCornerProcessor(x, y);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+
+
+template
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedHeatFluxBoundary(int x0, int x1, int y0, int y1, T omega, T *heatFlux)
+{
+ OLB_PRECONDITION(x0==x1 || y0==y1);
+
+ for (int iX=x0; iX<=x1; ++iX) {
+ for (int iY=y0; iY<=y1; ++iY) {
+ Momenta* momenta
+ = BoundaryManager::template getRegularizedHeatFluxBoundaryMomenta(heatFlux);
+ Dynamics* dynamics
+ = BoundaryManager::template getRegularizedHeatFluxBoundaryDynamics(omega, *momenta);
+ this->getBlock().defineDynamics(iX,iX,iY,iY, dynamics);
+ momentaVector.push_back(momenta);
+ dynamicsVector.push_back(dynamics);
+ }
+ }
+
+ PostProcessorGenerator2D* postProcessor
+ = BoundaryManager::template getRegularizedHeatFluxBoundaryProcessor(x0,x1, y0,y1);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+template
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedHeatFluxCorner(int x, int y, T omega)
+{
+ Momenta* momenta
+ = BoundaryManager::template getRegularizedHeatFluxCornerMomenta();
+ Dynamics* dynamics
+ = BoundaryManager::template getRegularizedHeatFluxCornerDynamics(omega, *momenta);
+
+ this->getBlock().defineDynamics(x,x,y,y, dynamics);
+
+ PostProcessorGenerator2D* postProcessor
+ = BoundaryManager::template getRegularizedHeatFluxCornerProcessor(x, y);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+
+
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addTemperatureBoundary(BlockIndicatorF2D& indicator,
+ int x0, int x1, int y0, int y1, T omega)
+{
+ std::vector discreteNormal(3,0);
+ for (int iX = x0; iX <= x1; ++iX) {
+ for (int iY = y0; iY <= y1; ++iY) {
+ if (indicator(iX, iY)) {
+ discreteNormal = indicator.getBlockGeometryStructure().getStatistics().getType(iX,iY);
+ if (discreteNormal[0] == 0) {
+ if (discreteNormal[1] == 1) {
+ addTemperatureBoundary<0,1>(iX,iX,iY,iY, omega);
+ }
+ else if (discreteNormal[1] == -1) {
+ addTemperatureBoundary<0,-1>(iX,iX,iY,iY, omega);
+ }
+ else if (discreteNormal[2] == 1) {
+ addTemperatureBoundary<1,1>(iX,iX,iY,iY, omega);
+ }
+ else if (discreteNormal[2] == -1) {
+ addTemperatureBoundary<1,-1>(iX,iX,iY,iY, omega);
+ }
+ }
+ else if (discreteNormal[0] == 1) {
+ if (discreteNormal[1] == 1 && discreteNormal[2] == 1) {
+ addTemperatureCorner<1,1>(iX,iY, omega);
+ }
+ else if (discreteNormal[1] == 1 && discreteNormal[2] == -1) {
+ addTemperatureCorner<1,-1>(iX,iY, omega);
+ }
+ else if (discreteNormal[1] == -1 && discreteNormal[2] == 1) {
+ addTemperatureCorner<-1,1>(iX,iY, omega);
+ }
+ else if (discreteNormal[1] == -1 && discreteNormal[2] == -1) {
+ addTemperatureCorner<-1,-1>(iX,iY, omega);
+ }
+ }
+ }
+ }
+ }
+}
+
+
+
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedTemperatureBoundary(BlockIndicatorF2D& indicator,
+ int x0, int x1, int y0, int y1, T omega)
+{
+ std::vector discreteNormal(3,0);
+ for (int iX = x0; iX <= x1; ++iX) {
+ for (int iY = y0; iY <= y1; ++iY) {
+ if (indicator(iX, iY)) {
+ discreteNormal = indicator.getBlockGeometryStructure().getStatistics().getType(iX,iY);
+ // cout << discreteNormal[0] << " " << discreteNormal[1] << " " << discreteNormal[2] << endl;
+ if (discreteNormal[0] == 0) {
+ if (discreteNormal[1] == 1) {
+ addRegularizedTemperatureBoundary<0,1>(iX,iX,iY,iY, omega);
+ }
+ else if (discreteNormal[1] == -1) {
+ addRegularizedTemperatureBoundary<0,-1>(iX,iX,iY,iY, omega);
+ }
+ else if (discreteNormal[2] == 1) {
+ addRegularizedTemperatureBoundary<1,1>(iX,iX,iY,iY, omega);
+ }
+ else if (discreteNormal[2] == -1) {
+ addRegularizedTemperatureBoundary<1,-1>(iX,iX,iY,iY, omega);
+ }
+ }
+ else if (discreteNormal[0] == 1) {
+ if (discreteNormal[1] == 1 && discreteNormal[2] == 1) {
+ addRegularizedTemperatureCorner<1,1>(iX,iY, omega);
+ }
+ else if (discreteNormal[1] == 1 && discreteNormal[2] == -1) {
+ addRegularizedTemperatureCorner<1,-1>(iX,iY, omega);
+ }
+ else if (discreteNormal[1] == -1 && discreteNormal[2] == 1) {
+ addRegularizedTemperatureCorner<-1,1>(iX,iY, omega);
+ }
+ else if (discreteNormal[1] == -1 && discreteNormal[2] == -1) {
+ addRegularizedTemperatureCorner<-1,-1>(iX,iY, omega);
+ }
+ }
+ }
+ }
+ }
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedTemperatureBoundary(BlockGeometryStructure2D& blockGeometryStructure, int material,
+ int x0, int x1, int y0, int y1, T omega)
+{
+ BlockIndicatorMaterial2D indicator(blockGeometryStructure, material);
+ addRegularizedTemperatureBoundary(indicator, x0, x1, y0, y1, omega);
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedTemperatureBoundary(BlockIndicatorF2D& indicator, T omega)
+{
+ auto& blockGeometryStructure = indicator.getBlockGeometryStructure();
+ addRegularizedTemperatureBoundary(indicator,
+ 0, blockGeometryStructure.getNx()-1,
+ 0, blockGeometryStructure.getNy()-1,
+ omega);
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedTemperatureBoundary(BlockGeometryStructure2D& blockGeometryStructure, int material, T omega)
+{
+ BlockIndicatorMaterial2D indicator(blockGeometryStructure, material);
+ addRegularizedTemperatureBoundary(indicator,
+ 0, blockGeometryStructure.getNx()-1,
+ 0, blockGeometryStructure.getNy()-1,
+ omega);
+}
+
+
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedHeatFluxBoundary(BlockIndicatorF2D& indicator,
+ int x0, int x1, int y0, int y1, T omega, T *heatFlux)
+{
+ std::vector discreteNormal(3,0);
+ for (int iX = x0; iX <= x1; ++iX) {
+ for (int iY = y0; iY <= y1; ++iY) {
+ if (indicator(iX, iY)) {
+ discreteNormal = indicator.getBlockGeometryStructure().getStatistics().getType(iX,iY);
+ // cout << discreteNormal[0] << " " << discreteNormal[1] << " " << discreteNormal[2] << endl;
+ if (discreteNormal[0] == 0) {
+ if (discreteNormal[1] == 1) {
+ addRegularizedHeatFluxBoundary<0,1>(iX,iX,iY,iY, omega, heatFlux);
+ }
+ else if (discreteNormal[1] == -1) {
+ addRegularizedHeatFluxBoundary<0,-1>(iX,iX,iY,iY, omega, heatFlux);
+ }
+ else if (discreteNormal[2] == 1) {
+ addRegularizedHeatFluxBoundary<1,1>(iX,iX,iY,iY, omega, heatFlux);
+ }
+ else if (discreteNormal[2] == -1) {
+ addRegularizedHeatFluxBoundary<1,-1>(iX,iX,iY,iY, omega, heatFlux);
+ }
+ }
+ else if (discreteNormal[0] == 1) {
+ if (discreteNormal[1] == 1 && discreteNormal[2] == 1) {
+ addRegularizedHeatFluxCorner<1,1>(iX,iY, omega);
+ }
+ else if (discreteNormal[1] == 1 && discreteNormal[2] == -1) {
+ addRegularizedHeatFluxCorner<1,-1>(iX,iY, omega);
+ }
+ else if (discreteNormal[1] == -1 && discreteNormal[2] == 1) {
+ addRegularizedHeatFluxCorner<-1,1>(iX,iY, omega);
+ }
+ else if (discreteNormal[1] == -1 && discreteNormal[2] == -1) {
+ addRegularizedHeatFluxCorner<-1,-1>(iX,iY, omega);
+ }
+ }
+ }
+ }
+ }
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedHeatFluxBoundary(BlockGeometryStructure2D& blockGeometryStructure, int material,
+ int x0, int x1, int y0, int y1, T omega, T *heatFlux)
+{
+ BlockIndicatorMaterial2D indicator(blockGeometryStructure, material);
+ addRegularizedHeatFluxBoundary(indicator, x0, x1, y0, y1, omega, heatFlux);
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedHeatFluxBoundary(BlockIndicatorF2D& indicator, T omega, T *heatFlux)
+{
+ auto& blockGeometryStructure = indicator.getBlockGeometryStructure();
+ addRegularizedHeatFluxBoundary(indicator,
+ 0, blockGeometryStructure.getNx()-1,
+ 0, blockGeometryStructure.getNy()-1,
+ omega, heatFlux);
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addRegularizedHeatFluxBoundary(BlockGeometryStructure2D& blockGeometryStructure, int material, T omega, T *heatFlux)
+{
+ BlockIndicatorMaterial2D indicator(blockGeometryStructure, material);
+ addRegularizedHeatFluxBoundary(indicator,
+ 0, blockGeometryStructure.getNx()-1,
+ 0, blockGeometryStructure.getNy()-1,
+ omega, heatFlux);
+}
+
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addTemperatureBoundary0N(int x0, int x1, int y0, int y1, T omega)
+{
+ addTemperatureBoundary<0,-1>(x0,x1,y0,y1, omega);
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addTemperatureBoundary0P(int x0, int x1, int y0, int y1, T omega)
+{
+ addTemperatureBoundary<0,1>(x0,x1,y0,y1, omega);
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addTemperatureBoundary1N(int x0, int x1, int y0, int y1, T omega)
+{
+ addTemperatureBoundary<1,-1>(x0,x1,y0,y1, omega);
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addTemperatureBoundary1P(int x0, int x1, int y0, int y1, T omega)
+{
+ addTemperatureBoundary<1,1>(x0,x1,y0,y1, omega);
+}
+
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addTemperatureCornerNN(int x, int y, T omega)
+{
+ addTemperatureCorner<-1,-1>(x,y, omega);
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addTemperatureCornerNP(int x, int y, T omega)
+{
+ addTemperatureCorner<-1,1>(x,y, omega);
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addTemperatureCornerPN(int x, int y, T omega)
+{
+ addTemperatureCorner<1,-1>(x,y, omega);
+}
+
+template
+void AdvectionDiffusionBoundaryConditionInstantiator2D::
+addTemperatureCornerPP(int x, int y, T omega)
+{
+ addTemperatureCorner<1,1>(x,y, omega);
+}
+
+
+template
+BlockLatticeStructure2D& AdvectionDiffusionBoundaryConditionInstantiator2D::getBlock()
+{
+ return block;
+}
+
+template
+BlockLatticeStructure2D const& AdvectionDiffusionBoundaryConditionInstantiator2D::getBlock() const
+{
+ return block;
+}
+
+}
+
+
+#endif
--
cgit v1.2.3