superboundarycondition3d.hh

open lattice boltzmann project www.openlb.org

    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addInternalVelocityEdge0PN(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]->addInternalVelocityEdge0PN( 
                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>::
        addInternalVelocityEdge0PP(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]->addInternalVelocityEdge0PP( 
                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>::
        addInternalVelocityEdge1NN(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]->addInternalVelocityEdge1NN( 
                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>::
        addInternalVelocityEdge1NP(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]->addInternalVelocityEdge1NP( 
                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>::
        addInternalVelocityEdge1PN(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]->addInternalVelocityEdge1PN( 
                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>::
        addInternalVelocityEdge1PP(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]->addInternalVelocityEdge1PP( 
                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>::
        addInternalVelocityEdge2NN(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]->addInternalVelocityEdge2NN( 
                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>::
        addInternalVelocityEdge2NP(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]->addInternalVelocityEdge2NP( 
                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>::
        addInternalVelocityEdge2PN(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]->addInternalVelocityEdge2PN( 
                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>::
        addInternalVelocityEdge2PP(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]->addInternalVelocityEdge2PP( 
                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>::
        addExternalVelocityCornerNNN(T x, T y, T z, T omega) {

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX, locY, locZ;

    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkPoint(x, y, z,
                                   locX, locY, locZ, overlap)) {
            _blockBCs[iC]->addExternalVelocityCornerNNN(locX, locY, locZ, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkPoint(x, y, z,
                                   locX, locY, locZ)) {
            addPoints2CommBC(locX, locX, locY, locY, locZ, locZ, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addExternalVelocityCornerNNP(T x, T y, T z, T omega) {

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX, locY, locZ;

    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkPoint(x, y, z,
                                   locX, locY, locZ, overlap)) {
            _blockBCs[iC]->addExternalVelocityCornerNNP(locX, locY, locZ, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkPoint(x, y, z,
                                   locX, locY, locZ)) {
            addPoints2CommBC(locX, locX, locY, locY, locZ, locZ, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addExternalVelocityCornerNPN(T x, T y, T z, T omega) {

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX, locY, locZ;

    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkPoint(x, y, z,
                                   locX, locY, locZ, overlap)) {
            _blockBCs[iC]->addExternalVelocityCornerNPN(locX, locY, locZ, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkPoint(x, y, z,
                                   locX, locY, locZ)) {
            addPoints2CommBC(locX, locX, locY, locY, locZ, locZ, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addExternalVelocityCornerNPP(T x, T y, T z, T omega) {

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX, locY, locZ;

    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkPoint(x, y, z,
                                   locX, locY, locZ, overlap)) {
            _blockBCs[iC]->addExternalVelocityCornerNPP(locX, locY, locZ, omega);
        }
        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkPoint(x, y, z,
                                   locX, locY, locZ)) {
            addPoints2CommBC(locX, locX, locY, locY, locZ, locZ, iCglob);
        }
    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition3D<T,Lattice>::
        addExternalVelocityCornerPNN(T x, T y, T z, T omega) {

    int overlap = _sLattice.get_overlap();
    int nC = _sLattice.get_load().size();
    int locX, locY, locZ;

    for (int iC=0; iC<nC; iC++) {
        int iCglob = _sLattice.get_load().glob(iC);