superboundarycondition2d.hh

open lattice boltzmann project www.openlb.org

    }
}

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition2D<T,Lattice>::
        addExternalVelocityCornerNN(T x, T y, T omega) {

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

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

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition2D<T,Lattice>::
        addExternalVelocityCornerNP(T x, T y, T omega) {

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

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

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition2D<T,Lattice>::
        addExternalVelocityCornerPN(T x, T y, T omega) {

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

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

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition2D<T,Lattice>::
        addExternalVelocityCornerPP(T x, T y, T omega) {

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

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

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition2D<T,Lattice>::
        addInternalVelocityCornerNN(T x, T y, T omega) {

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

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

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition2D<T,Lattice>::
        addInternalVelocityCornerNP(T x, T y, T omega) {

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

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

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition2D<T,Lattice>::
        addInternalVelocityCornerPN(T x, T y, T omega) {

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

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

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition2D<T,Lattice>::
        addInternalVelocityCornerPP(T x, T y, T omega) {

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

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

template<typename T, template<typename U> class Lattice>
void sOnLatticeBoundaryCondition2D<T,Lattice>::
        addPoints2CommBC(int x0, int x1, int y0, int y1, 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 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++) {
                    if (iX==x0-iOverl || iX==x1+iOverl ||
                                iY==y0-iOverl || iY==y1+iOverl) {
                        T nextX = globX +iX*delta;
                        T nextY = globY +iY*delta;
                        int found_iC = _sLattice.get_cGeometry().get_iC(nextX, nextY);
                        if (found_iC!=nC && found_iC!=iCglob) {
                            _sLattice.get_commBC().add_cell(iCglob, nextX, nextY);
                        }
                    }
                }
            }
        }
    }
}

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

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

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

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

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

}  // namespace olb

#endif