olb::legacy Namespace Reference

Classes
struct	BasicDynamics
class	BGKdynamics
class	NoLatticeDynamics
class	OffDynamics
	Dynamics for offLattice boundary conditions OffDynamics are basically NoLatticeDynamics with the additional functionality to store given velocities exactly at boundary links. More...

Functions
template<typename T , typename DESCRIPTOR >
void	defineUBouzidi (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 2 > &superGeometry, int material, AnalyticalF2D< T, T > &u, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
template<typename T , typename DESCRIPTOR >
void	defineUBouzidi (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF2D< T > > &&indicator, FunctorPtr< SuperIndicatorF2D< T > > &&bulkIndicator, AnalyticalF2D< T, T > &u)
template<typename T , typename DESCRIPTOR >
void	defineUBouzidi (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF2D< T > &indicator, BlockIndicatorF2D< T > &bulkIndicator, AnalyticalF2D< T, T > &u)
template<typename T , typename DESCRIPTOR >
void	defineUBouzidi (BlockLattice< T, DESCRIPTOR > &block, int iX, int iY, int iPop, const T u[DESCRIPTOR::d])
template<typename T , typename DESCRIPTOR >
bool	getBoundaryIntersection (BlockLattice< T, DESCRIPTOR > &block, int iX, int iY, int iPop, T point[DESCRIPTOR::d])
template<typename T , typename DESCRIPTOR >
void	setBoundaryIntersection (BlockLattice< T, DESCRIPTOR > &block, int iX, int iY, int iPop, T distance)
template<typename T , typename DESCRIPTOR >
void	defineUBouzidi (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material, AnalyticalF3D< T, T > &u, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
template<typename T , typename DESCRIPTOR >
void	defineUBouzidi (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&boundaryIndicator, AnalyticalF3D< T, T > &u, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
template<typename T , typename DESCRIPTOR >
void	defineUBouzidi (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF3D< T > > &&bulkIndicator, AnalyticalF3D< T, T > &u)
template<typename T , typename DESCRIPTOR >
void	defineUBouzidi (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, BlockIndicatorF3D< T > &bulkIndicator, AnalyticalF3D< T, T > &u)
template<typename T , typename DESCRIPTOR >
void	defineUBouzidi (BlockLattice< T, DESCRIPTOR > &_block, int iX, int iY, int iZ, int iPop, const T u[DESCRIPTOR::d])
template<typename T , typename DESCRIPTOR >
bool	getBoundaryIntersection (BlockLattice< T, DESCRIPTOR > &_block, int iX, int iY, int iZ, int iPop, T point[DESCRIPTOR::d])
template<typename T , typename DESCRIPTOR >
void	setBoundaryIntersection (BlockLattice< T, DESCRIPTOR > &_block, int iX, int iY, int iZ, int iPop, T distance)
template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setBouzidiVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 2 > &superGeometry, int material, IndicatorF2D< T > &geometryIndicator, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
	Set offDynamics with boundary links and post processors using indicators.
template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setBouzidiVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF2D< T > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF2D< T > > &&bulkIndicator, IndicatorF2D< T > &geometryIndicator)
	Initialising the BouzidiVelocityBoundary on the superLattice domain.
template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setBouzidiVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF2D< T > &boundaryIndicator, BlockIndicatorF2D< T > &bulkIndicator, IndicatorF2D< T > &geometryIndicator)
template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setBouzidiVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 2 > &blockGeometryStructure, int iX, int iY, BlockIndicatorF2D< T > &bulkIndicator, IndicatorF2D< T > &geometryIndicator)
template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setBouzidiVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 2 > &blockGeometryStructure, int x, int y, T distances[DESCRIPTOR::q])
template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setBouzidiVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 2 > &blockGeometryStructure, int x, int y, int iPop, T dist)
template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setOffDynamics (BlockLattice< T, DESCRIPTOR > &block, int x, int y, T location[DESCRIPTOR::d], T distances[DESCRIPTOR::q])
template<typename T , typename DESCRIPTOR >
void	setBouzidiVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material, IndicatorF3D< T > &indicator, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
	Set offDynamics with boundary links and post processors using indicators.
template<typename T , typename DESCRIPTOR >
void	setBouzidiVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF3D< T > > &&bulkIndicator, IndicatorF3D< T > &geometryIndicator)
	Initialising the BouzidiVelocityBoundary on the superLattice domain.
template<typename T , typename DESCRIPTOR >
void	setBouzidiVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF3D< T > &boundaryIndicator, BlockIndicatorF3D< T > &bulkIndicator, IndicatorF3D< T > &geometryIndicator, T _epsFraction)
template<typename T , typename DESCRIPTOR >
void	setBouzidiVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 3 > &blockGeometryStructure, int iX, int iY, int iZ, IndicatorF3D< T > &geometryIndicator, BlockIndicatorF3D< T > &bulkIndicator, T _epsFraction)
template<typename T , typename DESCRIPTOR >
void	setBouzidiVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 3 > &blockGeometryStructure, int x, int y, int z, T distances[DESCRIPTOR::q])
template<typename T , typename DESCRIPTOR >
void	setBouzidiVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 3 > &blockGeometryStructure, int x, int y, int z, int iPop, T dist)
template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setBouzidiZeroVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 2 > &superGeometry, int material, IndicatorF2D< T > &geometryIndicator, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
	Set offDynamics with boundary links and post processors using indicators.
template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setBouzidiZeroVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF2D< T > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF2D< T > > &&bulkIndicator, IndicatorF2D< T > &geometryIndicator)
	Initialising the BouzidiZeroVelocityBoundary on the superLattice domain.
template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setBouzidiZeroVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF2D< T > &boundaryIndicator, BlockIndicatorF2D< T > &bulkIndicator, IndicatorF2D< T > &geometryIndicator)
template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setBouzidiZeroVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 2 > &blockGeometryStructure, int iX, int iY, BlockIndicatorF2D< T > &bulkIndicator, IndicatorF2D< T > &geometryIndicator)
template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setBouzidiZeroVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 2 > &blockGeometryStructure, int x, int y, T distances[DESCRIPTOR::q])
template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setBouzidiZeroVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 2 > &blockGeometryStructure, int x, int y, int iPop, T dist)
template<typename T , typename DESCRIPTOR >
void	setBouzidiZeroVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material, IndicatorF3D< T > &geometryIndicator, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
	Set offDynamics with boundary links and post processors using indicators.
template<typename T , typename DESCRIPTOR >
void	setBouzidiZeroVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&boundaryIndicator, IndicatorF3D< T > &geometryIndicator, std::vector< int > bulkMaterials)
template<typename T , typename DESCRIPTOR >
void	setBouzidiZeroVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF3D< T > > &&bulkIndicator, IndicatorF3D< T > &geometryIndicator)
template<typename T , typename DESCRIPTOR >
void	setBouzidiZeroVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF3D< T > &boundaryIndicator, BlockIndicatorF3D< T > &bulkIndicator, IndicatorF3D< T > &geometryIndicator, T _epsFraction)
template<typename T , typename DESCRIPTOR >
void	setBouzidiZeroVelocityBoundary1 (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 3 > &blockGeometryStructure, int iX, int iY, int iZ, IndicatorF3D< T > &geometryIndicator, BlockIndicatorF3D< T > &bulkIndicator, T _epsFraction)
template<typename T , typename DESCRIPTOR >
void	setBouzidiZeroVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 3 > &blockGeometryStructure, int x, int y, int z, T distances[DESCRIPTOR::q])
template<typename T , typename DESCRIPTOR >
void	setBouzidiZeroVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, 3 > &blockGeometryStructure, int x, int y, int z, int iPop, T dist)
template<typename T , typename DESCRIPTOR >
void	setWallFunctionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material, UnitConverter< T, DESCRIPTOR > const &converter, wallFunctionParam< T > const &wallFunctionParam, IndicatorF3D< T > *geoIndicator=NULL)
	Initialising the WallFunctionBoundary on the superLattice domain.
template<typename T , typename DESCRIPTOR >
void	setWallFunctionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator, UnitConverter< T, DESCRIPTOR > const &converter, wallFunctionParam< T > const &wallFunctionParam, IndicatorF3D< T > *geoIndicator)
	Initialising the WallFunctionBoundary on the superLattice domain.
template<typename T , typename DESCRIPTOR >
void	setWallFunctionBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, UnitConverter< T, DESCRIPTOR > const &converter, wallFunctionParam< T > const &wallFunctionParam, IndicatorF3D< T > *geoIndicator)
	Set WallFunction boundary for any indicated cells inside the block domain.

Function Documentation

defineUBouzidi() [1/9]

template<typename T , typename DESCRIPTOR >

void olb::legacy::defineUBouzidi	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		BlockIndicatorF3D< T > &	bulkIndicator,
		AnalyticalF3D< T, T > &	u )

Definition at line 67 of file defineU3D.hh.

{
  _block.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (indicator(iX,iY,iZ)) {
      for (int q = 1; q < DESCRIPTOR::q ; ++q) {
        // Get direction
        const int iXn = iX + descriptors::c<DESCRIPTOR>(q,0);
        const int iYn = iY + descriptors::c<DESCRIPTOR>(q,1);
        const int iZn = iZ + descriptors::c<DESCRIPTOR>(q,2);
        if (_block.isInside({iXn,iYn,iZn}) && bulkIndicator(iXn,iYn,iZn)) {
          T intersection[3] = { };
          const int opp = descriptors::opposite<DESCRIPTOR>(q);
          if (getBoundaryIntersection<T,DESCRIPTOR>(_block, iX, iY, iZ, opp, intersection)) {
            T vel[3]= { };
            u(vel, intersection);
            defineUBouzidi<T,DESCRIPTOR>(_block, iX, iY, iZ, opp, vel);
          }
        }
      }
    }
  });
}

References olb::descriptors::c(), defineUBouzidi(), getBoundaryIntersection(), and olb::descriptors::opposite().

Here is the call graph for this function:

defineUBouzidi() [2/9]

template<typename T , typename DESCRIPTOR >

void olb::legacy::defineUBouzidi	(	BlockLattice< T, DESCRIPTOR > &	_block,
		int	iX,
		int	iY,
		int	iZ,
		int	iPop,
		const T	u[DESCRIPTOR::d] )

Definition at line 93 of file defineU3D.hh.

{
  OstreamManager clout(std::cout, "defineUBouzidi");
  bool _output = false;
  static_cast<legacy::OffDynamics<T,DESCRIPTOR>*>(_block.getDynamics(iX, iY, iZ))->defineU(iPop, u);
  if (_output) {
    clout << "defineUBouzidi(" << iX << ", " << iY << ", " << iZ << " )" << std::endl;
  }
 
}

References olb::legacy::OffDynamics< T, DESCRIPTOR >::defineU().

Here is the call graph for this function:

defineUBouzidi() [3/9]

template<typename T , typename DESCRIPTOR >

void olb::legacy::defineUBouzidi	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF2D< T > &	indicator,
		BlockIndicatorF2D< T > &	bulkIndicator,
		AnalyticalF2D< T, T > &	u )

Definition at line 60 of file defineU2D.hh.

{
  block.forSpatialLocations([&](auto iX, auto iY) {
    if (indicator(iX,iY)) {
      for (int iPop = 1; iPop < DESCRIPTOR::q ; ++iPop) {
        int iXn = iX + descriptors::c<DESCRIPTOR >(iPop,0);
        int iYn = iY + descriptors::c<DESCRIPTOR >(iPop,1);
        if (block.isInside({iXn,iYn}) && bulkIndicator(iXn, iYn)) {
          T intersection[] = { T(), T() }; // coord. of intersection
          int opp = descriptors::opposite<DESCRIPTOR >(iPop);
          if (getBoundaryIntersection<T,DESCRIPTOR>(block, iX, iY, opp, intersection) ) {
            T vel[]= {T(),T()};
            u(vel,intersection);
            defineUBouzidi<T,DESCRIPTOR>(iX, iY, opp, vel);
          }
        }
      }
    }
  });
}

References olb::descriptors::c(), defineUBouzidi(), getBoundaryIntersection(), and olb::descriptors::opposite().

Here is the call graph for this function:

defineUBouzidi() [4/9]

template<typename T , typename DESCRIPTOR >

void olb::legacy::defineUBouzidi	(	BlockLattice< T, DESCRIPTOR > &	block,
		int	iX,
		int	iY,
		int	iPop,
		const T	u[DESCRIPTOR::d] )

Definition at line 83 of file defineU2D.hh.

{
  bool _output = false;
  OstreamManager clout(std::cout, "defineUBouzidi");
  block.getDynamics(iX, iY)->defineU(iPop, u);
  if (_output) {
    clout << "defineUBouzidi(" << iX << ", " << iY << " )" << std::endl;
  }
}

defineUBouzidi() [5/9]

template<typename T , typename DESCRIPTOR >

void olb::legacy::defineUBouzidi	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator,
		FunctorPtr< SuperIndicatorF2D< T > > &&	bulkIndicator,
		AnalyticalF2D< T, T > &	u )

Definition at line 45 of file defineU2D.hh.

{
 
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    defineUBouzidi<T,DESCRIPTOR>(sLattice.getBlockIndicator(iCloc), indicator->getBlockIndicatorF(iCloc),
                                 bulkIndicator->getBlockIndicatorF(iCloc),
                                 u);
  }
}

References defineUBouzidi(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

defineUBouzidi() [6/9]

template<typename T , typename DESCRIPTOR >

void olb::legacy::defineUBouzidi	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	boundaryIndicator,
		AnalyticalF3D< T, T > &	u,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Definition at line 43 of file defineU3D.hh.

{
  defineUBouzidi<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator),
                               boundaryIndicator->getSuperGeometry().getMaterialIndicator(std::move(bulkMaterials)),
                               u);
}

References defineUBouzidi().

Here is the call graph for this function:

defineUBouzidi() [7/9]

template<typename T , typename DESCRIPTOR >

void olb::legacy::defineUBouzidi	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	boundaryIndicator,
		FunctorPtr< SuperIndicatorF3D< T > > &&	bulkIndicator,
		AnalyticalF3D< T, T > &	u )

Definition at line 52 of file defineU3D.hh.

{
 
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    defineUBouzidi<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
                                 boundaryIndicator->getBlockIndicatorF(iCloc),
                                 bulkIndicator->getBlockIndicatorF(iCloc),u);
  }
 
}

References defineUBouzidi(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

defineUBouzidi() [8/9]

template<typename T , typename DESCRIPTOR >

void olb::legacy::defineUBouzidi	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material,
		AnalyticalF2D< T, T > &	u,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Definition at line 35 of file defineU2D.hh.

{
  defineUBouzidi<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material),
                               superGeometry.getMaterialIndicator(std::move(bulkMaterials)),
                               u);
}

References defineUBouzidi(), and olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

Here is the caller graph for this function:

defineUBouzidi() [9/9]

template<typename T , typename DESCRIPTOR >

void olb::legacy::defineUBouzidi	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		AnalyticalF3D< T, T > &	u,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Definition at line 35 of file defineU3D.hh.

{
  defineUBouzidi<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material), u, bulkMaterials);
}

References defineUBouzidi(), and olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

getBoundaryIntersection() [1/2]

template<typename T , typename DESCRIPTOR >

bool olb::legacy::getBoundaryIntersection	(	BlockLattice< T, DESCRIPTOR > &	_block,
		int	iX,
		int	iY,
		int	iZ,
		int	iPop,
		T	point[DESCRIPTOR::d] )

Definition at line 105 of file defineU3D.hh.

{
  return static_cast<legacy::OffDynamics<T,DESCRIPTOR>*>(_block.getDynamics(iX, iY, iZ))->getBoundaryIntersection(iPop, point);
}

References olb::legacy::OffDynamics< T, DESCRIPTOR >::getBoundaryIntersection().

Here is the call graph for this function:

getBoundaryIntersection() [2/2]

template<typename T , typename DESCRIPTOR >

bool olb::legacy::getBoundaryIntersection	(	BlockLattice< T, DESCRIPTOR > &	block,
		int	iX,
		int	iY,
		int	iPop,
		T	point[DESCRIPTOR::d] )

Definition at line 96 of file defineU2D.hh.

{
  return static_cast<legacy::OffDynamics<T,DESCRIPTOR>*>(block.getDynamics(iX,iY))->getBoundaryIntersection(iPop, point);
}

References olb::legacy::OffDynamics< T, DESCRIPTOR >::getBoundaryIntersection().

Here is the call graph for this function:

Here is the caller graph for this function:

setBoundaryIntersection() [1/2]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBoundaryIntersection	(	BlockLattice< T, DESCRIPTOR > &	_block,
		int	iX,
		int	iY,
		int	iZ,
		int	iPop,
		T	distance )

Definition at line 111 of file defineU3D.hh.

{
  bool _output = false;
  OstreamManager clout(std::cout, "setBoundaryIntersection");
  _block.getDynamics(iX, iY, iZ)->setBoundaryIntersection(iPop, distance);
  if (_output) {
    clout << "setBoundaryIntersection(" << iX << ", " << iY << ", " << iZ << " )" << std::endl;
  }
}

setBoundaryIntersection() [2/2]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBoundaryIntersection	(	BlockLattice< T, DESCRIPTOR > &	block,
		int	iX,
		int	iY,
		int	iPop,
		T	distance )

Definition at line 102 of file defineU2D.hh.

{
  bool _output = false;
  OstreamManager clout(std::cout, "setBoundaryIntersection");
  static_cast<legacy::OffDynamics<T,DESCRIPTOR>*>(block.getDynamics(iX,iY))->setBoundaryIntersection(iPop, distance);
  if (_output) {
    clout << "setBoundaryIntersection(" << iX << ", " << iY << " )" << std::endl;
  }
}

References olb::legacy::OffDynamics< T, DESCRIPTOR >::setBoundaryIntersection().

Here is the call graph for this function:

setBouzidiVelocityBoundary() [1/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::legacy::setBouzidiVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 2 > &	blockGeometryStructure,
		int	iX,
		int	iY,
		BlockIndicatorF2D< T > &	bulkIndicator,
		IndicatorF2D< T > &	geometryIndicator )

Definition at line 101 of file setBouzidiVelocityBoundary2D.hh.

{
  T _epsFraction = 0.0001;
  OstreamManager clout(std::cout, "setBouzidiVelocityBoundary");
  T distances[DESCRIPTOR::q];
  for (int iPop = 1; iPop < DESCRIPTOR::q ; ++iPop) {
    distances[iPop] = -1;
  }
 
  for (int iPop = 1; iPop < DESCRIPTOR::q ; ++iPop) {
    const int iXn = iX + descriptors::c<DESCRIPTOR >(iPop,0);
    const int iYn = iY + descriptors::c<DESCRIPTOR >(iPop,1);
    if (blockGeometryStructure.isInside(iXn,iYn) && bulkIndicator(iXn,iYn)) {
      T dist = -1;
      T physR[2];
      blockGeometryStructure.getPhysR(physR,{iXn,iYn});
      T voxelSize=blockGeometryStructure.getDeltaR();
      Vector<T,2> physC(physR);
 
      Vector<T,2> direction(-voxelSize*descriptors::c<DESCRIPTOR >(iPop,0),-voxelSize*descriptors::c<DESCRIPTOR >(iPop,1));
      T cPhysNorm = voxelSize*util::sqrt(descriptors::c<DESCRIPTOR >(iPop,0)*descriptors::c<DESCRIPTOR >(iPop,0)+descriptors::c<DESCRIPTOR >(iPop,1)*descriptors::c<DESCRIPTOR >(iPop,1));
 
      if (!geometryIndicator.distance(dist,physC,direction,blockGeometryStructure.getIcGlob() ) ) {
        T epsX = voxelSize*descriptors::c<DESCRIPTOR >(iPop,0)*_epsFraction;
        T epsY = voxelSize*descriptors::c<DESCRIPTOR >(iPop,1)*_epsFraction;
 
        Vector<T,2> physC2(physC);
        physC2[0] += epsX;
        physC2[1] += epsY;
        Vector<T,2> direction2(direction);
        direction2[0] -= 2.*epsX;
        direction2[1] -= 2.*epsY;
 
        if ( !geometryIndicator.distance(dist,physC2,direction2,blockGeometryStructure.getIcGlob())) {
          clout << "ERROR: no boundary found at (" << iXn << "," << iYn <<") ~ ("
                << physR[0] << "," << physR[1] << "), "
                << "in direction " << descriptors::opposite<DESCRIPTOR >(iPop)
                << std::endl;
        }
        T distNew = (dist - util::sqrt(epsX*epsX+epsY*epsY))/cPhysNorm;
        if (distNew < 0.5) {
          dist = 0;
        }
        else {
          dist = 0.5 * cPhysNorm;
          clout << "WARNING: distance at (" << iXn << "," << iYn <<") ~ ("
                << physR[0] << "," << physR[1] <<"), "
                << "in direction " << descriptors::opposite<DESCRIPTOR >(iPop) << ": "
                << distNew
                << " rounded to "
                << dist/cPhysNorm
                << std::endl;
        }
      }
      distances[descriptors::opposite<DESCRIPTOR >(iPop)] = dist/cPhysNorm;
    } // bulk indicator
  } // iPop loop
  setBouzidiVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(block, blockGeometryStructure, iX, iY, distances);
 
}

References olb::descriptors::c(), olb::IndicatorF2D< T >::distance(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getIcGlob(), olb::BlockGeometry< T, D >::getPhysR(), olb::BlockStructureD< D >::isInside(), olb::descriptors::opposite(), setBouzidiVelocityBoundary(), and olb::util::sqrt().

Here is the call graph for this function:

setBouzidiVelocityBoundary() [2/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::legacy::setBouzidiVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 2 > &	blockGeometryStructure,
		int	x,
		int	y,
		int	iPop,
		T	dist )

Using Bouzidi BC OnePoint. This corresponds to Bounce Back

Using Bouzidi BC TwoPoint. This corresponds to Linear Interpolation

Using Bouzidi BC OnePoint. This corresponds to Bounce Back

Using Bouzidi BC TwoPoint. This corresponds to Linear Interpolation

Definition at line 190 of file setBouzidiVelocityBoundary2D.hh.

{
  PostProcessorGenerator2D<T, DESCRIPTOR>* postProcessor{};
  if (blockGeometryStructure.getMaterial({x-descriptors::c<DESCRIPTOR >(iPop,0), y-descriptors::c<DESCRIPTOR >(iPop,1)}) != 1) {
    postProcessor = new VelocityBounceBackPostProcessorGenerator2D<T,DESCRIPTOR>(x, y, iPop, dist);
 
  }
  else {
    postProcessor =new VelocityBouzidiLinearPostProcessorGenerator2D<T,DESCRIPTOR>(x, y, iPop, dist);
  }
 
  if (postProcessor && !block.isPadding({x,y})) {
    block.addPostProcessor(*postProcessor);
  }
}

References olb::BlockGeometry< T, D >::getMaterial().

Here is the call graph for this function:

setBouzidiVelocityBoundary() [3/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::legacy::setBouzidiVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 2 > &	blockGeometryStructure,
		int	x,
		int	y,
		T	distances[DESCRIPTOR::q] )

Definition at line 163 of file setBouzidiVelocityBoundary2D.hh.

{
  typedef DESCRIPTOR L;
  T location[DESCRIPTOR::d];
  blockGeometryStructure.getPhysR(location, {x,y});
 
  T distancesCopy[L::q];
  T spacing = blockGeometryStructure.getDeltaR();
  for (int iPop = 1; iPop < L::q ; ++iPop) {
    distancesCopy[iPop] = spacing*(1.-distances[iPop]);
    if ( !util::nearZero(distances[iPop]+1) ) {
      distancesCopy[iPop] = -1;
    }
  }
  //can be universally used for Bouzidi and bounceBackVelocityBoundary
  setOffDynamics<T,DESCRIPTOR,MixinDynamics>(block, x, y, location, distancesCopy);
 
  for (int iPop = 1; iPop < L::q ; ++iPop) {
    if ( !util::nearZero(distances[iPop]+1) ) {
      setBouzidiVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(block, blockGeometryStructure, x-descriptors::c<L>(iPop,0), y-descriptors::c<L>(iPop,1), iPop, distances[iPop]);
    }
  }
 
}

References olb::descriptors::c(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getPhysR(), olb::util::nearZero(), setBouzidiVelocityBoundary(), and setOffDynamics().

Here is the call graph for this function:

setBouzidiVelocityBoundary() [4/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 3 > &	blockGeometryStructure,
		int	iX,
		int	iY,
		int	iZ,
		IndicatorF3D< T > &	geometryIndicator,
		BlockIndicatorF3D< T > &	bulkIndicator,
		T	_epsFraction )

Definition at line 108 of file setBouzidiVelocityBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setBouzidiBoundary");
  T distances[DESCRIPTOR::q];
  for (int iPop = 1; iPop < DESCRIPTOR::q ; ++iPop) {
    distances[iPop] = -1;
  }
 
  for (int iPop = 1; iPop < DESCRIPTOR::q ; ++iPop) {
    const Vector<int,3> c = descriptors::c<DESCRIPTOR>(iPop);
    const int iXn = iX + c[0];
    const int iYn = iY + c[1];
    const int iZn = iZ + c[2];
    if (blockGeometryStructure.isInside(iXn,iYn,iZn) && bulkIndicator(iXn,iYn,iZn)) {
      T dist = -1;
      T physR[3];
      blockGeometryStructure.getPhysR(physR,{iXn,iYn,iZn});
      T voxelSize=blockGeometryStructure.getDeltaR();
 
      Vector<T,3> physC(physR);
      Vector<T,3> direction(-voxelSize*c[0],-voxelSize*c[1],-voxelSize*c[2]);
      T cPhysNorm = voxelSize*util::sqrt(c[0]*c[0]+c[1]*c[1]+c[2]*c[2]);
 
      if (!geometryIndicator.distance(dist,physC,direction,blockGeometryStructure.getIcGlob() ) ) {
        T epsX = voxelSize*c[0]*_epsFraction;
        T epsY = voxelSize*c[1]*_epsFraction;
        T epsZ = voxelSize*c[2]*_epsFraction;
 
        Vector<T,3> physC2(physC);
        physC2[0] += epsX;
        physC2[1] += epsY;
        physC2[2] += epsZ;
        Vector<T,3> direction2(direction);
        direction2[0] -= 2.*epsX;
        direction2[1] -= 2.*epsY;
        direction2[2] -= 2.*epsZ;
 
        if ( !geometryIndicator.distance(dist,physC2,direction2,blockGeometryStructure.getIcGlob())) {
          clout << "ERROR: no boundary found at (" << iXn << "," << iYn << "," << iZn <<") ~ ("
                << physR[0] << "," << physR[1] << "," << physR[2] <<"), "
                << "in direction " << descriptors::opposite<DESCRIPTOR >(iPop)
                << std::endl;
 
        }
        T distNew = (dist - util::sqrt(epsX*epsX+epsY*epsY+epsZ*epsZ))/cPhysNorm;
        if (distNew < 0.5) {
          dist = 0;
        }
        else {
          dist = 0.5 * cPhysNorm;
          clout << "WARNING: distance at (" << iXn << "," << iYn << "," << iZn <<") ~ ("
                << physR[0] << "," << physR[1] << "," << physR[2] <<"), "
                << "in direction " << descriptors::opposite<DESCRIPTOR >(iPop) << ": "
                << distNew
                << " rounded to "
                << dist/cPhysNorm
                << std::endl;
 
        }
      }
      distances[descriptors::opposite<DESCRIPTOR >(iPop)] = dist/cPhysNorm;
    } // bulk indicator if
  } // iPop loop
  setBouzidiVelocityBoundary<T,DESCRIPTOR>(block, blockGeometryStructure, iX, iY, iZ, distances);
}

References olb::descriptors::c(), olb::IndicatorF3D< T >::distance(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getIcGlob(), olb::BlockGeometry< T, D >::getPhysR(), olb::BlockStructureD< D >::isInside(), olb::descriptors::opposite(), setBouzidiVelocityBoundary(), and olb::util::sqrt().

Here is the call graph for this function:

setBouzidiVelocityBoundary() [5/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 3 > &	blockGeometryStructure,
		int	x,
		int	y,
		int	z,
		int	iPop,
		T	dist )

Definition at line 202 of file setBouzidiVelocityBoundary3D.hh.

{
  const Vector<int,3> c = descriptors::c<DESCRIPTOR>(iPop);
  //setOnePointVelocityBoundary. This corresponds to Bounce Back
  auto postProcessor = std::unique_ptr<PostProcessorGenerator3D<T, DESCRIPTOR>> { nullptr };
  if (blockGeometryStructure.getMaterial({x-c[0], y-c[1], z-c[2]}) != 1) {
    postProcessor.reset(new VelocityBounceBackPostProcessorGenerator3D <T, DESCRIPTOR>(x, y, z, iPop, dist));
  }
  //setTwoPointVelocityBoundary.This corresponds to Linear Interpolation
  else {
    postProcessor.reset(new VelocityBouzidiLinearPostProcessorGenerator3D<T, DESCRIPTOR>(x, y, z, iPop, dist));
  }
  if (postProcessor && !block.isPadding({x,y,z})) {
    block.addPostProcessor(*postProcessor);
  }
}

References olb::descriptors::c(), and olb::BlockGeometry< T, D >::getMaterial().

Here is the call graph for this function:

setBouzidiVelocityBoundary() [6/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 3 > &	blockGeometryStructure,
		int	x,
		int	y,
		int	z,
		T	distances[DESCRIPTOR::q] )

Definition at line 177 of file setBouzidiVelocityBoundary3D.hh.

{
  T location[DESCRIPTOR::d];
  blockGeometryStructure.getPhysR(location, {x,y,z});
  T distancesCopy[DESCRIPTOR::q];
  T spacing = blockGeometryStructure.getDeltaR();
  for (int iPop = 1; iPop < DESCRIPTOR::q ; ++iPop) {
    distancesCopy[iPop] = spacing*(1.-distances[iPop]);
    if ( util::nearZero(distances[iPop]+1) ) {
      distancesCopy[iPop] = -1;
    }
  }
  Dynamics<T,DESCRIPTOR>* dynamics = new legacy::OffDynamics<T, DESCRIPTOR>(location, distancesCopy);
  block.defineDynamics({x,y,z}, dynamics);
 
  for (int iPop = 1; iPop < DESCRIPTOR::q ; ++iPop) {
    if (!util::nearZero(distances[iPop]+1)) {
      const Vector<int,3> c = descriptors::c<DESCRIPTOR>(iPop);
 
      setBouzidiVelocityBoundary<T,DESCRIPTOR>(block, blockGeometryStructure, x-c[0], y-c[1], z-c[2], iPop, distances[iPop]);
    }
  }
}

References olb::descriptors::c(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getPhysR(), olb::util::nearZero(), and setBouzidiVelocityBoundary().

Here is the call graph for this function:

setBouzidiVelocityBoundary() [7/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::legacy::setBouzidiVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF2D< T > &	boundaryIndicator,
		BlockIndicatorF2D< T > &	bulkIndicator,
		IndicatorF2D< T > &	geometryIndicator )

Definition at line 87 of file setBouzidiVelocityBoundary2D.hh.

{
  block.forSpatialLocations([&](auto iX, auto iY) {
    if (boundaryIndicator(iX,iY)) {
      setBouzidiVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(block,
                                                             bulkIndicator.getBlockGeometry(),
                                                             iX, iY,
                                                             bulkIndicator,
                                                             geometryIndicator);
    }
  });
}

References olb::BlockIndicatorF2D< T >::getBlockGeometry(), and setBouzidiVelocityBoundary().

Here is the call graph for this function:

setBouzidiVelocityBoundary() [8/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF3D< T > &	boundaryIndicator,
		BlockIndicatorF3D< T > &	bulkIndicator,
		IndicatorF3D< T > &	geometryIndicator,
		T	_epsFraction )

Definition at line 91 of file setBouzidiVelocityBoundary3D.hh.

{
  block.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (boundaryIndicator(iX,iY,iZ)) {
      setBouzidiVelocityBoundary<T,DESCRIPTOR>(block,
                                               bulkIndicator.getBlockGeometry(),
                                               iX, iY, iZ,
                                               geometryIndicator,
                                               bulkIndicator,
                                               _epsFraction);
    }
  });
}

References olb::BlockIndicatorF3D< T >::getBlockGeometry(), and setBouzidiVelocityBoundary().

Here is the call graph for this function:

setBouzidiVelocityBoundary() [9/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::legacy::setBouzidiVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF2D< T > > &&	boundaryIndicator,
		FunctorPtr< SuperIndicatorF2D< T > > &&	bulkIndicator,
		IndicatorF2D< T > &	geometryIndicator )

Initialising the BouzidiVelocityBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 52 of file setBouzidiVelocityBoundary2D.hh.

{
  T _epsFraction = 0.0001;
  /*  local boundaries: _overlap = 0;
   *  interp boundaries: _overlap = 1;
   *  bouzidi boundaries: _overlap = 1;
   *  extField boundaries: _overlap = 1;
   *  advectionDiffusion boundaries: _overlap = 1;
   */
  int _overlap = 1;
 
  OstreamManager clout(std::cout, "setBouzidiVelocityBoundary");
  clout << "epsFraction=" << _epsFraction << std::endl;
  clout.setMultiOutput(true);
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    clout << "Cuboid globiC " << sLattice.getLoadBalancer().glob(iCloc)
          << " starts to read distances for Velocity Boundary..." << std::endl;
    setBouzidiVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc),boundaryIndicator->getBlockIndicatorF(iCloc),
        bulkIndicator->getBlockIndicatorF(iCloc),
        geometryIndicator);
    clout << "Cuboid globiC " << sLattice.getLoadBalancer().glob(iCloc)
          << " finished reading distances for Velocity Boundary." << std::endl;
  }
  clout.setMultiOutput(false);
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator), _overlap);
}

References olb::addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), setBouzidiVelocityBoundary(), and olb::OstreamManager::setMultiOutput().

Here is the call graph for this function:

setBouzidiVelocityBoundary() [10/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	boundaryIndicator,
		FunctorPtr< SuperIndicatorF3D< T > > &&	bulkIndicator,
		IndicatorF3D< T > &	geometryIndicator )

Initialising the BouzidiVelocityBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 52 of file setBouzidiVelocityBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setBouzidiBoundary");
  T _epsFraction = 0.0001;
  int overlap = 1;
  bool _output = false;
  if (_output) {
    clout << "epsFraction=" << _epsFraction << std::endl;
    clout.setMultiOutput(true);
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    if (_output) {
      clout << "Cuboid globiC " << sLattice.getLoadBalancer().glob(iCloc)
            << " starts to read distances for Velocity Boundary..." << std::endl;
    }
    //this is a guess to solve the private member block issue
    setBouzidiVelocityBoundary<T,DESCRIPTOR>(
      sLattice.getBlock(iCloc), boundaryIndicator->getBlockIndicatorF(iCloc),
      bulkIndicator->getBlockIndicatorF(iCloc),
      geometryIndicator, _epsFraction);
    if (_output) {
      clout << "Cuboid globiC " << sLattice.getLoadBalancer().glob(iCloc)
            << " finished reading distances for Velocity Boundary." << std::endl;
    }
  }
  if (_output) {
    clout.setMultiOutput(false);
  }
  addPoints2CommBC<T,DESCRIPTOR>(sLattice,std::forward<decltype(boundaryIndicator)>(boundaryIndicator), overlap);
}

References olb::addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), setBouzidiVelocityBoundary(), and olb::OstreamManager::setMultiOutput().

Here is the call graph for this function:

setBouzidiVelocityBoundary() [11/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::legacy::setBouzidiVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material,
		IndicatorF2D< T > &	geometryIndicator,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Set offDynamics with boundary links and post processors using indicators.

Initialising the BouzidiVelocityBoundary on the superLattice domain.

Add offDynamics with initialisation of boundary links and the corresponding post processors Note: Uses information of the second neighbours of the cell (x,y) Add post processors. Ensure that offDynamics are defined!

Parameters

boundaryIndicator	Indicator describing boundary cells
bulkIndicator	Indicator describing bulk cells
geometryIndicator	Indicator describing the geometry to be bounded Initialising the BouzidiVelocityBoundary on the superLattice domain

Definition at line 41 of file setBouzidiVelocityBoundary2D.hh.

{
 
  setBouzidiVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, superGeometry.getMaterialIndicator(material),
      superGeometry.getMaterialIndicator(std::move(bulkMaterials)),
      geometryIndicator);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiVelocityBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

setBouzidiVelocityBoundary() [12/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		IndicatorF3D< T > &	indicator,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Set offDynamics with boundary links and post processors using indicators.

Initialising the BouzidiVelocityBoundary on the superLattice domain.

Add offDynamics with initialisation of boundary links and the corresponding post processors Note: Uses information of the second neighbours of the cell (x,y,z) Add post processors. Ensure that offDynamics are defined!

Parameters

boundaryIndicator	Indicator describing boundary cells
bulkIndicator	Indicator describing bulk cells
geometryIndicator	Indicator describing the geometry to be bounded Initialising the BouzidiVelocityBoundary on the superLattice domain

Definition at line 40 of file setBouzidiVelocityBoundary3D.hh.

{
 
  setBouzidiVelocityBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material),
      superGeometry.getMaterialIndicator(std::move(bulkMaterials)),
      geometryIndicator);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiVelocityBoundary().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary() [1/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::legacy::setBouzidiZeroVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 2 > &	blockGeometryStructure,
		int	iX,
		int	iY,
		BlockIndicatorF2D< T > &	bulkIndicator,
		IndicatorF2D< T > &	geometryIndicator )

Definition at line 99 of file setBouzidiZeroVelocityBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setBouzidiZeroVelocityBoundary");
  T _epsFraction = 0.0001;
  T distances[DESCRIPTOR::q];
  std::fill(std::begin(distances), std::end(distances), -1);
 
  for (int iPop = 1; iPop < DESCRIPTOR::q ; ++iPop) {
    const Vector<int,2> c = descriptors::c<DESCRIPTOR>(iPop);
    const int iXn = iX + c[0];
    const int iYn = iY + c[1];
    if (blockGeometryStructure.isInside(iXn,iYn)) {
      if (bulkIndicator(iXn,iYn)) {
        T dist = -1;
        T physR[2];
        blockGeometryStructure.getPhysR(physR,{iXn,iYn});
        T voxelSize=blockGeometryStructure.getDeltaR();
        Vector<T,2> physC(physR);
 
        Vector<T,2> direction(-voxelSize*descriptors::c<DESCRIPTOR >(iPop,0),-voxelSize*descriptors::c<DESCRIPTOR >(iPop,1));
        T cPhysNorm = voxelSize*util::sqrt(descriptors::c<DESCRIPTOR >(iPop,0)*descriptors::c<DESCRIPTOR >(iPop,0)+descriptors::c<DESCRIPTOR >(iPop,1)*descriptors::c<DESCRIPTOR >(iPop,1));
 
        if (!geometryIndicator.distance(dist,physC,direction,blockGeometryStructure.getIcGlob() ) ) {
          T epsX = voxelSize*descriptors::c<DESCRIPTOR >(iPop,0)*_epsFraction;
          T epsY = voxelSize*descriptors::c<DESCRIPTOR >(iPop,1)*_epsFraction;
 
          Vector<T,2> physC2(physC);
          physC2[0] += epsX;
          physC2[1] += epsY;
          Vector<T,2> direction2(direction);
          direction2[0] -= 2.*epsX;
          direction2[1] -= 2.*epsY;
 
          if ( !geometryIndicator.distance(dist,physC2,direction2,blockGeometryStructure.getIcGlob())) {
            clout << "ERROR: no boundary found at (" << iXn << "," << iYn <<") ~ ("
                  << physR[0] << "," << physR[1] << "), "
                  << "in direction " << descriptors::opposite<DESCRIPTOR >(iPop)
                  << std::endl;
          }
          T distNew = (dist - util::sqrt(epsX*epsX+epsY*epsY))/cPhysNorm;
          if (distNew < 0.5) {
            dist = 0;
          }
          else {
            dist = 0.5 * cPhysNorm;
            clout << "WARNING: distance at (" << iXn << "," << iYn <<") ~ ("
                  << physR[0] << "," << physR[1] <<"), "
                  << "in direction " << descriptors::opposite<DESCRIPTOR >(iPop) << ": "
                  << distNew
                  << " rounded to "
                  << dist/cPhysNorm
                  << std::endl;
          }
        }
        distances[descriptors::opposite<DESCRIPTOR >(iPop)] = dist/cPhysNorm;
      }
      else {
        if (blockGeometryStructure.getMaterial({iXn,iYn}) != 0) {
          auto postProcessor = std::unique_ptr<ZeroVelocityBounceBackPostProcessorGenerator2D<T,DESCRIPTOR>>{new ZeroVelocityBounceBackPostProcessorGenerator2D<T,DESCRIPTOR>(iXn, iYn, descriptors::opposite<DESCRIPTOR>(iPop), 0)};
          block.addPostProcessor(*postProcessor);
        }
      }
    } // bulk indicator
  } // iPop loop
  setBouzidiZeroVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(block, blockGeometryStructure, iX, iY, distances);
}

References olb::descriptors::c(), olb::IndicatorF2D< T >::distance(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getIcGlob(), olb::BlockGeometry< T, D >::getMaterial(), olb::BlockGeometry< T, D >::getPhysR(), olb::BlockStructureD< D >::isInside(), olb::descriptors::opposite(), setBouzidiZeroVelocityBoundary(), and olb::util::sqrt().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary() [2/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::legacy::setBouzidiZeroVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 2 > &	blockGeometryStructure,
		int	x,
		int	y,
		int	iPop,
		T	dist )

Definition at line 180 of file setBouzidiZeroVelocityBoundary2D.hh.

{
  auto postProcessor = std::unique_ptr<PostProcessorGenerator2D<T, DESCRIPTOR>>{ nullptr };
  const Vector<int,2> c = descriptors::c<DESCRIPTOR>(iPop);
 
  if (blockGeometryStructure.getMaterial({x-c[0], y-c[1]}) != 1) {
    postProcessor.reset(new ZeroVelocityBounceBackPostProcessorGenerator2D<T,DESCRIPTOR>(x, y, iPop, dist));
  }
  else {
    postProcessor.reset(new ZeroVelocityBouzidiLinearPostProcessorGenerator2D<T,DESCRIPTOR>(x, y, iPop, dist));
  }
 
  if (postProcessor && !block.isPadding({x,y})) {
    block.addPostProcessor(*postProcessor);
  }
}

References olb::descriptors::c(), and olb::BlockGeometry< T, D >::getMaterial().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary() [3/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::legacy::setBouzidiZeroVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 2 > &	blockGeometryStructure,
		int	x,
		int	y,
		T	distances[DESCRIPTOR::q] )

Definition at line 168 of file setBouzidiZeroVelocityBoundary2D.hh.

{
  for (int iPop = 1; iPop < DESCRIPTOR::q ; ++iPop) {
    if ( !util::nearZero(distances[iPop]+1) ) {
      const Vector<int,2> c = descriptors::c<DESCRIPTOR>(iPop);
      setBouzidiZeroVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(block, blockGeometryStructure, x-c[0], y-c[1], iPop, distances[iPop]);
    }
  }
}

References olb::descriptors::c(), olb::util::nearZero(), and setBouzidiZeroVelocityBoundary().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary() [4/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiZeroVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 3 > &	blockGeometryStructure,
		int	x,
		int	y,
		int	z,
		int	iPop,
		T	dist )

Definition at line 198 of file setBouzidiZeroVelocityBoundary3D.hh.

{
  auto postProcessor = std::unique_ptr<PostProcessorGenerator3D<T, DESCRIPTOR>>{ nullptr };
  const Vector<int,3> c = descriptors::c<DESCRIPTOR>(iPop);
 
  if (blockGeometryStructure.getMaterial(x-c[0], y-c[1], z-c[2]) != 1) {
    postProcessor.reset(new ZeroVelocityBounceBackPostProcessorGenerator3D<T,DESCRIPTOR>(x, y, z, iPop, dist));
  }
  else {
    postProcessor.reset(new ZeroVelocityBouzidiLinearPostProcessorGenerator3D<T,DESCRIPTOR>(x, y, z, iPop, dist));
  }
 
  if (postProcessor && !block.isPadding({x,y,z})) {
    block.addPostProcessor(*postProcessor);
  }
}

References olb::descriptors::c(), and olb::BlockGeometry< T, D >::getMaterial().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary() [5/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiZeroVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 3 > &	blockGeometryStructure,
		int	x,
		int	y,
		int	z,
		T	distances[DESCRIPTOR::q] )

Definition at line 187 of file setBouzidiZeroVelocityBoundary3D.hh.

{
  for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
    if ( !util::nearZero(distances[iPop]+1) ) {
      const Vector<int,3> c = descriptors::c<DESCRIPTOR>(iPop);
      setBouzidiZeroVelocityBoundary<T,DESCRIPTOR>(block, blockGeometryStructure, x-c[0], y-c[1], z-c[2], iPop, distances[iPop]);
    }
  }
}

References olb::descriptors::c(), olb::util::nearZero(), and setBouzidiZeroVelocityBoundary().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary() [6/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::legacy::setBouzidiZeroVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF2D< T > &	boundaryIndicator,
		BlockIndicatorF2D< T > &	bulkIndicator,
		IndicatorF2D< T > &	geometryIndicator )

Definition at line 84 of file setBouzidiZeroVelocityBoundary2D.hh.

{
  block.forSpatialLocations([&](auto iX, auto iY) {
    if (boundaryIndicator(iX,iY)) {
      setBouzidiZeroVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(block,
                                                                 bulkIndicator.getBlockGeometry(),
                                                                 iX, iY,
                                                                 bulkIndicator,
                                                                 geometryIndicator);
    }
  });
}

References olb::BlockIndicatorF2D< T >::getBlockGeometry(), and setBouzidiZeroVelocityBoundary().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary() [7/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiZeroVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF3D< T > &	boundaryIndicator,
		BlockIndicatorF3D< T > &	bulkIndicator,
		IndicatorF3D< T > &	geometryIndicator,
		T	_epsFraction )

Definition at line 94 of file setBouzidiZeroVelocityBoundary3D.hh.

{
  block.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (boundaryIndicator(iX,iY,iZ)) {
      setBouzidiZeroVelocityBoundary1<T,DESCRIPTOR>(block,
                                                    boundaryIndicator.getBlockGeometry(),
                                                    iX, iY, iZ,
                                                    geometryIndicator,
                                                    bulkIndicator,
                                                    _epsFraction);
    }
  });
}

References olb::BlockIndicatorF3D< T >::getBlockGeometry(), and setBouzidiZeroVelocityBoundary1().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary() [8/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::legacy::setBouzidiZeroVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF2D< T > > &&	boundaryIndicator,
		FunctorPtr< SuperIndicatorF2D< T > > &&	bulkIndicator,
		IndicatorF2D< T > &	geometryIndicator )

Initialising the BouzidiZeroVelocityBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 53 of file setBouzidiZeroVelocityBoundary2D.hh.

{
  //out of superOffBoundary2D
  T _epsFraction = 0.0001;
  OstreamManager clout(std::cout, "setBouzidiZeroVelocityBoundary");
  int _overlap = 1;
 
  clout << "epsFraction=" << _epsFraction << std::endl;
  clout.setMultiOutput(true);
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    clout << "Cuboid globiC " << sLattice.getLoadBalancer().glob(iCloc)
          << " starts to read distances for ZeroVelocity Boundary..." << std::endl;
    setBouzidiZeroVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc),
        boundaryIndicator->getBlockIndicatorF(iCloc),
        bulkIndicator->getBlockIndicatorF(iCloc),
        geometryIndicator);
    clout << "Cuboid globiC " << sLattice.getLoadBalancer().glob(iCloc)
          << " finished reading distances for ZeroVelocity Boundary." << std::endl;
  }
  clout.setMultiOutput(false);
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator), _overlap);
}

References olb::addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), setBouzidiZeroVelocityBoundary(), and olb::OstreamManager::setMultiOutput().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary() [9/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiZeroVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	boundaryIndicator,
		FunctorPtr< SuperIndicatorF3D< T > > &&	bulkIndicator,
		IndicatorF3D< T > &	geometryIndicator )

Adds needed Cells to the Communicator _commBC in SuperLattice

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 58 of file setBouzidiZeroVelocityBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setBouzidiZeroVelocityBoundary");
  T _epsFraction = 0.0001;
  int overlap = 1;
  bool _output = false;
  if (_output) {
    clout << "epsFraction=" << _epsFraction << std::endl;
    clout.setMultiOutput(true);
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    if (_output) {
      clout << "Cuboid globiC " << sLattice.getLoadBalancer().glob(iCloc)
            << " starts to read distances for ZeroVelocity Boundary..." << std::endl;
    }
    setBouzidiZeroVelocityBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
        boundaryIndicator->getBlockIndicatorF(iCloc),
        bulkIndicator->getBlockIndicatorF(iCloc),
        geometryIndicator, _epsFraction);
    if (_output) {
      clout << "Cuboid globiC " << sLattice.getLoadBalancer().glob(iCloc)
            << " finished reading distances for ZeroVelocity Boundary." << std::endl;
    }
  }
  if (_output) {
    clout.setMultiOutput(false);
  }
  addPoints2CommBC(sLattice,std::forward<decltype(boundaryIndicator)>(boundaryIndicator), overlap);
}

References olb::addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), setBouzidiZeroVelocityBoundary(), and olb::OstreamManager::setMultiOutput().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary() [10/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiZeroVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	boundaryIndicator,
		IndicatorF3D< T > &	geometryIndicator,
		std::vector< int >	bulkMaterials )

Definition at line 48 of file setBouzidiZeroVelocityBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setBouzidiZeroVelocityBoundary");
  SuperGeometry<T,3>& superGeometry = boundaryIndicator->getSuperGeometry();
  setBouzidiZeroVelocityBoundary<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator), superGeometry.getMaterialIndicator(std::move(bulkMaterials)),
      geometryIndicator);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiZeroVelocityBoundary().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary() [11/12]

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::legacy::setBouzidiZeroVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material,
		IndicatorF2D< T > &	geometryIndicator,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Set offDynamics with boundary links and post processors using indicators.

Initialising the BouzidiZeroVelocityBoundary on the superLattice domain.

Add offDynamics with initialisation of boundary links and the corresponding post processors Note: Uses information of the second neighbours of the cell (x,y) Add post processors. Ensure that offDynamics are defined!

Parameters

boundaryIndicator	Indicator describing boundary cells
bulkIndicator	Indicator describing bulk cells
geometryIndicator	Indicator describing the geometry to be bounded Initialising the BouzidiZeroVelocityBoundary on the superLattice domain

Definition at line 40 of file setBouzidiZeroVelocityBoundary2D.hh.

{
  setBouzidiZeroVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, superGeometry.getMaterialIndicator(material),
      superGeometry.getMaterialIndicator(std::move(bulkMaterials)),
      geometryIndicator);
 
 
}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiZeroVelocityBoundary().

Here is the call graph for this function:

Here is the caller graph for this function:

setBouzidiZeroVelocityBoundary() [12/12]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiZeroVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		IndicatorF3D< T > &	geometryIndicator,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Set offDynamics with boundary links and post processors using indicators.

Initialising the setLocalVelocityBoundary function on the superLattice domain.

Add offDynamics with initialisation of boundary links and the corresponding post processors Note: Uses information of the second neighbours of the cell (x,y,z) Add post processors. Ensure that offDynamics are defined!

Parameters

boundaryIndicator	Indicator describing boundary cells
bulkIndicator	Indicator describing bulk cells
geometryIndicator	Indicator describing the geometry to be bounded Initialising the setLocalVelocityBoundary function on the superLattice domain

Definition at line 40 of file setBouzidiZeroVelocityBoundary3D.hh.

{
  setBouzidiZeroVelocityBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material),
      geometryIndicator,
      bulkMaterials);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiZeroVelocityBoundary().

Here is the call graph for this function:

setBouzidiZeroVelocityBoundary1()

template<typename T , typename DESCRIPTOR >

void olb::legacy::setBouzidiZeroVelocityBoundary1	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, 3 > &	blockGeometryStructure,
		int	iX,
		int	iY,
		int	iZ,
		IndicatorF3D< T > &	geometryIndicator,
		BlockIndicatorF3D< T > &	bulkIndicator,
		T	_epsFraction )

Definition at line 112 of file setBouzidiZeroVelocityBoundary3D.hh.

{
  OstreamManager clout(std::cout, "BouzidiBoundary");
  T distances[DESCRIPTOR::q];
  std::fill(std::begin(distances), std::end(distances), -1);
 
  for (int iPop = 1; iPop < DESCRIPTOR::q ; ++iPop) {
    const Vector<int,3> c = descriptors::c<DESCRIPTOR>(iPop);
    const int iXn = iX + c[0];
    const int iYn = iY + c[1];
    const int iZn = iZ + c[2];
    if (blockGeometryStructure.isInside(iXn,iYn,iZn)) {
      if (bulkIndicator(iXn,iYn,iZn)) {
        T dist = -1;
        Vector<T,3> physR{};
        blockGeometryStructure.getPhysR(physR,{iXn,iYn,iZn});
        T voxelSize=blockGeometryStructure.getDeltaR();
 
        Vector<T,3> physC(physR);
 
        Vector<T,3> direction(-voxelSize*c[0],-voxelSize*c[1],-voxelSize*c[2]);
        T cPhysNorm = voxelSize*util::sqrt(c[0]*c[0]+c[1]*c[1]+c[2]*c[2]);
 
        if (!geometryIndicator.distance(dist,physC,direction,blockGeometryStructure.getIcGlob() ) ) {
          T epsX = voxelSize*c[0]*_epsFraction;
          T epsY = voxelSize*c[1]*_epsFraction;
          T epsZ = voxelSize*c[2]*_epsFraction;
 
          Vector<T,3> physC2(physC);
          physC2[0] += epsX;
          physC2[1] += epsY;
          physC2[2] += epsZ;
          Vector<T,3> direction2(direction);
          direction2[0] -= 2.*epsX;
          direction2[1] -= 2.*epsY;
          direction2[2] -= 2.*epsZ;
 
          if ( !geometryIndicator.distance(dist,physC2,direction2,blockGeometryStructure.getIcGlob())) {
            clout << "ERROR: no boundary found at (" << iXn << "," << iYn << "," << iZn <<") ~ ("
                  << physR[0] << "," << physR[1] << "," << physR[2] <<"), "
                  << "in direction " << descriptors::opposite<DESCRIPTOR >(iPop)
                  << std::endl;
            break;
          }
          T distNew = (dist - util::sqrt(epsX*epsX+epsY*epsY+epsZ*epsZ))/cPhysNorm;
          if (distNew < 0.5) {
            dist = 0;
          }
          else {
            dist = 0.5 * cPhysNorm;
            clout << "WARNING: distance at (" << iXn << "," << iYn << "," << iZn <<") ~ ("
                  << physR[0] << "," << physR[1] << "," << physR[2] <<"), "
                  << "in direction " << descriptors::opposite<DESCRIPTOR >(iPop) << ": "
                  << distNew
                  << " rounded to "
                  << dist/cPhysNorm
                  << std::endl;
          }
        }
        distances[descriptors::opposite<DESCRIPTOR>(iPop)] = dist/cPhysNorm;
      }
      else {
        if (blockGeometryStructure.getMaterial(iXn,iYn,iZn) != 0) {
          auto postProcessor = std::unique_ptr<PostProcessorGenerator3D<T, DESCRIPTOR>>{
      new ZeroVelocityBounceBackPostProcessorGenerator3D<T,DESCRIPTOR>(iXn, iYn, iZn, descriptors::opposite<DESCRIPTOR>(iPop), 0) };
          block.addPostProcessor(*postProcessor);
        }
      }
    }
  }
  setBouzidiZeroVelocityBoundary<T,DESCRIPTOR>(block,blockGeometryStructure, iX, iY, iZ, distances);
}

References olb::descriptors::c(), olb::IndicatorF3D< T >::distance(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getIcGlob(), olb::BlockGeometry< T, D >::getMaterial(), olb::BlockGeometry< T, D >::getPhysR(), olb::BlockStructureD< D >::isInside(), olb::descriptors::opposite(), setBouzidiZeroVelocityBoundary(), and olb::util::sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

setOffDynamics()

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::legacy::setOffDynamics	(	BlockLattice< T, DESCRIPTOR > &	block,
		int	x,
		int	y,
		T	location[DESCRIPTOR::d],
		T	distances[DESCRIPTOR::q] )

Definition at line 210 of file setBouzidiVelocityBoundary2D.hh.

{
  //Dynamics<T,DESCRIPTOR>* dynamics = BoundaryManager::getOffDynamics(location, distances);
  Dynamics<T,DESCRIPTOR>* dynamics = new legacy::OffDynamics<T, DESCRIPTOR>(location, distances);
  block.defineDynamics({x,y}, dynamics);
}

Here is the caller graph for this function:

setWallFunctionBoundary() [1/3]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setWallFunctionBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		wallFunctionParam< T > const &	wallFunctionParam,
		IndicatorF3D< T > *	geoIndicator )

Set WallFunction boundary for any indicated cells inside the block domain.

Definition at line 70 of file setWallFunctionBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setWallFunctionBoundary");
  bool _output = false;
  const auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = 1;
  std::vector<int> discreteNormal(4, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      std::vector<int> missingIndices;
      for (int x = -1 ; x < 2; ++x) {
        for (int y = -1 ; y < 2; ++y) {
          for (int z = -1 ; z < 2; ++z) {
            if (blockGeometryStructure.getMaterial(iX + x, iY + y, iZ + z) == 0) {
              for (int iPop = 0; iPop < DESCRIPTOR::q; ++iPop) {
                if (descriptors::c<DESCRIPTOR>(iPop,0) == x &&
                    descriptors::c<DESCRIPTOR>(iPop,1) == y &&
                    descriptors::c<DESCRIPTOR>(iPop,2) == z) {
                  missingIndices.push_back(descriptors::opposite<DESCRIPTOR>(iPop));
                }
              }
            }
          }
        }
      }
      if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {
        discreteNormal.erase(discreteNormal.begin());
        //OLB_PRECONDITION(x0==x1 || y0==y1 || z0==z1);
        if (_output) {
          clout << "setWallFunctionBoundary<" << discreteNormal[0] << ","<< discreteNormal[1] << ","<< discreteNormal[2] << ">("  << iX << ", "<< iX << ", " << iY << ", " << iY << ", " << iZ << ", " << iZ << " )" << std::endl;
        }
        auto postProcessor = std::unique_ptr<PostProcessorGenerator3D<T, DESCRIPTOR>>{ new WallFunctionBoundaryProcessorGenerator3D<T, DESCRIPTOR>(iX, iX, iY, iY, iZ, iZ, indicator.getBlockGeometry(), discreteNormal, missingIndices,
            converter, wallFunctionParam, geoIndicator) };
        if (postProcessor) {
          _block.addPostProcessor(*postProcessor);
        }
      }
      else {
        clout << "Warning: Could not setWallFunctionBoundary (" << iX << ", " << iY << ", " << iZ << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] <<","<< discreteNormal[3] <<"), set to bounceBack" << std::endl;
        _block.template defineDynamics<BounceBack>({iX, iY, iZ});
      }
    }
  });
}

References olb::descriptors::c(), olb::BlockIndicatorF3D< T >::getBlockGeometry(), and olb::descriptors::opposite().

Here is the call graph for this function:

setWallFunctionBoundary() [2/3]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setWallFunctionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		wallFunctionParam< T > const &	wallFunctionParam,
		IndicatorF3D< T > *	geoIndicator )

Initialising the WallFunctionBoundary on the superLattice domain.

Definition at line 48 of file setWallFunctionBoundary3D.hh.

{
  int _overlap = 1;
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setWallFunctionBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
        indicator->getBlockIndicatorF(iCloc),
        converter, wallFunctionParam, geoIndicator);
  }
  auto& communicator = sLattice.getCommunicator(stage::PostStream());
  communicator.template requestField<descriptors::POPULATION>();
 
  SuperIndicatorBoundaryNeighbor<T,DESCRIPTOR::d> neighborIndicator(std::forward<decltype(indicator)>(indicator), _overlap);
  communicator.requestOverlap(_overlap, neighborIndicator);
  communicator.exchangeRequests();
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperLattice< T, DESCRIPTOR >::getCommunicator(), olb::SuperStructure< T, D >::getLoadBalancer(), and setWallFunctionBoundary().

Here is the call graph for this function:

setWallFunctionBoundary() [3/3]

template<typename T , typename DESCRIPTOR >

void olb::legacy::setWallFunctionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		wallFunctionParam< T > const &	wallFunctionParam,
		IndicatorF3D< T > *	geoIndicator = NULL )

Initialising the WallFunctionBoundary on the superLattice domain.

Definition at line 37 of file setWallFunctionBoundary3D.hh.

{
  setWallFunctionBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material),
                                        converter, wallFunctionParam, geoIndicator);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setWallFunctionBoundary().

Here is the call graph for this function:

Here is the caller graph for this function: