olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation > Class Template Reference

This class computes a convection BC on a flat wall in 2D. More...

#include <boundaryPostProcessors2D.h>

Inheritance diagram for olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >:

Collaboration diagram for olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >:

Public Member Functions
	StraightConvectionBoundaryProcessor2D (int x0_, int x1_, int y0_, int y1_, T *uAv_=NULL)
	~StraightConvectionBoundaryProcessor2D () override
int	extent () const override
	Extent of application area (0 for purely local operations)
int	extent (int whichDirection) const override
	Extent of application area along a direction (0 or 1)
void	process (BlockLattice< T, DESCRIPTOR > &blockLattice) override
	Execute post-processing step.
void	processSubDomain (BlockLattice< T, DESCRIPTOR > &blockLattice, int x0_, int x1_, int y0_, int y1_) override
	Execute post-processing step on a sublattice.
Public Member Functions inherited from olb::PostProcessor2D< T, DESCRIPTOR >
	PostProcessor2D ()
virtual	~PostProcessor2D ()
std::string &	getName ()
	read and write access to name
std::string const &	getName () const
	read only access to name
int	getPriority () const
	read only access to priority

Additional Inherited Members
Protected Attributes inherited from olb::PostProcessor2D< T, DESCRIPTOR >
int	_priority

Detailed Description

template<typename T, typename DESCRIPTOR, int direction, int orientation>
class olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >

This class computes a convection BC on a flat wall in 2D.

Definition at line 140 of file boundaryPostProcessors2D.h.

Constructor & Destructor Documentation

StraightConvectionBoundaryProcessor2D()

template<typename T , typename DESCRIPTOR , int direction, int orientation>

olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >::StraightConvectionBoundaryProcessor2D	(	int	x0_,
		int	x1_,
		int	y0_,
		int	y1_,
		T *	uAv_ = NULL )

Definition at line 86 of file boundaryPostProcessors2D.hh.

  : x0(x0_), x1(x1_), y0(y0_), y1(y1_), uAv(uAv_)
{
  OLB_PRECONDITION(x0==x1 || y0==y1);
 
  this->getName() = "StraightConvectionBoundaryProcessor2D";
  saveCell = new T** [(size_t)(x1_-x0_+1)];
  for (int iX=0; iX<=x1_-x0_; ++iX) {
    saveCell[iX] = new T* [(size_t)(y1_-y0_+1)];
    for (int iY=0; iY<=y1_-y0_; ++iY) {
      saveCell[iX][iY] = new T [(size_t)(DESCRIPTOR::q)];
      for (int iPop=0; iPop<DESCRIPTOR::q; ++iPop) {
        // default set to -1 in order to avoid wrong results at first call
        saveCell[iX][iY][iPop] = T(-1);
      }
    }
  }
}

References olb::PostProcessor2D< T, DESCRIPTOR >::getName(), and OLB_PRECONDITION.

Here is the call graph for this function:

~StraightConvectionBoundaryProcessor2D()

template<typename T , typename DESCRIPTOR , int direction, int orientation>

olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >::~StraightConvectionBoundaryProcessor2D ( )

override

Definition at line 107 of file boundaryPostProcessors2D.hh.

{
  for (int iX=0; iX<=x1-x0; ++iX) {
    for (int iY=0; iY<=y1-y0; ++iY) {
      delete [] saveCell[iX][iY];
    }
    delete [] saveCell[iX];
  }
  delete [] saveCell;
}

Member Function Documentation

extent() [1/2]

template<typename T , typename DESCRIPTOR , int direction, int orientation>

int olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >::extent ( ) const

inlineoverridevirtual

Extent of application area (0 for purely local operations)

Implements olb::PostProcessor2D< T, DESCRIPTOR >.

Definition at line 144 of file boundaryPostProcessors2D.h.

  {
    return 1;
  }

extent() [2/2]

template<typename T , typename DESCRIPTOR , int direction, int orientation>

int olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >::extent ( int direction ) const

inlineoverridevirtual

Extent of application area along a direction (0 or 1)

Implements olb::PostProcessor2D< T, DESCRIPTOR >.

Definition at line 148 of file boundaryPostProcessors2D.h.

  {
    return 1;
  }

process()

template<typename T , typename DESCRIPTOR , int direction, int orientation>

void olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >::process ( BlockLattice< T, DESCRIPTOR > & blockLattice )

overridevirtual

Execute post-processing step.

Implements olb::PostProcessor2D< T, DESCRIPTOR >.

Definition at line 182 of file boundaryPostProcessors2D.hh.

{
  processSubDomain(blockLattice, x0, x1, y0, y1);
}

processSubDomain()

template<typename T , typename DESCRIPTOR , int direction, int orientation>

void olb::StraightConvectionBoundaryProcessor2D< T, DESCRIPTOR, direction, orientation >::processSubDomain ( BlockLattice< T, DESCRIPTOR > & blockLattice, int x0_, int x1_, int y0_, int y1_ )

overridevirtual

Execute post-processing step on a sublattice.

Implements olb::PostProcessor2D< T, DESCRIPTOR >.

Definition at line 120 of file boundaryPostProcessors2D.hh.

{
  using namespace olb::util::tensorIndices2D;
 
  int newX0, newX1, newY0, newY1;
  if ( util::intersect (
         x0, x1, y0, y1,
         x0_, x1_, y0_, y1_,
         newX0, newX1, newY0, newY1 ) ) {
 
    int iX;
#ifdef PARALLEL_MODE_OMP
    #pragma omp parallel for
#endif
    for (iX=newX0; iX<=newX1; ++iX) {
      for (int iY=newY0; iY<=newY1; ++iY) {
        Cell<T,DESCRIPTOR> cell = blockLattice.get(iX,iY);
        for (int iPop = 0; iPop < DESCRIPTOR::q ; ++iPop) {
          if (descriptors::c<DESCRIPTOR>(iPop,direction)==-orientation) {
            // using default -1 avoids wrong first call
            if (!util::nearZero(1 + saveCell[iX-newX0][iY-newY0][iPop]) ) {
              cell[iPop] = saveCell[iX-newX0][iY-newY0][iPop];
            }
          }
        }
 
        T rho0, u0[2];
        T rho1, u1[2];
        T rho2, u2[2];
        if (direction==0) {
          blockLattice.get(iX,iY).computeRhoU(rho0,u0);
          blockLattice.get(iX-orientation,iY).computeRhoU(rho1,u1);
          blockLattice.get(iX-orientation*2,iY).computeRhoU(rho2,u2);
        }
        else {
          blockLattice.get(iX,iY).computeRhoU(rho0,u0);
          blockLattice.get(iX,iY-orientation).computeRhoU(rho1,u1);
          blockLattice.get(iX,iY-orientation*2).computeRhoU(rho2,u2);
        }
 
        // rho0 = T(1); rho1 = T(1); rho2 = T(1);
 
        T uDelta[2];
        T uAverage = rho0*u0[direction];
        if (uAv!=nullptr) {
          uAverage = *uAv;
        }
        uDelta[0]=-uAverage*0.5*(3*rho0*u0[0]-4*rho1*u1[0]+rho2*u2[0]);
        uDelta[1]=-uAverage*0.5*(3*rho0*u0[1]-4*rho1*u1[1]+rho2*u2[1]);
 
        for (int iPop = 0; iPop < DESCRIPTOR::q ; ++iPop) {
          if (descriptors::c<DESCRIPTOR>(iPop,direction) == -orientation) {
            saveCell[iX-newX0][iY-newY0][iPop] = cell[iPop] + descriptors::invCs2<T,DESCRIPTOR>()*descriptors::t<T,DESCRIPTOR>(iPop)*(uDelta[0]*descriptors::c<DESCRIPTOR>(iPop,0)+uDelta[1]*descriptors::c<DESCRIPTOR>(iPop,1));
          }
        }
      }
    }
  }
}

References olb::BlockLattice< T, DESCRIPTOR >::get(), olb::util::intersect(), and olb::util::nearZero().

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• src/boundary/boundaryPostProcessors2D.h
• src/boundary/boundaryPostProcessors2D.hh