summaryrefslogtreecommitdiff
path: root/src/boundary/advectionDiffusionBoundaryInstantiator2D.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/boundary/advectionDiffusionBoundaryInstantiator2D.h')
-rw-r--r--src/boundary/advectionDiffusionBoundaryInstantiator2D.h523
1 files changed, 523 insertions, 0 deletions
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
+ * <http://www.openlb.net/>
+ *
+ * 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<typename T, typename DESCRIPTOR, class BoundaryManager>
+class AdvectionDiffusionBoundaryConditionInstantiator2D : public OnLatticeAdvectionDiffusionBoundaryCondition2D<T,DESCRIPTOR> {
+public:
+ AdvectionDiffusionBoundaryConditionInstantiator2D( BlockLatticeStructure2D<T,DESCRIPTOR>& 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<T,DESCRIPTOR>& getBlock();
+ virtual BlockLatticeStructure2D<T,DESCRIPTOR> const& getBlock() const;
+
+ void addTemperatureBoundary(BlockIndicatorF2D<T>& indicator, int x0, int x1, int y0, int y1, T omega) override;
+
+ void addRegularizedTemperatureBoundary(BlockIndicatorF2D<T>& indicator, int x0, int x1, int y0, int y1, T omega) override;
+ void addRegularizedTemperatureBoundary(BlockGeometryStructure2D<T>& blockGeometryStructure, int material, int x0, int x1, int y0, int y1, T omega) override;
+ void addRegularizedTemperatureBoundary(BlockIndicatorF2D<T>& indicator, T omega) override;
+ void addRegularizedTemperatureBoundary(BlockGeometryStructure2D<T>& blockGeometryStructure, int material, T omega) override;
+
+ void addRegularizedHeatFluxBoundary(BlockIndicatorF2D<T>& indicator, int x0, int x1, int y0, int y1, T omega, T *heatFlux) override;
+ void addRegularizedHeatFluxBoundary(BlockGeometryStructure2D<T>& blockGeometryStructure, int material, int x0, int x1, int y0, int y1, T omega, T *heatFlux) override;
+ void addRegularizedHeatFluxBoundary(BlockIndicatorF2D<T>& indicator, T omega, T *heatFlux) override;
+ void addRegularizedHeatFluxBoundary(BlockGeometryStructure2D<T>& blockGeometryStructure, int material, T omega, T *heatFlux) override;
+
+private:
+ template<int direction, int orientation>
+ void addTemperatureBoundary(int x0, int x1, int y0, int y1, T omega);
+ template<int normalX, int normalY>
+ void addTemperatureCorner(int x, int y, T omega);
+
+ template<int direction, int orientation>
+ void addRegularizedTemperatureBoundary(int x0, int x1, int y0, int y1, T omega);
+ template<int normalX, int normalY>
+ void addRegularizedTemperatureCorner(int x, int y, T omega);
+
+ template<int direction, int orientation>
+ void addRegularizedHeatFluxBoundary(int x0, int x1, int y0, int y1, T omega, T *heatFlux);
+ template<int normalX, int normalY>
+ void addRegularizedHeatFluxCorner(int x, int y, T omega);
+
+ BlockLatticeStructure2D<T,DESCRIPTOR>& block;
+ std::vector<Momenta<T,DESCRIPTOR>*> momentaVector;
+ std::vector<Dynamics<T,DESCRIPTOR>*> dynamicsVector;
+};
+
+///////// class AdvectionDiffusionBoundaryConditionInstantiator2D ////////////////////////
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::AdvectionDiffusionBoundaryConditionInstantiator2D (
+ BlockLatticeStructure2D<T,DESCRIPTOR>& block_)
+ : block(block_)
+{ }
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::~AdvectionDiffusionBoundaryConditionInstantiator2D()
+{
+ for (unsigned iDynamics=0; iDynamics<dynamicsVector.size(); ++iDynamics) {
+ delete dynamicsVector[iDynamics];
+ }
+ for (unsigned iMomenta=0; iMomenta<dynamicsVector.size(); ++iMomenta) {
+ delete momentaVector[iMomenta];
+ }
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+template<int direction, int orientation>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+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<T,DESCRIPTOR>* momenta
+ = BoundaryManager::template getTemperatureBoundaryMomenta<direction,orientation>();
+ Dynamics<T,DESCRIPTOR>* dynamics
+ = BoundaryManager::template getTemperatureBoundaryDynamics<direction,orientation>(omega, *momenta);
+ this->getBlock().defineDynamics(iX,iX,iY,iY, dynamics);
+ momentaVector.push_back(momenta);
+ dynamicsVector.push_back(dynamics);
+ }
+ }
+
+ PostProcessorGenerator2D<T,DESCRIPTOR>* postProcessor
+ = BoundaryManager::template getTemperatureBoundaryProcessor<direction,orientation>(x0,x1, y0,y1);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+template<int xNormal, int yNormal>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addTemperatureCorner(int x, int y, T omega)
+{
+ Momenta<T,DESCRIPTOR>* momenta
+ = BoundaryManager::template getTemperatureCornerMomenta<xNormal,yNormal>();
+ Dynamics<T,DESCRIPTOR>* dynamics
+ = BoundaryManager::template getTemperatureCornerDynamics<xNormal,yNormal>(omega, *momenta);
+
+ this->getBlock().defineDynamics(x,x,y,y, dynamics);
+
+ PostProcessorGenerator2D<T,DESCRIPTOR>* postProcessor
+ = BoundaryManager::template getTemperatureCornerProcessor<xNormal,yNormal>(x, y);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+
+
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+template<int direction, int orientation>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+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<T,DESCRIPTOR>* momenta
+ = BoundaryManager::template getRegularizedTemperatureBoundaryMomenta<direction,orientation>();
+ Dynamics<T,DESCRIPTOR>* dynamics
+ = BoundaryManager::template getRegularizedTemperatureBoundaryDynamics<direction,orientation>(omega, *momenta);
+ this->getBlock().defineDynamics(iX,iX,iY,iY, dynamics);
+ momentaVector.push_back(momenta);
+ dynamicsVector.push_back(dynamics);
+ }
+ }
+
+ PostProcessorGenerator2D<T,DESCRIPTOR>* postProcessor
+ = BoundaryManager::template getRegularizedTemperatureBoundaryProcessor<direction,orientation>(x0,x1, y0,y1);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+template<int xNormal, int yNormal>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addRegularizedTemperatureCorner(int x, int y, T omega)
+{
+ Momenta<T,DESCRIPTOR>* momenta
+ = BoundaryManager::template getRegularizedTemperatureCornerMomenta<xNormal,yNormal>();
+ Dynamics<T,DESCRIPTOR>* dynamics
+ = BoundaryManager::template getRegularizedTemperatureCornerDynamics<xNormal,yNormal>(omega, *momenta);
+
+ this->getBlock().defineDynamics(x,x,y,y, dynamics);
+
+ PostProcessorGenerator2D<T,DESCRIPTOR>* postProcessor
+ = BoundaryManager::template getRegularizedTemperatureCornerProcessor<xNormal,yNormal>(x, y);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+template<int direction, int orientation>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+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<T,DESCRIPTOR>* momenta
+ = BoundaryManager::template getRegularizedHeatFluxBoundaryMomenta<direction,orientation>(heatFlux);
+ Dynamics<T,DESCRIPTOR>* dynamics
+ = BoundaryManager::template getRegularizedHeatFluxBoundaryDynamics<direction,orientation>(omega, *momenta);
+ this->getBlock().defineDynamics(iX,iX,iY,iY, dynamics);
+ momentaVector.push_back(momenta);
+ dynamicsVector.push_back(dynamics);
+ }
+ }
+
+ PostProcessorGenerator2D<T,DESCRIPTOR>* postProcessor
+ = BoundaryManager::template getRegularizedHeatFluxBoundaryProcessor<direction,orientation>(x0,x1, y0,y1);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+template<int xNormal, int yNormal>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addRegularizedHeatFluxCorner(int x, int y, T omega)
+{
+ Momenta<T,DESCRIPTOR>* momenta
+ = BoundaryManager::template getRegularizedHeatFluxCornerMomenta<xNormal,yNormal>();
+ Dynamics<T,DESCRIPTOR>* dynamics
+ = BoundaryManager::template getRegularizedHeatFluxCornerDynamics<xNormal,yNormal>(omega, *momenta);
+
+ this->getBlock().defineDynamics(x,x,y,y, dynamics);
+
+ PostProcessorGenerator2D<T,DESCRIPTOR>* postProcessor
+ = BoundaryManager::template getRegularizedHeatFluxCornerProcessor<xNormal,yNormal>(x, y);
+ if (postProcessor) {
+ this->getBlock().addPostProcessor(*postProcessor);
+ }
+}
+
+
+
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addTemperatureBoundary(BlockIndicatorF2D<T>& indicator,
+ int x0, int x1, int y0, int y1, T omega)
+{
+ std::vector<int> 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<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addRegularizedTemperatureBoundary(BlockIndicatorF2D<T>& indicator,
+ int x0, int x1, int y0, int y1, T omega)
+{
+ std::vector<int> 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<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addRegularizedTemperatureBoundary(BlockGeometryStructure2D<T>& blockGeometryStructure, int material,
+ int x0, int x1, int y0, int y1, T omega)
+{
+ BlockIndicatorMaterial2D<T> indicator(blockGeometryStructure, material);
+ addRegularizedTemperatureBoundary(indicator, x0, x1, y0, y1, omega);
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addRegularizedTemperatureBoundary(BlockIndicatorF2D<T>& indicator, T omega)
+{
+ auto& blockGeometryStructure = indicator.getBlockGeometryStructure();
+ addRegularizedTemperatureBoundary(indicator,
+ 0, blockGeometryStructure.getNx()-1,
+ 0, blockGeometryStructure.getNy()-1,
+ omega);
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addRegularizedTemperatureBoundary(BlockGeometryStructure2D<T>& blockGeometryStructure, int material, T omega)
+{
+ BlockIndicatorMaterial2D<T> indicator(blockGeometryStructure, material);
+ addRegularizedTemperatureBoundary(indicator,
+ 0, blockGeometryStructure.getNx()-1,
+ 0, blockGeometryStructure.getNy()-1,
+ omega);
+}
+
+
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addRegularizedHeatFluxBoundary(BlockIndicatorF2D<T>& indicator,
+ int x0, int x1, int y0, int y1, T omega, T *heatFlux)
+{
+ std::vector<int> 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<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addRegularizedHeatFluxBoundary(BlockGeometryStructure2D<T>& blockGeometryStructure, int material,
+ int x0, int x1, int y0, int y1, T omega, T *heatFlux)
+{
+ BlockIndicatorMaterial2D<T> indicator(blockGeometryStructure, material);
+ addRegularizedHeatFluxBoundary(indicator, x0, x1, y0, y1, omega, heatFlux);
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addRegularizedHeatFluxBoundary(BlockIndicatorF2D<T>& indicator, T omega, T *heatFlux)
+{
+ auto& blockGeometryStructure = indicator.getBlockGeometryStructure();
+ addRegularizedHeatFluxBoundary(indicator,
+ 0, blockGeometryStructure.getNx()-1,
+ 0, blockGeometryStructure.getNy()-1,
+ omega, heatFlux);
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addRegularizedHeatFluxBoundary(BlockGeometryStructure2D<T>& blockGeometryStructure, int material, T omega, T *heatFlux)
+{
+ BlockIndicatorMaterial2D<T> indicator(blockGeometryStructure, material);
+ addRegularizedHeatFluxBoundary(indicator,
+ 0, blockGeometryStructure.getNx()-1,
+ 0, blockGeometryStructure.getNy()-1,
+ omega, heatFlux);
+}
+
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addTemperatureBoundary0N(int x0, int x1, int y0, int y1, T omega)
+{
+ addTemperatureBoundary<0,-1>(x0,x1,y0,y1, omega);
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addTemperatureBoundary0P(int x0, int x1, int y0, int y1, T omega)
+{
+ addTemperatureBoundary<0,1>(x0,x1,y0,y1, omega);
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addTemperatureBoundary1N(int x0, int x1, int y0, int y1, T omega)
+{
+ addTemperatureBoundary<1,-1>(x0,x1,y0,y1, omega);
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addTemperatureBoundary1P(int x0, int x1, int y0, int y1, T omega)
+{
+ addTemperatureBoundary<1,1>(x0,x1,y0,y1, omega);
+}
+
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addTemperatureCornerNN(int x, int y, T omega)
+{
+ addTemperatureCorner<-1,-1>(x,y, omega);
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addTemperatureCornerNP(int x, int y, T omega)
+{
+ addTemperatureCorner<-1,1>(x,y, omega);
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addTemperatureCornerPN(int x, int y, T omega)
+{
+ addTemperatureCorner<1,-1>(x,y, omega);
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+void AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::
+addTemperatureCornerPP(int x, int y, T omega)
+{
+ addTemperatureCorner<1,1>(x,y, omega);
+}
+
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+BlockLatticeStructure2D<T,DESCRIPTOR>& AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::getBlock()
+{
+ return block;
+}
+
+template<typename T, typename DESCRIPTOR, class BoundaryManager>
+BlockLatticeStructure2D<T,DESCRIPTOR> const& AdvectionDiffusionBoundaryConditionInstantiator2D<T,DESCRIPTOR,BoundaryManager>::getBlock() const
+{
+ return block;
+}
+
+}
+
+
+#endif