advectiondiffusionboundaryinstantiator2d.h

open lattice boltzmann project www.openlb.org

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2008 Orestis Malaspinas, Andrea Parmigiani
 *  Address: EPFL-STI-LIN Station 9, 1015 Lausanne
 *  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 2D boundaries -- header file.  */
#ifndef ADVECTION_DIFFUSION_BOUNDARY_INSTANTIATOR_2D_H
#define ADVECTION_DIFFUSION_BOUNDARY_INSTANTIATOR_2D_H

#include "advectionDiffusionBoundaryCondition2D.h"
#include "advectionDiffusionBoundaryCondition2D.hh"

namespace olb {

template<typename T, template<typename U> class Lattice, class BoundaryManager>
class AdvectionDiffusionBoundaryConditionInstantiator2D : public OnLatticeAdvectionDiffusionBoundaryCondition2D<T,Lattice> {
public:
    AdvectionDiffusionBoundaryConditionInstantiator2D( BlockStructure2D<T,Lattice>& block_ );
    ~AdvectionDiffusionBoundaryConditionInstantiator2D();

    void addTemperatureBoundary0N(int x0, int x1, int y0, int y1, T omega);
    void addTemperatureBoundary0P(int x0, int x1, int y0, int y1, T omega);
    void addTemperatureBoundary1N(int x0, int x1, int y0, int y1, T omega);
    void addTemperatureBoundary1P(int x0, int x1, int y0, int y1, T omega);

	void addTemperatureCornerNN(int x, int y, T omega);
    void addTemperatureCornerNP(int x, int y, T omega);
    void addTemperatureCornerPN(int x, int y, T omega);
    void addTemperatureCornerPP(int x, int y, T omega);

    virtual BlockStructure2D<T,Lattice>& getBlock();
    virtual BlockStructure2D<T,Lattice> const& getBlock() const;
private:
    template<int direction, int orientation>
        void addTemperatureBoundary(int x0, int x1, int y0, int y1, T omega);
    template<int normalX, int normalY>
        void addTemperatureCorner(int x, int y, T omega);    
private:
    BlockStructure2D<T,Lattice>& block;
    std::vector<Momenta<T,Lattice>*>  momentaVector;
    std::vector<Dynamics<T,Lattice>*> dynamicsVector;
};

///////// class AdvectionDiffusionBoundaryConditionInstantiator2D ////////////////////////

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

template<typename T, template<typename U> class Lattice, class BoundaryManager>
AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::~AdvectionDiffusionBoundaryConditionInstantiator2D() {
    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 AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::
    addTemperatureBoundary(int x0, int x1, int y0, int y1, T omega)
{
    OLB_PRECONDITION(x0==x1 || y0==y1);

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

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


template<typename T, template<typename U> class Lattice, class BoundaryManager>
template<int xNormal, int yNormal>
void AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::
    addTemperatureCorner(int x, int y, T omega)
{
    Momenta<T,Lattice>* momenta
        = BoundaryManager::template getTemperatureCornerMomenta<xNormal,yNormal>();
    Dynamics<T,Lattice>* dynamics
        = BoundaryManager::template getTemperatureCornerDynamics<xNormal,yNormal>(omega, *momenta);

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

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



template<typename T, template<typename U> class Lattice, class BoundaryManager>
void AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::
    addTemperatureBoundary0N(int x0, int x1, int y0, int y1, T omega)
{
    addTemperatureBoundary<0,-1>(x0,x1,y0,y1, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::
    addTemperatureBoundary0P(int x0, int x1, int y0, int y1, T omega)
{
    addTemperatureBoundary<0,1>(x0,x1,y0,y1, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::
    addTemperatureBoundary1N(int x0, int x1, int y0, int y1, T omega)
{
    addTemperatureBoundary<1,-1>(x0,x1,y0,y1, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::
    addTemperatureBoundary1P(int x0, int x1, int y0, int y1, T omega)
{
    addTemperatureBoundary<1,1>(x0,x1,y0,y1, omega);
}


template<typename T, template<typename U> class Lattice, class BoundaryManager>
void AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::
    addTemperatureCornerNN(int x, int y, T omega)
{
    addTemperatureCorner<-1,-1>(x,y, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::
    addTemperatureCornerNP(int x, int y, T omega)
{
    addTemperatureCorner<-1,1>(x,y, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::
    addTemperatureCornerPN(int x, int y, T omega)
{
    addTemperatureCorner<1,-1>(x,y, omega);
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
void AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::
    addTemperatureCornerPP(int x, int y, T omega)
{
    addTemperatureCorner<1,1>(x,y, omega);
}


template<typename T, template<typename U> class Lattice, class BoundaryManager>
BlockStructure2D<T,Lattice>& AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::getBlock()
{
    return block;
}

template<typename T, template<typename U> class Lattice, class BoundaryManager>
BlockStructure2D<T,Lattice> const& AdvectionDiffusionBoundaryConditionInstantiator2D<T,Lattice,BoundaryManager>::getBlock() const
{
    return block;
}

}


#endif