diff options
Initialize at openlb-1-3
Diffstat (limited to 'src/boundary/advectionDiffusionBoundaryInstantiator2D.h')
-rw-r--r-- | src/boundary/advectionDiffusionBoundaryInstantiator2D.h | 523 |
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 |