boundaryinstantiator3d.h

来自「open lattice boltzmann project www.open」· C头文件 代码 · 共 678 行 · 第 1/2 页

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2007 Jonas Latt
 *  Address: Rue General Dufour 24,  1211 Geneva 4, Switzerland 
 *  E-mail: [e-mail]
 *
 *  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 3D boundaries -- header file.  */
#ifndef BOUNDARY_INSTANTIATOR_3D_H
#define BOUNDARY_INSTANTIATOR_3D_H

#include "boundaryCondition3D.h"

namespace olb {

template<typename T, template<typename U> class Lattice, class BoundaryManager>
class BoundaryConditionInstantiator3D : public OnLatticeBoundaryCondition3D<T,Lattice> {
public:
    BoundaryConditionInstantiator3D( BlockStructure3D<T,Lattice>& block_ );
    ~BoundaryConditionInstantiator3D();

    void addVelocityBoundary0N(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addVelocityBoundary0P(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addVelocityBoundary1N(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addVelocityBoundary1P(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addVelocityBoundary2N(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addVelocityBoundary2P(int x0, int x1, int y0, int y1, int z0, int z1, T omega);

    void addPressureBoundary0N(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addPressureBoundary0P(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addPressureBoundary1N(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addPressureBoundary1P(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addPressureBoundary2N(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addPressureBoundary2P(int x0, int x1, int y0, int y1, int z0, int z1, T omega);

    void addExternalVelocityEdge0NN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addExternalVelocityEdge0NP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addExternalVelocityEdge0PN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addExternalVelocityEdge0PP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addExternalVelocityEdge1NN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addExternalVelocityEdge1NP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addExternalVelocityEdge1PN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addExternalVelocityEdge1PP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addExternalVelocityEdge2NN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addExternalVelocityEdge2NP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addExternalVelocityEdge2PN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addExternalVelocityEdge2PP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);

    void addInternalVelocityEdge0NN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addInternalVelocityEdge0NP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addInternalVelocityEdge0PN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addInternalVelocityEdge0PP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addInternalVelocityEdge1NN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addInternalVelocityEdge1NP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addInternalVelocityEdge1PN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addInternalVelocityEdge1PP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addInternalVelocityEdge2NN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addInternalVelocityEdge2NP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addInternalVelocityEdge2PN(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    void addInternalVelocityEdge2PP(int x0, int x1, int y0, int y1, int z0, int z1, T omega);

    void addExternalVelocityCornerNNN(int x, int y, int z, T omega);
    void addExternalVelocityCornerNNP(int x, int y, int z, T omega);
    void addExternalVelocityCornerNPN(int x, int y, int z, T omega);
    void addExternalVelocityCornerNPP(int x, int y, int z, T omega);
    void addExternalVelocityCornerPNN(int x, int y, int z, T omega);
    void addExternalVelocityCornerPNP(int x, int y, int z, T omega);
    void addExternalVelocityCornerPPN(int x, int y, int z, T omega);
    void addExternalVelocityCornerPPP(int x, int y, int z, T omega);

    void addInternalVelocityCornerNNN(int x, int y, int z, T omega);
    void addInternalVelocityCornerNNP(int x, int y, int z, T omega);
    void addInternalVelocityCornerNPN(int x, int y, int z, T omega);
    void addInternalVelocityCornerNPP(int x, int y, int z, T omega);
    void addInternalVelocityCornerPNN(int x, int y, int z, T omega);
    void addInternalVelocityCornerPNP(int x, int y, int z, T omega);
    void addInternalVelocityCornerPPN(int x, int y, int z, T omega);
    void addInternalVelocityCornerPPP(int x, int y, int z, T omega);

    BlockStructure3D<T,Lattice>& getBlock();
    BlockStructure3D<T,Lattice> const& getBlock() const;
private:
    template<int direction, int orientation>
        void addVelocityBoundary(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    template<int direction, int orientation>
        void addPressureBoundary(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    template<int plane, int normal1, int normal2>
        void addExternalVelocityEdge(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    template<int plane, int normal1, int normal2>
        void addInternalVelocityEdge(int x0, int x1, int y0, int y1, int z0, int z1, T omega);
    template<int normalX, int normalY, int normalZ>
        void addExternalVelocityCorner(int x, int y, int z, T omega);
    template<int normalX, int normalY, int normalZ>
        void addInternalVelocityCorner(int x, int y, int z, T omega);
private:
    BlockStructure3D<T,Lattice>& block;
    std::vector<Momenta<T,Lattice>*>  momentaVector;
    std::vector<Dynamics<T,Lattice>*> dynamicsVector;
};


///////// class BoundaryConditionInstantiator3D ////////////////////////

template<typename T, template<typename U> class Lattice, class BoundaryManager>
BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::BoundaryConditionInstantiator3D (
        BlockStructure3D<T,Lattice>& block_)
    : block(block_)
{ }

template<typename T, template<typename U> class Lattice, class BoundaryManager>
BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::~BoundaryConditionInstantiator3D() {
    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, template<typename U> class Lattice, class BoundaryManager>
template<int direction, int orientation>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addVelocityBoundary(int x0, int x1, int y0, int y1, int z0, int z1, T omega)
{
    OLB_PRECONDITION( x0==x1 || y0==y1 || z0==z1 );

    for (int iX=x0; iX<=x1; ++iX) {
        for (int iY=y0; iY<=y1; ++iY) {
            for (int iZ=z0; iZ<=z1; ++iZ) {
                Momenta<T,Lattice>* momenta
                    = BoundaryManager::template getVelocityBoundaryMomenta<direction,orientation>();
                Dynamics<T,Lattice>* dynamics
                    = BoundaryManager::template getVelocityBoundaryDynamics<direction,orientation>(omega, *momenta);
                this->getBlock().defineDynamics(iX,iX,iY,iY,iZ,iZ, dynamics);
                momentaVector.push_back(momenta);
                dynamicsVector.push_back(dynamics);
            }
        }
    }

    PostProcessorGenerator3D<T,Lattice>* postProcessor
        = BoundaryManager::template getVelocityBoundaryProcessor<direction,orientation>(x0,x1, y0,y1, z0,z1);
    if (postProcessor) {
        this->getBlock().addPostProcessor(*postProcessor);
    }
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
template<int direction, int orientation>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addPressureBoundary(int x0, int x1, int y0, int y1, int z0, int z1, T omega)
{
    OLB_PRECONDITION( x0==x1 || y0==y1 || z0==z1 );

    for (int iX=x0; iX<=x1; ++iX) {
        for (int iY=y0; iY<=y1; ++iY) {
            for (int iZ=z0; iZ<=z1; ++iZ) {
                Momenta<T,Lattice>* momenta
                    = BoundaryManager::template getPressureBoundaryMomenta<direction,orientation>();
                Dynamics<T,Lattice>* dynamics
                    = BoundaryManager::template getPressureBoundaryDynamics<direction,orientation>(omega, *momenta);
                this->getBlock().defineDynamics(iX,iX,iY,iY,iZ,iZ, dynamics);
                momentaVector.push_back(momenta);
                dynamicsVector.push_back(dynamics);
            }
        }
    }

    PostProcessorGenerator3D<T,Lattice>* postProcessor
        = BoundaryManager::template getPressureBoundaryProcessor<direction,orientation>(x0,x1, y0,y1, z0,z1);
    if (postProcessor) {
        this->getBlock().addPostProcessor(*postProcessor);
    }
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
template<int plane, int normal1, int normal2>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addExternalVelocityEdge(int x0, int x1, int y0, int y1, int z0, int z1, T omega)
{
    OLB_PRECONDITION(
            ( x0==x1 && y0==y1 ) ||
            ( x0==x1 && z0==z1 ) ||
            ( y0==y1 && z0==z1 ) );

    for (int iX=x0; iX<=x1; ++iX) {
        for (int iY=y0; iY<=y1; ++iY) {
            for (int iZ=z0; iZ<=z1; ++iZ) {
                Momenta<T,Lattice>* momenta
                    = BoundaryManager::template getExternalVelocityEdgeMomenta<plane,normal1,normal2>();
                Dynamics<T,Lattice>* dynamics
                    = BoundaryManager::template getExternalVelocityEdgeDynamics<plane,normal1,normal2>(omega, *momenta);
                this->getBlock().defineDynamics(iX,iX,iY,iY,iZ,iZ, dynamics);
                momentaVector.push_back(momenta);
                dynamicsVector.push_back(dynamics);
            }
        }
    }

    PostProcessorGenerator3D<T,Lattice>* postProcessor
        = BoundaryManager::template getExternalVelocityEdgeProcessor<plane,normal1,normal2>(x0,x1, y0,y1, z0,z1);
    if (postProcessor) {
        this->getBlock().addPostProcessor(*postProcessor);
    }
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
template<int plane, int normal1, int normal2>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addInternalVelocityEdge(int x0, int x1, int y0, int y1, int z0, int z1, T omega)
{
    OLB_PRECONDITION(
            ( x0==x1 && y0==y1 ) ||
            ( x0==x1 && z0==z1 ) ||
            ( y0==y1 && z0==z1 ) );

    for (int iX=x0; iX<=x1; ++iX) {
        for (int iY=y0; iY<=y1; ++iY) {
            for (int iZ=z0; iZ<=z1; ++iZ) {
                Momenta<T,Lattice>* momenta
                    = BoundaryManager::template getInternalVelocityEdgeMomenta<plane,normal1,normal2>();
                Dynamics<T,Lattice>* dynamics
                    = BoundaryManager::template getInternalVelocityEdgeDynamics<plane,normal1,normal2>(omega, *momenta);
                this->getBlock().defineDynamics(iX,iX,iY,iY,iZ,iZ, dynamics);
                momentaVector.push_back(momenta);
                dynamicsVector.push_back(dynamics);
            }
        }
    }

    PostProcessorGenerator3D<T,Lattice>* postProcessor
        = BoundaryManager::template getInternalVelocityEdgeProcessor<plane,normal1,normal2>(x0,x1, y0,y1, z0,z1);
    if (postProcessor) {
        this->getBlock().addPostProcessor(*postProcessor);
    }
}


template<typename T, template<typename U> class Lattice, class BoundaryManager>
template<int xNormal, int yNormal, int zNormal>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addExternalVelocityCorner(int x, int y, int z, T omega)
{
    Momenta<T,Lattice>* momenta
        = BoundaryManager::template getExternalVelocityCornerMomenta<xNormal,yNormal,zNormal>();
    Dynamics<T,Lattice>* dynamics
        = BoundaryManager::template getExternalVelocityCornerDynamics<xNormal,yNormal,zNormal>(omega, *momenta);

    this->getBlock().defineDynamics(x,x,y,y,z,z, dynamics);

    PostProcessorGenerator3D<T,Lattice>* postProcessor
        = BoundaryManager::template getExternalVelocityCornerProcessor<xNormal,yNormal,zNormal>(x, y, z);
    if (postProcessor) {
        this->getBlock().addPostProcessor(*postProcessor);
    }
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
template<int xNormal, int yNormal, int zNormal>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addInternalVelocityCorner(int x, int y, int z, T omega)
{
    Momenta<T,Lattice>* momenta
        = BoundaryManager::template getInternalVelocityCornerMomenta<xNormal,yNormal,zNormal>();
    Dynamics<T,Lattice>* dynamics
        = BoundaryManager::template getInternalVelocityCornerDynamics<xNormal,yNormal,zNormal>(omega, *momenta);

    this->getBlock().defineDynamics(x,x,y,y,z,z, dynamics);

    PostProcessorGenerator3D<T,Lattice>* postProcessor
        = BoundaryManager::template getInternalVelocityCornerProcessor<xNormal,yNormal,zNormal>(x, y, z);
    if (postProcessor) {
        this->getBlock().addPostProcessor(*postProcessor);
    }
}


template<typename T, template<typename U> class Lattice, class BoundaryManager>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addVelocityBoundary0N(int x0, int x1, int y0, int y1, int z0, int z1, T omega)
{
    addVelocityBoundary<0,-1>(x0,x1,y0,y1,z0,z1, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addVelocityBoundary0P(int x0, int x1, int y0, int y1, int z0, int z1, T omega)
{
    addVelocityBoundary<0,1>(x0,x1,y0,y1,z0,z1, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addVelocityBoundary1N(int x0, int x1, int y0, int y1, int z0, int z1, T omega)
{
    addVelocityBoundary<1,-1>(x0,x1,y0,y1,z0,z1, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addVelocityBoundary1P(int x0, int x1, int y0, int y1, int z0, int z1, T omega)
{
    addVelocityBoundary<1, 1>(x0,x1,y0,y1,z0,z1, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addVelocityBoundary2N(int x0, int x1, int y0, int y1, int z0, int z1, T omega)
{
    addVelocityBoundary<2,-1>(x0,x1,y0,y1,z0,z1, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addVelocityBoundary2P(int x0, int x1, int y0, int y1, int z0, int z1, T omega)
{
    addVelocityBoundary<2, 1>(x0,x1,y0,y1,z0,z1, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void BoundaryConditionInstantiator3D<T,Lattice,BoundaryManager>::
    addPressureBoundary0N(int x0, int x1, int y0, int y1, int z0, int z1, T omega)
{
    addPressureBoundary<0,-1>(x0,x1,y0,y1,z0,z1, omega);