superboundarycondition3d.hh

open lattice boltzmann project www.openlb.org

        if (_sLattice.get_cGeometry().get_cuboid(iCglob).checkPoint(x, y, z,
                                   locX, locY, locZ, overlap)) {
            _blockBCs[iC]->addExternalVelocityCornerPNN(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>::
        addExternalVelocityCornerPNP(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]->addExternalVelocityCornerPNP(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>::
        addExternalVelocityCornerPPN(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]->addExternalVelocityCornerPPN(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>::
        addExternalVelocityCornerPPP(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]->addExternalVelocityCornerPPP(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>::
        addInternalVelocityCornerNNN(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]->addInternalVelocityCornerNNN(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>::
        addInternalVelocityCornerNNP(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]->addInternalVelocityCornerNNP(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>::
        addInternalVelocityCornerNPN(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]->addInternalVelocityCornerNPN(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>::
        addInternalVelocityCornerNPP(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]->addInternalVelocityCornerNPP(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>::
        addInternalVelocityCornerPNN(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]->addInternalVelocityCornerPNN(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>::
        addInternalVelocityCornerPNP(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]->addInternalVelocityCornerPNP(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>::
        addInternalVelocityCornerPPN(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]->addInternalVelocityCornerPPN(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>::
        addInternalVelocityCornerPPP(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]->addInternalVelocityCornerPPP(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>::
        addPoints2CommBC(int x0, int x1, int y0, int y1, int z0, int z1, int iCglob) {

    if (_overlap!=0) {
        int nC  = _sLattice.get_cGeometry().get_nC();
        T globX = _sLattice.get_cGeometry().get_cuboid(iCglob).get_globPosX();
        T globY = _sLattice.get_cGeometry().get_cuboid(iCglob).get_globPosY();
        T globZ = _sLattice.get_cGeometry().get_cuboid(iCglob).get_globPosZ();
        T delta = _sLattice.get_cGeometry().get_cuboid(iCglob).get_delta();

        for (int iOverl=1; iOverl<=_overlap; iOverl++) {
            for (int iX=x0-iOverl; iX<=x1+iOverl; iX++) {
                for (int iY=y0-iOverl; iY<=y1+iOverl; iY++) {
                    for (int iZ=z0-iOverl; iZ<=z1+iOverl; iZ++) {
                        if (iX==x0-iOverl || iX==x1+iOverl ||
                            iY==y0-iOverl || iY==y1+iOverl ||
                            iZ==z0-iOverl || iZ==z1+iOverl) {
                            T nextX = globX +iX*delta;
                            T nextY = globY +iY*delta;
                            T nextZ = globZ +iZ*delta;
                            int found_iC = _sLattice.get_cGeometry().get_iC(nextX, nextY, nextZ);
                            if (found_iC!=nC && found_iC!=iCglob) {
                                _sLattice.get_commBC().add_cell(iCglob, nextX, nextY, nextZ);
                            }
                        }
                    }
                }
            }
        }
    }
}

////////////////// Factory functions //////////////////////////////////

template<typename T, template<typename U> class Lattice, typename MixinDynamics>
void createLocalBoundaryCondition3D(sOnLatticeBoundaryCondition3D<T,Lattice>& sBC) {

    int nC = sBC.get_sLattice().get_load().size();
    sBC.set_overlap(0);
    for (int iC=0; iC<nC; iC++) {
        OnLatticeBoundaryCondition3D<T,Lattice>* blockBC
            = createLocalBoundaryCondition3D(sBC.get_sLattice().get_blockLattice(iC));
        sBC.get_blockBCs().push_back(blockBC);
    }
}

template<typename T, template<typename U> class Lattice, typename MixinDynamics>
void createInterpBoundaryCondition3D(sOnLatticeBoundaryCondition3D<T,Lattice>& sBC) {

    int nC = sBC.get_sLattice().get_load().size();
    sBC.set_overlap(1);
    for (int iC=0; iC<nC; iC++) {
        OnLatticeBoundaryCondition3D<T,Lattice>* blockBC
            = createInterpBoundaryCondition3D(sBC.get_sLattice().get_blockLattice(iC));
        sBC.get_blockBCs().push_back(blockBC);
    }
}

}  // namespace olb

#endif