olb::particles::boundaries Namespace Reference

Functions
template<typename T , unsigned D>
Vector< T, D >	getNormalOnClosestSurface (SolidBoundary< T, D > &solidBoundary, Vector< T, D > &position, T referenceLength)
template<typename T , typename PARTICLETYPE >
Vector< T, PARTICLETYPE::d >	getNormalOnClosestSurface (SolidBoundary< T, PARTICLETYPE::d > &solidBoundary, Particle< T, PARTICLETYPE > &particle)
template<bool useCubicBounds = false, typename T , typename PARTICLETYPE , typename F >
void	doAtParticleWallContact (Particle< T, PARTICLETYPE > &particle, SolidBoundary< T, PARTICLETYPE::d > &solidBoundary, F f)
	Generic treatment of particle wall contact.
template<typename T , unsigned D>
Vector< T, utilities::dimensions::convert< D >::rotation >	getRelativeSurfaceOrientation (SolidBoundary< T, D > &solidBoundary, Vector< T, D > &position, Vector< T, D > &normalToBeComparedTo, T referenceLength)
template<typename T , unsigned D>
bool	materialVicinity (SuperIndicatorMaterial< T, D > &materialIndicator, LatticeR< D+1 > &latticeR)
template<typename T , typename PARTICLETYPE >
bool	checkMaterialVicinity (SuperIndicatorMaterial< T, PARTICLETYPE::d > &materialIndicator, Particle< T, PARTICLETYPE > &particle)
template<bool useCubicBounds = false, typename T , typename PARTICLETYPE >
void	velocityWallReflection (Particle< T, PARTICLETYPE > &particle, SolidBoundary< T, PARTICLETYPE::d > &solidBoundary, T coefficientOfRestitution=1.0)
	Velocity wall reflection.
template<typename T , typename PARTICLETYPE >
void	cuboidVelocityWallReflection (Particle< T, PARTICLETYPE > &particle, Vector< T, PARTICLETYPE::d > origin, Vector< T, PARTICLETYPE::d > end)
	Alias for cubic version of velocity wall reflection.
template<bool useCubicBounds = false, typename T , typename PARTICLETYPE >
void	wallSlip (Particle< T, PARTICLETYPE > &particle, SolidBoundary< T, PARTICLETYPE::d > &solidBoundary)
	Wall slip.
template<bool useCubicBounds = false, typename T , typename PARTICLETYPE >
void	wallCapture (Particle< T, PARTICLETYPE > &particle, SolidBoundary< T, PARTICLETYPE::d > &solidBoundary)
	Wall capture.
template<typename T , typename PARTICLETYPE >
void	materialCapture (Particle< T, PARTICLETYPE > &particle, SuperIndicatorMaterial< T, PARTICLETYPE::d > &materialIndicator)
	Wall capture based on material rather than SolidBoundary.
template<typename T , typename PARTICLETYPE >
void	wallCaptureMaterialAware (Particle< T, PARTICLETYPE > &particle, SolidBoundary< T, PARTICLETYPE::d > &solidBoundary, SuperIndicatorMaterial< T, PARTICLETYPE::d > &materialIndicator)
	Wall capture with material awareness.
template<bool useCubicBounds = false, typename T , typename PARTICLETYPE >
void	escape (Particle< T, PARTICLETYPE > &particle, SolidBoundary< T, PARTICLETYPE::d > &solidBoundary)
	Escape.
template<typename T , typename PARTICLETYPE >
void	materialEscape (Particle< T, PARTICLETYPE > &particle, SuperIndicatorMaterial< T, PARTICLETYPE::d > &materialIndicator)
	Escape boundary based on material rather than SolidBoundary.
template<typename T , typename PARTICLETYPE >
void	escapeMaterialAware (Particle< T, PARTICLETYPE > &particle, SolidBoundary< T, PARTICLETYPE::d > &solidBoundary, SuperIndicatorMaterial< T, PARTICLETYPE::d > &materialIndicator)
	Escape boundary with material awareness.
template<typename T , typename PARTICLETYPE >
void	materialCaptureAndEscape (Particle< T, PARTICLETYPE > &particle, SuperIndicatorMaterial< T, PARTICLETYPE::d > &captureMaterialIndicator, SuperIndicatorMaterial< T, PARTICLETYPE::d > &escapeMaterialIndicator)
	Escape and capture based on material rather than SolidBoundary.
template<typename T , typename PARTICLETYPE >
void	wallCaptureAndEscapeMaterialAware (Particle< T, PARTICLETYPE > &particle, SolidBoundary< T, PARTICLETYPE::d > &solidBoundary, SuperIndicatorMaterial< T, PARTICLETYPE::d > &captureMaterialIndicator, SuperIndicatorMaterial< T, PARTICLETYPE::d > &escapeMaterialIndicator)
	Escape boundary with material awareness.

Function Documentation

checkMaterialVicinity()

template<typename T , typename PARTICLETYPE >

bool olb::particles::boundaries::checkMaterialVicinity	(	SuperIndicatorMaterial< T, PARTICLETYPE::d > &	materialIndicator,
		Particle< T, PARTICLETYPE > &	particle )

Definition at line 60 of file materialHandling.h.

{
  constexpr unsigned D = PARTICLETYPE::d;
  //Retrieve particle position
  auto position = access::getPosition( particle );
  //Retrieve super geometry
  auto& sGeometry = materialIndicator.getSuperGeometry();
  //Get lattice position
  LatticeR<D+1> latticeR;
  bool foundPos = sGeometry.getCuboidGeometry().getFloorLatticeR(position, latticeR);
  if (!foundPos) {std::cerr << "LatticeR (" << latticeR << ") not found!" << std::endl; }
  //Check whether responsible iC
  bool isLocal = sGeometry.getLoadBalancer().isLocal(latticeR[0]);
  if(isLocal){
    //Check if in vicinity of specified material numbers
    bool vicinity = materialVicinity<T,D>( materialIndicator, latticeR );
    return vicinity;
  }
  return false;
}

References olb::particles::access::getPosition().

Here is the call graph for this function:

Here is the caller graph for this function:

cuboidVelocityWallReflection()

template<typename T , typename PARTICLETYPE >

void olb::particles::boundaries::cuboidVelocityWallReflection	(	Particle< T, PARTICLETYPE > &	particle,
		Vector< T, PARTICLETYPE::d >	origin,
		Vector< T, PARTICLETYPE::d >	end )

Alias for cubic version of velocity wall reflection.

• mainly used as legacy support

Definition at line 70 of file particleBoundaries.h.

{
  //Create solid wall
  Vector<T,PARTICLETYPE::d> extent = end-origin;
  IndicatorCuboid3D<T> cuboid(extent, origin);
  std::unique_ptr<IndicatorF<T,PARTICLETYPE::d>> boundaryIndicator =
      std::make_unique<IndicInverse<T,PARTICLETYPE::d>>(cuboid);
  SolidBoundary<T,PARTICLETYPE::d> solidBoundary(std::move(boundaryIndicator), 2, 0);
  //Execute velocity wall reflection
  velocityWallReflection<true>( particle, solidBoundary );
}

doAtParticleWallContact()

template<bool useCubicBounds = false, typename T , typename PARTICLETYPE , typename F >

void olb::particles::boundaries::doAtParticleWallContact	(	Particle< T, PARTICLETYPE > &	particle,
		SolidBoundary< T, PARTICLETYPE::d > &	solidBoundary,
		F	f )

Generic treatment of particle wall contact.

• evaluation of penetration by
  • Version A: signed distance function
  • Version B: simple min/max cubic bounds evaluation
• can be used for:
  • f( particle, normal, penetrationDepth )
  • f( particle, normal )
  • f( particle )

Definition at line 65 of file boundaryHandling.h.

{
  using namespace descriptors;
  //Retrieve quantities
  auto position = access::getPosition( particle );
  T radius = access::getRadius( particle );
  //VERSION A: Use signed distance functions of indicator
  if constexpr (!useCubicBounds){
    T distToWall = solidBoundary.getIndicator()->signedDistance(position)-radius;
    if (distToWall<=0){
 
      if constexpr (std::is_invocable_v<F,Particle<T,PARTICLETYPE>&,Vector<T,PARTICLETYPE::d>&,T>){
        auto normal = getNormalOnClosestSurface( solidBoundary, position, radius );
        T penetrationDepth = -distToWall;
        f( particle, normal, penetrationDepth );
      } else if constexpr (std::is_invocable_v<F,Particle<T,PARTICLETYPE>&,Vector<T,PARTICLETYPE::d>&>){
        auto normal = getNormalOnClosestSurface( solidBoundary, position, radius );
        f( particle, normal );
      } else {
        f( particle );
      }
 
    }
  }
  //VERSION B: Use origin and end of cubic indicator bounds (min, max)
  else {
    auto origin = solidBoundary.getIndicator()->getMin();
    auto end = solidBoundary.getIndicator()->getMax();
    for (int iDim=0; iDim<PARTICLETYPE::d; ++iDim){
      T posParticleStart = position[iDim] - radius;
      T posParticleEnd = position[iDim] + radius;
      //Retrieve distance for lower and upper limit
      T distToWallOrig = posParticleStart - origin[iDim];
      T distToWallEnd = end[iDim] - posParticleEnd;
      //Set up normal
      Vector<T,PARTICLETYPE::d> normal(0.);
      //Evaluate distances
      if (distToWallOrig<=0){
        normal[iDim] = 1;
        if constexpr (std::is_invocable_v<F,Particle<T,PARTICLETYPE>&,Vector<T,PARTICLETYPE::d>&,T>){
          T penetrationDepth = -distToWallOrig;
          f( particle, normal, penetrationDepth );
        } else if constexpr (std::is_invocable_v<F,Particle<T,PARTICLETYPE>&,Vector<T,PARTICLETYPE::d>&>){
          f( particle, normal );
        } else {
          f( particle );
        }
      } else if (distToWallEnd<=0){
        normal[iDim] = -1;
        if constexpr (std::is_invocable_v<F,Particle<T,PARTICLETYPE>&,Vector<T,PARTICLETYPE::d>&,T>){
          T penetrationDepth = -distToWallEnd;
          f( particle, normal, penetrationDepth );
        } else if constexpr (std::is_invocable_v<F,Particle<T,PARTICLETYPE>&,Vector<T,PARTICLETYPE::d>&>){
          f( particle, normal );
        } else {
          f( particle );
        }
      }
    }
  } //constexpr if (!useCubicBounds)
}

References olb::SolidBoundary< T, D >::getIndicator(), getNormalOnClosestSurface(), olb::particles::access::getPosition(), and olb::particles::access::getRadius().

Here is the call graph for this function:

escape()

template<bool useCubicBounds = false, typename T , typename PARTICLETYPE >

void olb::particles::boundaries::escape	(	Particle< T, PARTICLETYPE > &	particle,
		SolidBoundary< T, PARTICLETYPE::d > &	solidBoundary )

Escape.

• setting particle field ACTIVE=false

Definition at line 178 of file particleBoundaries.h.

{
  using namespace descriptors;
  //Execute wall treatment
  doAtParticleWallContact<useCubicBounds>( particle, solidBoundary,
    [&]( Particle<T,PARTICLETYPE>& particle,
    Vector<T,PARTICLETYPE::d>& normal ){
    //Deactivate particle
    access::setInactive( particle );
  });
}

References olb::particles::access::setInactive().

Here is the call graph for this function:

escapeMaterialAware()

template<typename T , typename PARTICLETYPE >

void olb::particles::boundaries::escapeMaterialAware	(	Particle< T, PARTICLETYPE > &	particle,
		SolidBoundary< T, PARTICLETYPE::d > &	solidBoundary,
		SuperIndicatorMaterial< T, PARTICLETYPE::d > &	materialIndicator )

Escape boundary with material awareness.

• implies necessity of SuperGeometry, so no DEM only possible
• setting particle field ACTIVE=false at wall impact
• represents combination of wallCapture and materialCapture
• intended to use aprior material check to speed up complex SolidBoudaries carying STLs

Definition at line 216 of file particleBoundaries.h.

{
  using namespace descriptors;
  //Check whether still active
  bool isActive = access::isActive( particle );
  if (isActive){
    bool vicinity = checkMaterialVicinity( materialIndicator, particle );
    if (vicinity){
      constexpr bool useCubicBounds=false;
      boundaries::escape<useCubicBounds>(particle, solidBoundary);
    }
  }
}

References checkMaterialVicinity(), and olb::particles::access::isActive().

Here is the call graph for this function:

Here is the caller graph for this function:

getNormalOnClosestSurface() [1/2]

template<typename T , unsigned D>

Vector< T, D > olb::particles::boundaries::getNormalOnClosestSurface	(	SolidBoundary< T, D > &	solidBoundary,
		Vector< T, D > &	position,
		T	referenceLength )

Definition at line 40 of file boundaryHandling.h.

{
  T delXofCentralDifference = 1.e-8*referenceLength;
  return solidBoundary.getIndicator()->surfaceNormal(position, delXofCentralDifference);
}

References olb::SolidBoundary< T, D >::getIndicator().

Here is the call graph for this function:

Here is the caller graph for this function:

getNormalOnClosestSurface() [2/2]

template<typename T , typename PARTICLETYPE >

Vector< T, PARTICLETYPE::d > olb::particles::boundaries::getNormalOnClosestSurface	(	SolidBoundary< T, PARTICLETYPE::d > &	solidBoundary,
		Particle< T, PARTICLETYPE > &	particle )

Definition at line 48 of file boundaryHandling.h.

{
  auto position = access::getPosition( particle );
  auto radius = access::getRadius( particle );
  return getNormalOnClosestSurface( solidBoundary, position, radius );
}

References getNormalOnClosestSurface(), olb::particles::access::getPosition(), and olb::particles::access::getRadius().

Here is the call graph for this function:

getRelativeSurfaceOrientation()

template<typename T , unsigned D>

Vector< T, utilities::dimensions::convert< D >::rotation > olb::particles::boundaries::getRelativeSurfaceOrientation	(	SolidBoundary< T, D > &	solidBoundary,
		Vector< T, D > &	position,
		Vector< T, D > &	normalToBeComparedTo,
		T	referenceLength )

Definition at line 134 of file boundaryHandling.h.

{
  auto normalWall = getNormalOnClosestSurface( solidBoundary, position, referenceLength );
  auto orientation = util::angleBetweenVectors( normalWall, normalToBeComparedTo );
  return orientation;
}

References olb::util::angleBetweenVectors(), and getNormalOnClosestSurface().

Here is the call graph for this function:

Here is the caller graph for this function:

materialCapture()

template<typename T , typename PARTICLETYPE >

void olb::particles::boundaries::materialCapture	(	Particle< T, PARTICLETYPE > &	particle,
		SuperIndicatorMaterial< T, PARTICLETYPE::d > &	materialIndicator )

Wall capture based on material rather than SolidBoundary.

• implies necessity of SuperGeometry, so no DEM only possible
• setting particle field ACTIVE=false at material contact
• setting resting particle

Definition at line 134 of file particleBoundaries.h.

{
  using namespace descriptors;
  //Check whether still active
  bool isActive = access::isActive( particle );
  if (isActive){
    bool vicinity = checkMaterialVicinity( materialIndicator, particle );
    if (vicinity){
      //Deactivate particle
      access::setInactive( particle );
      access::setRestingParticle( particle );
    }
  }
}

References checkMaterialVicinity(), olb::particles::access::isActive(), olb::particles::access::setInactive(), and olb::particles::access::setRestingParticle().

Here is the call graph for this function:

Here is the caller graph for this function:

materialCaptureAndEscape()

template<typename T , typename PARTICLETYPE >

void olb::particles::boundaries::materialCaptureAndEscape	(	Particle< T, PARTICLETYPE > &	particle,
		SuperIndicatorMaterial< T, PARTICLETYPE::d > &	captureMaterialIndicator,
		SuperIndicatorMaterial< T, PARTICLETYPE::d > &	escapeMaterialIndicator )

Escape and capture based on material rather than SolidBoundary.

• implies necessity of SuperGeometry, so no DEM only possible
• setting particle field ACTIVE=false at material contact
• setting resting particle (only capture)

Definition at line 238 of file particleBoundaries.h.

{
  using namespace descriptors;
  //Check whether still active
  bool isActive = access::isActive( particle );
  if (isActive){
    bool vicinity = checkMaterialVicinity( captureMaterialIndicator, particle );
    if (vicinity){
      access::setInactive( particle );
      access::setRestingParticle( particle );
    }
    else {
      vicinity = checkMaterialVicinity( escapeMaterialIndicator, particle );
      if (vicinity){
        access::setInactive( particle );
      }
    }
  }
}

References checkMaterialVicinity(), olb::particles::access::isActive(), olb::particles::access::setInactive(), and olb::particles::access::setRestingParticle().

Here is the call graph for this function:

Here is the caller graph for this function:

materialEscape()

template<typename T , typename PARTICLETYPE >

void olb::particles::boundaries::materialEscape	(	Particle< T, PARTICLETYPE > &	particle,
		SuperIndicatorMaterial< T, PARTICLETYPE::d > &	materialIndicator )

Escape boundary based on material rather than SolidBoundary.

• implies necessity of SuperGeometry, so no DEM only possible
• setting particle field ACTIVE=false at material contact

Definition at line 195 of file particleBoundaries.h.

{
  using namespace descriptors;
  //Check whether still active
  bool isActive = access::isActive( particle );
  if (isActive){
    bool vicinity = checkMaterialVicinity( materialIndicator, particle );
    if (vicinity){
      //Deactivate particle
      access::setInactive( particle );
    }
  }
}

References checkMaterialVicinity(), olb::particles::access::isActive(), and olb::particles::access::setInactive().

Here is the call graph for this function:

Here is the caller graph for this function:

materialVicinity()

template<typename T , unsigned D>

bool olb::particles::boundaries::materialVicinity	(	SuperIndicatorMaterial< T, D > &	materialIndicator,
		LatticeR< D+1 > &	latticeR )

Definition at line 40 of file materialHandling.h.

{
  static_assert((D==2 || D==3), "Dimension unknown!");
  static_assert(D!=2, "2D VERSION NOT IMPLEMENTED YET");
  if constexpr(D==2){
    //TODO: implement 2D version
  } else if constexpr(D==3){
    return (materialIndicator(latticeR[0],latticeR[1]+1,latticeR[2],  latticeR[3] ) ||
            materialIndicator(latticeR[0],latticeR[1]+1,latticeR[2],  latticeR[3]+1 ) ||
            materialIndicator(latticeR[0],latticeR[1]+1,latticeR[2]+1,latticeR[3] ) ||
            materialIndicator(latticeR[0],latticeR[1]+1,latticeR[2]+1,latticeR[3]+1 ) ||
            materialIndicator(latticeR[0],latticeR[1],latticeR[2],    latticeR[3] ) ||
            materialIndicator(latticeR[0],latticeR[1],latticeR[2],    latticeR[3]+1 ) ||
            materialIndicator(latticeR[0],latticeR[1],latticeR[2]+1,  latticeR[3] ) ||
            materialIndicator(latticeR[0],latticeR[1],latticeR[2]+1,  latticeR[3]+1 ));
  }
}

velocityWallReflection()

template<bool useCubicBounds = false, typename T , typename PARTICLETYPE >

void olb::particles::boundaries::velocityWallReflection	(	Particle< T, PARTICLETYPE > &	particle,
		SolidBoundary< T, PARTICLETYPE::d > &	solidBoundary,
		T	coefficientOfRestitution = 1.0 )

Velocity wall reflection.

• applying resurfacing for current timeStep
• inverting normal velocity component at wall impact for consequtive timeStep

Definition at line 41 of file particleBoundaries.h.

{
  using namespace descriptors;
  //Execute wall treatment
  doAtParticleWallContact<useCubicBounds>( particle, solidBoundary,
    [&]( Particle<T,PARTICLETYPE>& particle,
    Vector<T,PARTICLETYPE::d>& normal, T penetrationDepth ){
    //Retrieve velocity
    auto velocity = access::getVelocity( particle );
    auto position = access::getPosition( particle );
    //Modify velocity and set after-reflection position
    for (int iDim=0; iDim<PARTICLETYPE::d; ++iDim){
      //1. Resurface
      position[iDim] += normal[iDim] * 2.*penetrationDepth;
      //2. Reflection
      velocity[iDim] += std::abs(normal[iDim]) * -2.*velocity[iDim];
      velocity[iDim] *= coefficientOfRestitution;
    }
    //Apply velocity
    access::setVelocity( particle, velocity );
    access::setPosition( particle, position );
  });
}

References olb::particles::access::getPosition(), olb::particles::access::getVelocity(), olb::particles::access::setPosition(), and olb::particles::access::setVelocity().

Here is the call graph for this function:

wallCapture()

template<bool useCubicBounds = false, typename T , typename PARTICLETYPE >

void olb::particles::boundaries::wallCapture	(	Particle< T, PARTICLETYPE > &	particle,
		SolidBoundary< T, PARTICLETYPE::d > &	solidBoundary )

Wall capture.

• setting particle field ACTIVE=false at wall impact
• setting resting particle

Definition at line 115 of file particleBoundaries.h.

{
  using namespace descriptors;
  //Execute wall treatment
  doAtParticleWallContact<useCubicBounds>( particle, solidBoundary,
    [&]( Particle<T,PARTICLETYPE>& particle,
    Vector<T,PARTICLETYPE::d>& normal ){
    //Deactivate particle
    access::setInactive( particle );
    access::setRestingParticle( particle );
  });
}

References olb::particles::access::setInactive(), and olb::particles::access::setRestingParticle().

Here is the call graph for this function:

wallCaptureAndEscapeMaterialAware()

template<typename T , typename PARTICLETYPE >

void olb::particles::boundaries::wallCaptureAndEscapeMaterialAware	(	Particle< T, PARTICLETYPE > &	particle,
		SolidBoundary< T, PARTICLETYPE::d > &	solidBoundary,
		SuperIndicatorMaterial< T, PARTICLETYPE::d > &	captureMaterialIndicator,
		SuperIndicatorMaterial< T, PARTICLETYPE::d > &	escapeMaterialIndicator )

Escape boundary with material awareness.

• implies necessity of SuperGeometry, so no DEM only possible
• setting particle field ACTIVE=false at wall impact
• represents combination of wallCapture and materialCapture
• intended to use aprior material check to speed up complex SolidBoudaries carying STLs

Definition at line 266 of file particleBoundaries.h.

{
  using namespace descriptors;
  //Check whether still active
  bool isActive = access::isActive( particle );
  if (isActive){
    bool vicinity = checkMaterialVicinity( captureMaterialIndicator, particle );
    if (vicinity){
      constexpr bool useCubicBounds=false;
      boundaries::wallCapture<useCubicBounds>(particle, solidBoundary);
    }
    else {
      vicinity = checkMaterialVicinity( escapeMaterialIndicator, particle );
      if (vicinity){
        constexpr bool useCubicBounds=false;
        boundaries::escape<useCubicBounds>(particle, solidBoundary);
      }
    }
  }
}

References checkMaterialVicinity(), and olb::particles::access::isActive().

Here is the call graph for this function:

Here is the caller graph for this function:

wallCaptureMaterialAware()

template<typename T , typename PARTICLETYPE >

void olb::particles::boundaries::wallCaptureMaterialAware	(	Particle< T, PARTICLETYPE > &	particle,
		SolidBoundary< T, PARTICLETYPE::d > &	solidBoundary,
		SuperIndicatorMaterial< T, PARTICLETYPE::d > &	materialIndicator )

Wall capture with material awareness.

• implies necessity of SuperGeometry, so no DEM only possible
• setting particle field ACTIVE=false at wall impact
• setting resting particle
• represents combination of wallCapture and materialCapture
• intended to use aprior material check to speed up complex SolidBoudaries carying STLs

Definition at line 157 of file particleBoundaries.h.

{
  using namespace descriptors;
  //Check whether still active
  bool isActive = access::isActive( particle );
  if (isActive){
    bool vicinity = checkMaterialVicinity( materialIndicator, particle );
    if (vicinity){
      //Apply wall capture
      constexpr bool useCubicBounds=false;
      wallCapture<useCubicBounds>(particle, solidBoundary);
    }
  }
}

References checkMaterialVicinity(), and olb::particles::access::isActive().

Here is the call graph for this function:

Here is the caller graph for this function:

wallSlip()

template<bool useCubicBounds = false, typename T , typename PARTICLETYPE >

void olb::particles::boundaries::wallSlip	(	Particle< T, PARTICLETYPE > &	particle,
		SolidBoundary< T, PARTICLETYPE::d > &	solidBoundary )

Wall slip.

• applying resurfacing for current timeStep
• setting normal velocity component to 0 at wall impact for consequtive timeStep

Definition at line 87 of file particleBoundaries.h.

{
  using namespace descriptors;
  //Execute wall treatment
  doAtParticleWallContact<useCubicBounds>( particle, solidBoundary,
    [&]( Particle<T,PARTICLETYPE>& particle,
    Vector<T,PARTICLETYPE::d>& normal, T penetrationDepth ){
    //Retrieve velocity
    auto velocity = access::getVelocity( particle );
    auto position = access::getPosition( particle );
    //Modify velocity and set after-reflection position
    for (int iDim=0; iDim<PARTICLETYPE::d; ++iDim){
      //1. Resurface
      position[iDim] += normal[iDim] * 2.*penetrationDepth;
      //2. Velocity swallow //TODO: include momentum transfer treatment
      velocity[iDim] = 0.;
    }
    //Apply velocity
    access::setVelocity( particle, velocity );
    access::setPosition( particle, position );
  });
}

References olb::particles::access::getPosition(), olb::particles::access::getVelocity(), olb::particles::access::setPosition(), and olb::particles::access::setVelocity().

Here is the call graph for this function: