olb::ShanChenForcedSingleComponentPostProcessor2D< T, DESCRIPTOR > Class Template Reference

Multiphysics class for coupling between different lattices. More...

#include <shanChenForcedSingleComponentPostProcessor2D.h>

Inheritance diagram for olb::ShanChenForcedSingleComponentPostProcessor2D< T, DESCRIPTOR >:

Collaboration diagram for olb::ShanChenForcedSingleComponentPostProcessor2D< T, DESCRIPTOR >:

Public Member Functions
	ShanChenForcedSingleComponentPostProcessor2D (int x0_, int x1_, int y0_, int y1_, T G_, std::vector< T > rho0_, AnalyticalF< 1, T, T > &iP_, std::vector< BlockStructureD< 2 > * > partners_)
	ShanChenForcedSingleComponentPostProcessor2D (T G_, std::vector< T > rho0_, AnalyticalF< 1, T, T > &iP_, std::vector< BlockStructureD< 2 > * > partners_)
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>
class olb::ShanChenForcedSingleComponentPostProcessor2D< T, DESCRIPTOR >

Multiphysics class for coupling between different lattices.

Definition at line 42 of file shanChenForcedSingleComponentPostProcessor2D.h.

Constructor & Destructor Documentation

ShanChenForcedSingleComponentPostProcessor2D() [1/2]

template<typename T , typename DESCRIPTOR >

olb::ShanChenForcedSingleComponentPostProcessor2D< T, DESCRIPTOR >::ShanChenForcedSingleComponentPostProcessor2D	(	int	x0_,
		int	x1_,
		int	y0_,
		int	y1_,
		T	G_,
		std::vector< T >	rho0_,
		AnalyticalF< 1, T, T > &	iP_,
		std::vector< BlockStructureD< 2 > * >	partners_ )

Definition at line 38 of file shanChenForcedSingleComponentPostProcessor2D.hh.

  :  x0(x0_), x1(x1_), y0(y0_), y1(y1_), G(G_), rho0(rho0_), interactionPotential(iP_), partners(partners_)
{
  this->getName() = "ShanChenForcedSingleComponentPostProcessor2D";
}

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

Here is the call graph for this function:

ShanChenForcedSingleComponentPostProcessor2D() [2/2]

template<typename T , typename DESCRIPTOR >

olb::ShanChenForcedSingleComponentPostProcessor2D< T, DESCRIPTOR >::ShanChenForcedSingleComponentPostProcessor2D	(	T	G_,
		std::vector< T >	rho0_,
		AnalyticalF< 1, T, T > &	iP_,
		std::vector< BlockStructureD< 2 > * >	partners_ )

Definition at line 49 of file shanChenForcedSingleComponentPostProcessor2D.hh.

  :  x0(0), x1(0), y0(0), y1(0), G(G_), rho0(rho0_), interactionPotential(iP_), partners(partners_)
{
  this->getName() = "ShanChenForcedSingleComponentPostProcessor2D";
}

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

Here is the call graph for this function:

Member Function Documentation

extent() [1/2]

template<typename T , typename DESCRIPTOR >

int olb::ShanChenForcedSingleComponentPostProcessor2D< T, DESCRIPTOR >::extent ( ) const

inlineoverridevirtual

Extent of application area (0 for purely local operations)

Implements olb::PostProcessor2D< T, DESCRIPTOR >.

Definition at line 52 of file shanChenForcedSingleComponentPostProcessor2D.h.

  {
    return 1;
  }

extent() [2/2]

template<typename T , typename DESCRIPTOR >

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

inlineoverridevirtual

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

Implements olb::PostProcessor2D< T, DESCRIPTOR >.

Definition at line 56 of file shanChenForcedSingleComponentPostProcessor2D.h.

  {
    return 1;
  }

process()

template<typename T , typename DESCRIPTOR >

void olb::ShanChenForcedSingleComponentPostProcessor2D< T, DESCRIPTOR >::process ( BlockLattice< T, DESCRIPTOR > & blockLattice )

overridevirtual

Execute post-processing step.

Implements olb::PostProcessor2D< T, DESCRIPTOR >.

Definition at line 126 of file shanChenForcedSingleComponentPostProcessor2D.hh.

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

processSubDomain()

template<typename T , typename DESCRIPTOR >

void olb::ShanChenForcedSingleComponentPostProcessor2D< T, DESCRIPTOR >::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 60 of file shanChenForcedSingleComponentPostProcessor2D.hh.

{
  typedef DESCRIPTOR L;
 
  int newX0, newX1, newY0, newY1;
  if ( util::intersect ( x0, x1, y0, y1,
                         x0_, x1_, y0_, y1_,
                         newX0, newX1, newY0, newY1 ) ) {
 
    auto& rhoField = blockLattice.template getField<RHO_CACHE>()[0];
 
    // Compute density and velocity on every site of first lattice, and store result
    //   in external scalars; envelope cells are included, because they are needed
    //   to compute the interaction potential in what follows.
    for (int iX=newX0-1; iX<=newX1+1; ++iX) {
      for (int iY=newY0-1; iY<=newY1+1; ++iY) {
        Cell<T,DESCRIPTOR> cell = blockLattice.get(iX,iY);
        rhoField[cell.getCellId()] = cell.computeRho()*rho0[0];
      }
    }
 
    for (int iX=newX0; iX<=newX1; ++iX) {
      for (int iY=newY0; iY<=newY1; ++iY) {
        Cell<T,DESCRIPTOR> blockCell = blockLattice.get(iX,iY);
 
        auto j = blockCell.template getField<descriptors::VELOCITY>();
        lbm<DESCRIPTOR>::computeJ(blockCell,j);
        blockCell.template setField<descriptors::VELOCITY>(j);
 
        T blockOmega   = blockCell.getDynamics()->getParameters(blockLattice).template getOrFallback<descriptors::OMEGA>(0);
 
        // Computation of the common velocity, shared among the two populations
        T rhoTot = rhoField[blockCell.getCellId()]*blockOmega;
 
        Vector<T, 2> uTot;
        auto blockU = blockCell.template getField<descriptors::VELOCITY>();     // contains precomputed value rho*u
        uTot = (blockU*rho0[0]*blockOmega) / rhoTot;
 
        // Computation of the interaction potential
        Vector<T, 2> rhoBlockContribution;
        T psi;
        interactionPotential(&psi, &rhoField[blockCell.getCellId()]);
        for (int iPop = 0; iPop < L::q; ++iPop) {
          int nextX = iX + descriptors::c<L>(iPop,0);
          int nextY = iY + descriptors::c<L>(iPop,1);
          T blockRho;
          interactionPotential(&blockRho, &rhoField[blockLattice.getCellId(nextX, nextY)]);//rho0[0];
          rhoBlockContribution   += psi * blockRho * descriptors::c<L>(iPop)* descriptors::t<T,L>(iPop);
        }
 
        // Computation and storage of the final velocity, consisting
        //   of u and the momentum difference due to interaction
        //   potential plus external force
        auto externalBlockForce   = blockCell.template getField<descriptors::EXTERNAL_FORCE>();
 
        blockCell.template setField<descriptors::VELOCITY>(uTot);
        blockCell.template setField<descriptors::FORCE>(externalBlockForce
            - G*rhoBlockContribution/rhoField[blockCell.getCellId()]);
      }
    }
  }
}

References olb::lbm< DESCRIPTOR >::computeJ(), olb::ConstCell< T, DESCRIPTOR >::computeRho(), olb::BlockLattice< T, DESCRIPTOR >::get(), olb::ConstCell< T, DESCRIPTOR >::getCellId(), olb::BlockStructureD< D >::getCellId(), olb::Cell< T, DESCRIPTOR >::getDynamics(), and olb::util::intersect().

Here is the call graph for this function:

---

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

• src/dynamics/shanChenForcedSingleComponentPostProcessor2D.h
• src/dynamics/shanChenForcedSingleComponentPostProcessor2D.hh