superboundarycondition3d.hh

open lattice boltzmann project www.openlb.org

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2007 Mathias J. Krause
 *  Address: Wilhelm-Maybach-Str. 24, 68766 Hockenheim, Germany 
 *  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 -- generic implementation.
 */


#ifndef SUPER_BOUNDARY_CONDITION_3D_HH
#define SUPER_BOUNDARY_CONDITION_3D_HH

#include <vector>
#include "core/boundaryCondition3D.h"
#include "superBoundaryCondition3D.h"
#include "superLattice3D.h"


namespace olb {


///////// class superBoundaryCondition3D ///////////////////////////////

template<typename T, template<typename U> class Lattice>
sOnLatticeBoundaryCondition3D<T,Lattice>::
    sOnLatticeBoundaryCondition3D (SuperLattice3D<T,Lattice>& sLattice ):_sLattice(sLattice) {
}

template<typename T, template<typename U> class Lattice>
sOnLatticeBoundaryCondition3D<T,Lattice>::
    sOnLatticeBoundaryCondition3D(sOnLatticeBoundaryCondition3D<T,Lattice> const& rhs):_sLattice(rhs._sLattice) {

    _blockBCs = rhs._blockBCs;
    _overlap = rhs._overlap;
}

template<typename T, template<typename U> class Lattice>
sOnLatticeBoundaryCondition3D<T,Lattice> sOnLatticeBoundaryCondition3D<T,Lattice>::operator=(
    sOnLatticeBoundaryCondition3D<T,Lattice> rhs) {

    sOnLatticeBoundaryCondition3D<T,Lattice> tmp(rhs);
    return tmp;
}

template<typename T, template<typename U> class Lattice>
sOnLatticeBoundaryCondition3D<T,Lattice>::
    ~sOnLatticeBoundaryCondition3D() {

    for (unsigned iC=0; iC<_blockBCs.size(); iC++) {
        delete _blockBCs[iC];
    }
}


template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addVelocityBoundary0N(T x0, T x1, T y0, T y1, T z0, T z1, T omega){

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX0, locX1, locY0, locY1, locZ0, locZ1;
    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters( x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1, overlap)) {
            _blockBCs[iC]->addVelocityBoundary0N( 
                locX0, locX1, locY0, locY1, locZ0, locZ1, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters(x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1)) {
            addPoints2CommBC(locX0, locX1, locY0, locY1, locZ0, locZ1, iCglob);
        }
    }
}


template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addVelocityBoundary0P(T x0, T x1, T y0, T y1, T z0, T z1, T omega){

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX0, locX1, locY0, locY1, locZ0, locZ1;
    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters( x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1, overlap)) {
            _blockBCs[iC]->addVelocityBoundary0P( 
                locX0, locX1, locY0, locY1, locZ0, locZ1, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters(x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1)) {
            addPoints2CommBC(locX0, locX1, locY0, locY1, locZ0, locZ1, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addVelocityBoundary1N(T x0, T x1, T y0, T y1, T z0, T z1, T omega){

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX0, locX1, locY0, locY1, locZ0, locZ1;
    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters( x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1, overlap)) {
            _blockBCs[iC]->addVelocityBoundary1N( 
                locX0, locX1, locY0, locY1, locZ0, locZ1, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters(x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1)) {
            addPoints2CommBC(locX0, locX1, locY0, locY1, locZ0, locZ1, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addVelocityBoundary1P(T x0, T x1, T y0, T y1, T z0, T z1, T omega){

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX0, locX1, locY0, locY1, locZ0, locZ1;
    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters( x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1, overlap)) {
            _blockBCs[iC]->addVelocityBoundary1P( 
                locX0, locX1, locY0, locY1, locZ0, locZ1, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters(x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1)) {
            addPoints2CommBC(locX0, locX1, locY0, locY1, locZ0, locZ1, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addVelocityBoundary2N(T x0, T x1, T y0, T y1, T z0, T z1, T omega){

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX0, locX1, locY0, locY1, locZ0, locZ1;
    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters( x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1, overlap)) {
            _blockBCs[iC]->addVelocityBoundary2N( 
                locX0, locX1, locY0, locY1, locZ0, locZ1, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters(x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1)) {
            addPoints2CommBC(locX0, locX1, locY0, locY1, locZ0, locZ1, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addVelocityBoundary2P(T x0, T x1, T y0, T y1, T z0, T z1, T omega){

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX0, locX1, locY0, locY1, locZ0, locZ1;
    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters( x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1, overlap)) {
            _blockBCs[iC]->addVelocityBoundary2P( 
                locX0, locX1, locY0, locY1, locZ0, locZ1, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters(x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1)) {
            addPoints2CommBC(locX0, locX1, locY0, locY1, locZ0, locZ1, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addPressureBoundary0N(T x0, T x1, T y0, T y1, T z0, T z1, T omega){

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX0, locX1, locY0, locY1, locZ0, locZ1;
    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters( x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1, overlap)) {
            _blockBCs[iC]->addPressureBoundary0N( 
                locX0, locX1, locY0, locY1, locZ0, locZ1, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters(x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1)) {
            addPoints2CommBC(locX0, locX1, locY0, locY1, locZ0, locZ1, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addPressureBoundary0P(T x0, T x1, T y0, T y1, T z0, T z1, T omega){

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX0, locX1, locY0, locY1, locZ0, locZ1;
    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters( x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1, overlap)) {
            _blockBCs[iC]->addPressureBoundary0P( 
                locX0, locX1, locY0, locY1, locZ0, locZ1, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters(x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1)) {
            addPoints2CommBC(locX0, locX1, locY0, locY1, locZ0, locZ1, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addPressureBoundary1N(T x0, T x1, T y0, T y1, T z0, T z1, T omega){

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX0, locX1, locY0, locY1, locZ0, locZ1;
    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters( x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1, overlap)) {
            _blockBCs[iC]->addPressureBoundary1N( 
                locX0, locX1, locY0, locY1, locZ0, locZ1, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters(x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1)) {
            addPoints2CommBC(locX0, locX1, locY0, locY1, locZ0, locZ1, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addPressureBoundary1P(T x0, T x1, T y0, T y1, T z0, T z1, T omega){

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX0, locX1, locY0, locY1, locZ0, locZ1;
    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters( x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1, overlap)) {
            _blockBCs[iC]->addPressureBoundary1P( 
                locX0, locX1, locY0, locY1, locZ0, locZ1, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters(x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1)) {
            addPoints2CommBC(locX0, locX1, locY0, locY1, locZ0, locZ1, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addPressureBoundary2N(T x0, T x1, T y0, T y1, T z0, T z1, T omega){

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX0, locX1, locY0, locY1, locZ0, locZ1;
    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters( x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1, overlap)) {
            _blockBCs[iC]->addPressureBoundary2N( 
                locX0, locX1, locY0, locY1, locZ0, locZ1, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkInters(x0, x1,
            y0, y1, z0, z1, locX0, locX1, locY0, locY1, locZ0, locZ1)) {
            addPoints2CommBC(locX0, locX1, locY0, locY1, locZ0, locZ1, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addPressureBoundary2P(T x0, T x1, T y0, T y1, T z0, T z1, T omega){