olb::particles Namespace Reference

Namespaces
namespace	access
namespace	boundaries
namespace	communication
namespace	conditions
namespace	contact
namespace	creators
namespace	defaults
namespace	dynamics
namespace	interaction
namespace	io
namespace	resolved
namespace	sorting
namespace	statistics
namespace	subgrid

Classes
struct	apply_external_acceleration_parallel
	Apply external acceleration (e.g. for apply gravity) More...
struct	apply_external_acceleration_single_cuboid
	Apply external acceleration (e.g. for apply gravity) More...
struct	communicate_surface_force
	Communicate surface force of parallel particles. More...
struct	couple_lattice_to_parallel_particles
	Couple lattice to parallel particles. More...
struct	couple_lattice_to_particles_single_cuboid
	Couple lattice to particles. More...
struct	couple_parallel_particles_to_lattice
	Couple particles to lattice. More...
struct	couple_particles_to_lattice_single_cuboid
	Couple particles to lattice. More...
struct	discrete_points_on_hull
struct	ParallelParticleLocator
class	Particle
class	ParticleSystem
struct	process_dynamics_parallel
	Process particle dynamics. More...
struct	process_dynamics_single_cuboid
	Process particle dynamics. More...
class	SuperParticleSystem
struct	update_particle_core_distribution
	Update particle core distribution of parallel particles. More...

Typedefs
template<typename T , typename PARTICLETYPE >
using	XParticleSystem
template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >
using	couple_lattice_to_particles
	Aliases.
template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >
using	couple_particles_to_lattice
template<typename T , typename PARTICLETYPE >
using	process_dynamics
template<typename T , typename PARTICLETYPE >
using	apply_gravity
template<typename T , typename PARTICLETYPE >
using	communicate_parallel_surface_force = communicate_surface_force<T,PARTICLETYPE>

Functions
template<typename DESCRIPTOR , typename CELL , typename V = typename CELL::value_t>
void	resetParticleRelatedFields (CELL &cell) noexcept
template<typename DESCRIPTOR , typename CELL , typename V = typename CELL::value_t>
void	resetParticleContactRelatedFields (CELL &cell) noexcept
template<typename DESCRIPTOR , typename CELL , typename V = typename CELL::value_t>
void	resetAllParticleRelatedFields (CELL &cell) noexcept
template<typename T , typename PARTICLETYPE , typename F >
void	doForParticle (Particle< T, PARTICLETYPE > &particle, F f)
template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles, typename F >
void	doWhenMeetingCondition (Particle< T, PARTICLETYPE > &particle, F f)
template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles, typename F >
void	doWhenMeetingCondition (Particle< T, PARTICLETYPE > &particle, F f, int globiC)
template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles, typename F >
void	forParticlesInParticleSystem (ParticleSystem< T, PARTICLETYPE > &particleSystem, F f, int globiC)
template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles, typename F >
void	forParticlesInParticleSystem (ParticleSystem< T, PARTICLETYPE > &particleSystem, F f)
template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles, typename F >
void	forParticlesInXParticleSystem (XParticleSystem< T, PARTICLETYPE > &xParticleSystem, F f)
	Iterate over particles in x particle system.
template<unsigned D>
constexpr bool	isPeriodic (const Vector< bool, D > &periodic)
template<typename T >
std::array< Vector< T, 3 >, 26 >	discretePointsOnSphericalHull (Vector< T, 3 > position, T radius)
template<typename T >
std::array< Vector< T, 2 >, 8 >	discretePointsOnSphericalHull (Vector< T, 2 > position, T radius)
template<typename T , typename PARTICLETYPE >
void	purgeInvalidParticles (XParticleSystem< T, PARTICLETYPE > &xParticleSystem)
template<typename T , typename PARTICLETYPE , std::size_t selectedID, typename F >
void	doForParticleMatchingID (XParticleSystem< T, PARTICLETYPE > &xParticleSystem, F f)
template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles>
bool	searchParticleLocally (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t globalIDrequested, std::size_t &localParticleID)
template<typename T , unsigned D>
bool	getBlockParticleIntersection (const BlockGeometry< T, D > &blockGeometry, T invDeltaX, LatticeR< D > &start, LatticeR< D > &end, Vector< T, D > position, T circumRadius)
template<typename T , unsigned D>
void	checkSmoothIndicatorOutOfGeometry (bool &outOfGeometry, Vector< T, D > &ghostPos, const PhysR< T, D > &cellMin, const PhysR< T, D > &cellMax, const Vector< T, D > &position, T circumRadius, const Vector< bool, D > &periodic)
template<typename T , typename DESCRIPTOR , typename F >
void	forSpatialLocationsInBlockParticleIntersection (const BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockLattice< T, DESCRIPTOR > &blockLattice, Vector< T, DESCRIPTOR::d > position, T circumRadius, F f)
template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >
void	setBlockParticleField (const BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockLattice< T, DESCRIPTOR > &blockLattice, UnitConverter< T, DESCRIPTOR > const &converter, Particle< T, PARTICLETYPE > &particle)
template<typename T , typename DESCRIPTOR , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , typename WALLCONTACTTYPE , typename F = decltype(defaults::periodicity<PARTICLETYPE::d>)>
void	setBlockParticleField (const BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockLattice< T, DESCRIPTOR > &blockLattice, UnitConverter< T, DESCRIPTOR > const &converter, ParticleSystem< T, PARTICLETYPE > &particleSystem, contact::ContactContainer< T, PARTICLECONTACTTYPE, WALLCONTACTTYPE > &particleContacts, size_t iP, Particle< T, PARTICLETYPE > &particle, std::vector< SolidBoundary< T, DESCRIPTOR::d > > &solidBoundaries, const PhysR< T, DESCRIPTOR::d > &cellMin=PhysR< T, DESCRIPTOR::d >(std::numeric_limits< T >::quiet_NaN()), const PhysR< T, DESCRIPTOR::d > &cellMax=PhysR< T, DESCRIPTOR::d >(std::numeric_limits< T >::quiet_NaN()), F getSetupPeriodicity=defaults::periodicity< PARTICLETYPE::d >)
template<typename T , typename DESCRIPTOR >
void	resetBlockParticleField (const BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockLattice< T, DESCRIPTOR > &blockLattice)
template<typename T , typename DESCRIPTOR >
void	resetBlockContactField (const BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockLattice< T, DESCRIPTOR > &blockLattice)
template<typename T , unsigned D>
bool	getBlockParticleIntersection (const BlockGeometry< T, D > &blockGeometry, T invDeltaX, LatticeR< D > &start, LatticeR< D > &end, PhysR< T, D > position, T circumRadius)
template<typename T , unsigned D>
void	checkSmoothIndicatorOutOfGeometry (bool &surfaceOutOfGeometry, PhysR< T, D > &ghostPos, const PhysR< T, D > &cellMin, const PhysR< T, D > &cellMax, const PhysR< T, D > &position, T circumRadius, const Vector< bool, D > &periodic)
template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >
void	setBlockParticleField (const BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockLattice< T, DESCRIPTOR > &blockLattice, UnitConverter< T, DESCRIPTOR > const &converter, const PhysR< T, DESCRIPTOR::d > &cellMin, const PhysR< T, DESCRIPTOR::d > &cellMax, Particle< T, PARTICLETYPE > &particle, const Vector< bool, DESCRIPTOR::d > &periodic)
template<typename T , typename DESCRIPTOR , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , typename WALLCONTACTTYPE , typename F >
void	setBlockParticleField (const BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockLattice< T, DESCRIPTOR > &blockLattice, UnitConverter< T, DESCRIPTOR > const &converter, const PhysR< T, DESCRIPTOR::d > &cellMin, const PhysR< T, DESCRIPTOR::d > &cellMax, ParticleSystem< T, PARTICLETYPE > &particleSystem, contact::ContactContainer< T, PARTICLECONTACTTYPE, WALLCONTACTTYPE > &contactContainer, size_t iP, Particle< T, PARTICLETYPE > &particle, std::vector< SolidBoundary< T, DESCRIPTOR::d > > &solidBoundaries, F getSetupPeriodicity)
template<typename T , typename DESCRIPTOR , typename F >
void	forSpatialLocationsInBlockParticleIntersection (const BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockLattice< T, DESCRIPTOR > &blockLattice, int padding, Vector< T, DESCRIPTOR::d > position, T circumRadius, F f)
template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >
void	setSuperParticleField (const SuperGeometry< T, DESCRIPTOR::d > &sGeometry, SuperLattice< T, DESCRIPTOR > &sLattice, UnitConverter< T, DESCRIPTOR > const &converter, Particle< T, PARTICLETYPE > &particle, const Vector< bool, DESCRIPTOR::d > &periodicity)
	Set particle field with peridic support.
template<typename T , typename DESCRIPTOR , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , typename WALLCONTACTTYPE , typename F >
void	setSuperParticleField (const SuperGeometry< T, DESCRIPTOR::d > &sGeometry, const PhysR< T, DESCRIPTOR::d > &min, const PhysR< T, DESCRIPTOR::d > &max, SuperLattice< T, DESCRIPTOR > &sLattice, UnitConverter< T, DESCRIPTOR > const &converter, ParticleSystem< T, PARTICLETYPE > &particleSystem, contact::ContactContainer< T, PARTICLECONTACTTYPE, WALLCONTACTTYPE > &particleContacts, size_t iP, Particle< T, PARTICLETYPE > &particle, std::vector< SolidBoundary< T, DESCRIPTOR::d > > &solidBoundaries, F getSetupPeriodicity, int globiC=-1)
template<typename T , typename DESCRIPTOR >
void	resetSuperParticleField (SuperGeometry< T, DESCRIPTOR::d > &sGeometry, SuperLattice< T, DESCRIPTOR > &sLattice)
	Reset particle field.
template<typename T , typename DESCRIPTOR >
void	resetContactField (SuperGeometry< T, DESCRIPTOR::d > &sGeometry, SuperLattice< T, DESCRIPTOR > &sLattice)

Typedef Documentation

apply_gravity

template<typename T , typename PARTICLETYPE >

using olb::particles::apply_gravity

Initial value:

 std::conditional_t<
  access::providesParallelization<PARTICLETYPE>(),
  apply_external_acceleration_parallel<T,PARTICLETYPE>,
  apply_external_acceleration_single_cuboid<T,PARTICLETYPE>
>

Definition at line 356 of file particleTasks.h.

communicate_parallel_surface_force

template<typename T , typename PARTICLETYPE >

using olb::particles::communicate_parallel_surface_force = communicate_surface_force<T,PARTICLETYPE>

Definition at line 363 of file particleTasks.h.

couple_lattice_to_particles

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

using olb::particles::couple_lattice_to_particles

Initial value:

 std::conditional_t<
  access::providesSurface<PARTICLETYPE>(),
  std::conditional_t<
    access::providesParallelization<PARTICLETYPE>(),
    couple_lattice_to_parallel_particles<T,DESCRIPTOR,PARTICLETYPE,
     BlockLatticeMomentumExchangeForce<T, DESCRIPTOR, PARTICLETYPE>>,
    couple_lattice_to_particles_single_cuboid<T,DESCRIPTOR,PARTICLETYPE,
     SuperLatticeMomentumExchangeForce<T, DESCRIPTOR, PARTICLETYPE>>>,
  couple_lattice_to_parallel_particles<T,DESCRIPTOR,PARTICLETYPE,
    BlockLatticeStokesDragForce<T,DESCRIPTOR,PARTICLETYPE,false>>
>

Aliases.

Definition at line 329 of file particleTasks.h.

couple_particles_to_lattice

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

using olb::particles::couple_particles_to_lattice

Initial value:

 std::conditional_t<
  access::providesParallelization<PARTICLETYPE>(),
  couple_parallel_particles_to_lattice<T,DESCRIPTOR,PARTICLETYPE>,
  couple_particles_to_lattice_single_cuboid<T,DESCRIPTOR,PARTICLETYPE>
>

Definition at line 342 of file particleTasks.h.

process_dynamics

template<typename T , typename PARTICLETYPE >

using olb::particles::process_dynamics

Initial value:

 std::conditional_t<
  access::providesParallelization<PARTICLETYPE>(),
  process_dynamics_parallel<T,PARTICLETYPE>,
  process_dynamics_single_cuboid<T,PARTICLETYPE>
>

Definition at line 349 of file particleTasks.h.

XParticleSystem

template<typename T , typename PARTICLETYPE >

using olb::particles::XParticleSystem

Initial value:

 std::conditional_t<
    PARTICLETYPE::template providesNested<descriptors::PARALLELIZATION>(),
    SuperParticleSystem<T, PARTICLETYPE>, ParticleSystem<T, PARTICLETYPE>>

Definition at line 74 of file superParticleSystem.h.

Function Documentation

checkSmoothIndicatorOutOfGeometry() [1/2]

template<typename T , unsigned D>

void olb::particles::checkSmoothIndicatorOutOfGeometry	(	bool &	outOfGeometry,
		Vector< T, D > &	ghostPos,
		const PhysR< T, D > &	cellMin,
		const PhysR< T, D > &	cellMax,
		const Vector< T, D > &	position,
		T	circumRadius,
		const Vector< bool, D > &	periodic )

Here is the caller graph for this function:

checkSmoothIndicatorOutOfGeometry() [2/2]

template<typename T , unsigned D>

void olb::particles::checkSmoothIndicatorOutOfGeometry	(	bool &	surfaceOutOfGeometry,
		PhysR< T, D > &	ghostPos,
		const PhysR< T, D > &	cellMin,
		const PhysR< T, D > &	cellMax,
		const PhysR< T, D > &	position,
		T	circumRadius,
		const Vector< bool, D > &	periodic )

Definition at line 68 of file blockLatticeInteraction.hh.

{
  ghostPos             = position;
  surfaceOutOfGeometry = false;
  for (unsigned i = 0; i < D; ++i) {
    T const particleMin = position[i] - circumRadius;
    T const particleMax = position[i] + circumRadius;
    if (particleMin < cellMin[i] && periodic[i]) {
      surfaceOutOfGeometry = true;
      ghostPos[i] = communication::movePositionToEnd(
          position[i], cellMax[i], cellMin[i]);
    }
    else if (particleMax > cellMax[i] && periodic[i]) {
      surfaceOutOfGeometry = true;
      ghostPos[i] = communication::movePositionToStart(
          position[i], cellMax[i], cellMin[i]);
    }
  }
}

References olb::particles::communication::movePositionToEnd(), and olb::particles::communication::movePositionToStart().

Here is the call graph for this function:

discretePointsOnSphericalHull() [1/2]

template<typename T >

std::array< Vector< T, 2 >, 8 > olb::particles::discretePointsOnSphericalHull	(	Vector< T, 2 >	position,
		T	radius )

Definition at line 100 of file particleUtilities.h.

{
  //TODO: check correctness
  T distA = radius;
  T distB = (1/std::sqrt(2))*distA;
 
  //Point on spherical hull
  std::array<Vector<T,2>,8> pointsOnSphericalHull = {
    Vector<T,2>(position[0]-distB, position[1]-distB),
    Vector<T,2>(position[0],       position[1]-distA),  //right
    Vector<T,2>(position[0]+distB, position[1]-distB),
 
    Vector<T,2>(position[0]-distA, position[1]),        //back
    // Centre excluded here!
    Vector<T,2>(position[0]+distA, position[1]),        //front
 
    Vector<T,2>(position[0]-distB, position[1]+distB),
    Vector<T,2>(position[0],       position[1]+distA),  //left
    Vector<T,2>(position[0]+distB, position[1]+distB)
  };
 
  return pointsOnSphericalHull;
}

discretePointsOnSphericalHull() [2/2]

template<typename T >

std::array< Vector< T, 3 >, 26 > olb::particles::discretePointsOnSphericalHull	(	Vector< T, 3 >	position,
		T	radius )

Definition at line 47 of file particleUtilities.h.

{
  //TODO: check correctness
  T distA = radius;
  T distB = (1/std::sqrt(2))*distA;
  T distC = (1/std::sqrt(2))*distB;
 
  //Point on spherical hull
  std::array<Vector<T,3>,26> pointsOnSphericalHull = {
    Vector<T,3>(position[0]-distC, position[1]-distC, position[2]-distC),
    Vector<T,3>(position[0],       position[1]-distB, position[2]-distB),
    Vector<T,3>(position[0]+distC, position[1]-distC, position[2]-distC),
 
    Vector<T,3>(position[0]-distB, position[1],       position[2]-distB),
    Vector<T,3>(position[0],       position[1],       position[2]-distA), //bottom
    Vector<T,3>(position[0]+distB, position[1],       position[2]-distB),
 
    Vector<T,3>(position[0]-distC, position[1]+distC, position[2]-distC),
    Vector<T,3>(position[0],       position[1]+distB, position[2]-distB),
    Vector<T,3>(position[0]+distC, position[1]+distC, position[2]-distC),
 
 
    Vector<T,3>(position[0]-distB, position[1]-distB, position[2]      ),
    Vector<T,3>(position[0],       position[1]-distA, position[2]      ), //right
    Vector<T,3>(position[0]+distB, position[1]-distB, position[2]      ),
 
    Vector<T,3>(position[0]-distA, position[1],       position[2]      ), //back
    // Centre excluded here!
    Vector<T,3>(position[0]+distA, position[1],       position[2]      ), //front
 
    Vector<T,3>(position[0]-distB, position[1]+distB, position[2]      ),
    Vector<T,3>(position[0],       position[1]+distA, position[2]      ), //left
    Vector<T,3>(position[0]+distB, position[1]+distB, position[2]      ),
 
 
    Vector<T,3>(position[0]-distC, position[1]-distC, position[2]+distC),
    Vector<T,3>(position[0],       position[1]-distB, position[2]+distB),
    Vector<T,3>(position[0]+distC, position[1]-distC, position[2]+distC),
 
    Vector<T,3>(position[0]-distB, position[1],       position[2]+distB),
    Vector<T,3>(position[0],       position[1],       position[2]+distA), //top
    Vector<T,3>(position[0]+distB, position[1],       position[2]+distB),
 
    Vector<T,3>(position[0]-distC, position[1]+distC, position[2]+distC),
    Vector<T,3>(position[0],       position[1]+distB, position[2]+distB),
    Vector<T,3>(position[0]+distC, position[1]+distC, position[2]+distC)
  };
 
  return pointsOnSphericalHull;
}

Here is the caller graph for this function:

doForParticle()

template<typename T , typename PARTICLETYPE , typename F >

void olb::particles::doForParticle	(	Particle< T, PARTICLETYPE > &	particle,
		F	f )

Definition at line 37 of file lambdaLoops.h.

{
  if constexpr (std::is_invocable_v<F,Particle<T,PARTICLETYPE>&>){
    f( particle );
  } else {
    f();
  }
}

Here is the caller graph for this function:

doForParticleMatchingID()

template<typename T , typename PARTICLETYPE , std::size_t selectedID, typename F >

void olb::particles::doForParticleMatchingID	(	XParticleSystem< T, PARTICLETYPE > &	xParticleSystem,
		F	f )

Definition at line 189 of file particleUtilities.h.

                                                                                     {
  const bool hasFieldValid = access::providesValid<PARTICLETYPE>();
  using PCOND = std::conditional_t<
    hasFieldValid,
    conditions::template valid_particle_matching_ID<selectedID>,
    conditions::template particle_matching_ID<selectedID>
  >;
  //Loop over particle and find the one matching iD
  forParticlesInXParticleSystem<T,PARTICLETYPE,PCOND>( xParticleSystem, f );
}

References doForParticleMatchingID().

Here is the call graph for this function:

Here is the caller graph for this function:

doWhenMeetingCondition() [1/2]

template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles, typename F >

void olb::particles::doWhenMeetingCondition	(	Particle< T, PARTICLETYPE > &	particle,
		F	f )

Definition at line 55 of file lambdaLoops.h.

{
  //Check whether dynamic (constexpression value not possible)
  if constexpr (PCONDITION::dynamic){
    if ( PCONDITION::template value<T,PARTICLETYPE>(particle) ){
      doForParticle( particle, f);
    }
  }
  //Use static constexpression value
  //- for now, implies no template use
  else {
    if constexpr (PCONDITION::value){
      doForParticle( particle, f);
    }
  }
}

References doForParticle().

Here is the call graph for this function:

doWhenMeetingCondition() [2/2]

template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles, typename F >

void olb::particles::doWhenMeetingCondition	(	Particle< T, PARTICLETYPE > &	particle,
		F	f,
		int	globiC )

Definition at line 82 of file lambdaLoops.h.

{
  //Check whether dynamic (constexpression value not possible)
  if constexpr (PCONDITION::dynamic){
    //Check whether globiC has to be passed
    if constexpr (std::is_invocable_v<decltype(PCONDITION::template value<T,PARTICLETYPE>),
                  Particle<T,PARTICLETYPE>&,int>){
      if ( PCONDITION::template value<T,PARTICLETYPE>(particle,globiC) ){
        if constexpr (std::is_invocable_v<F,Particle<T,PARTICLETYPE>&>){
          f( particle );
        } else {
          f();
        }
      }
    } else {
      //Call without globiC
      if ( PCONDITION::template value<T,PARTICLETYPE>(particle) ){
        doForParticle( particle, f);
      }
    }
  }
  //Use static constexpression value
  else {
    //Call without globiC
    if constexpr (PCONDITION::value){
      doForParticle( particle, f);
    }
  }
}

References doForParticle().

Here is the call graph for this function:

forParticlesInParticleSystem() [1/2]

template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles, typename F >

void olb::particles::forParticlesInParticleSystem	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		F	f )

Definition at line 135 of file lambdaLoops.h.

{
  for (std::size_t iP=0; iP<particleSystem.size(); ++iP) {
    auto particle = particleSystem.get(iP);
    //Execute F when particle meets condition
    doWhenMeetingCondition<T,PARTICLETYPE,PCONDITION>( particle,
      [&](Particle<T,PARTICLETYPE> particle){
      f( particle );
    });
  }
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

forParticlesInParticleSystem() [2/2]

template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles, typename F >

void olb::particles::forParticlesInParticleSystem	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		F	f,
		int	globiC )

Definition at line 118 of file lambdaLoops.h.

{
  for (std::size_t iP=0; iP<particleSystem.size(); ++iP) {
    auto particle = particleSystem.get(iP);
    //Execute F when particle meets condition
    doWhenMeetingCondition<T,PARTICLETYPE,PCONDITION>( particle,
      [&](Particle<T,PARTICLETYPE> particle){
      f( particle );
    }, globiC );
  }
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

forParticlesInXParticleSystem()

template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles, typename F >

void olb::particles::forParticlesInXParticleSystem	(	XParticleSystem< T, PARTICLETYPE > &	xParticleSystem,
		F	f )

Iterate over particles in x particle system.

• works both for ParticleSystem and SuperParticleSystem
• can both be run for
  • [](Particle<T,PARTICLETYPE>,ParticleSystem<T,PARTICLETYPE>,int){}
  • [](Particle<T,PARTICLETYPE>){}

Definition at line 227 of file lambdaLoops.h.

{
  if constexpr( access::providesParallelization<PARTICLETYPE>() ){
    //Iterate over particle systems
    communication::forSystemsInSuperParticleSystem( xParticleSystem,
      [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
      //Iterate over particles
      forParticlesInParticleSystem<T,PARTICLETYPE,PCONDITION>( particleSystem,
        [&](Particle<T,PARTICLETYPE>& particle){
        if constexpr (std::is_invocable_v<F,
          Particle<T,PARTICLETYPE>&,ParticleSystem<T,PARTICLETYPE>&,int>)
        {
          f( particle, particleSystem, globiC );
        } else {
          f( particle );
        }
      },globiC);
    });
  } else {
    //Loop over all particles
    forParticlesInParticleSystem<T,PARTICLETYPE,PCONDITION>( xParticleSystem,
      [&](Particle<T,PARTICLETYPE>& particle){
        if constexpr (std::is_invocable_v<F,
          Particle<T,PARTICLETYPE>&,ParticleSystem<T,PARTICLETYPE>&,int>)
        {
          f( particle, xParticleSystem, 0 );
        } else {
          f( particle );
        }
    });
  }
}

References olb::particles::communication::forSystemsInSuperParticleSystem().

Here is the call graph for this function:

forSpatialLocationsInBlockParticleIntersection() [1/2]

template<typename T , typename DESCRIPTOR , typename F >

void olb::particles::forSpatialLocationsInBlockParticleIntersection	(	const BlockGeometry< T, DESCRIPTOR::d > &	blockGeometry,
		BlockLattice< T, DESCRIPTOR > &	blockLattice,
		int	padding,
		Vector< T, DESCRIPTOR::d >	position,
		T	circumRadius,
		F	f )

Definition at line 195 of file blockLatticeInteraction.hh.

{
  constexpr unsigned D = DESCRIPTOR::d;
  LatticeR<D>        start;
  LatticeR<D>        end;
  if (getBlockParticleIntersection(blockGeometry,
                                   T {1} / blockGeometry.getDeltaR(), start,
                                   end, position, circumRadius)) {
    //Extend range by padding if desired
    start -= LatticeR<D>(padding);
    end += LatticeR<D>(padding);
    //For all cells in subdomain defined by start/end
    blockLattice.forSpatialLocations(start, end,
                                     [&](const LatticeR<D>& latticeR) {
                                       f(latticeR);
                                     });
  }
}

References olb::BlockStructureD< D >::forSpatialLocations(), getBlockParticleIntersection(), and olb::BlockGeometry< T, D >::getDeltaR().

Here is the call graph for this function:

forSpatialLocationsInBlockParticleIntersection() [2/2]

template<typename T , typename DESCRIPTOR , typename F >

void olb::particles::forSpatialLocationsInBlockParticleIntersection	(	const BlockGeometry< T, DESCRIPTOR::d > &	blockGeometry,
		BlockLattice< T, DESCRIPTOR > &	blockLattice,
		Vector< T, DESCRIPTOR::d >	position,
		T	circumRadius,
		F	f )

Here is the caller graph for this function:

getBlockParticleIntersection() [1/2]

template<typename T , unsigned D>

bool olb::particles::getBlockParticleIntersection	(	const BlockGeometry< T, D > &	blockGeometry,
		T	invDeltaX,
		LatticeR< D > &	start,
		LatticeR< D > &	end,
		PhysR< T, D >	position,
		T	circumRadius )

Setting block bounds excluding(!) padding

Calculate relative start/end in block domain

Set latticeR start/end and check validity

Definition at line 39 of file blockLatticeInteraction.hh.

{
  LatticeR<D> blockMin(0);
  LatticeR<D> blockMax(blockGeometry.getExtent() - 1);
 
  PhysR<T, D> particleMin(position - circumRadius);
  PhysR<T, D> relStart(particleMin - blockGeometry.getOrigin());
  PhysR<T, D> particleMax(position + circumRadius);
  PhysR<T, D> relEnd(particleMax - blockGeometry.getOrigin());
 
  bool validRange = true;
  for (unsigned iDim = 0; iDim < D; ++iDim) {
    start[iDim] =
        util::max(util::floor(invDeltaX * relStart[iDim]), blockMin[iDim]);
    end[iDim] = util::min(util::ceil(invDeltaX * relEnd[iDim]), blockMax[iDim]);
    int intersectionRange = end[iDim] - start[iDim];
    validRange            = validRange && (intersectionRange >= 0.);
  }
 
  return validRange;
}

References olb::util::ceil(), olb::util::floor(), olb::BlockGeometry< T, D >::getExtent(), olb::BlockGeometry< T, D >::getOrigin(), olb::util::max(), and olb::util::min().

Here is the call graph for this function:

getBlockParticleIntersection() [2/2]

template<typename T , unsigned D>

bool olb::particles::getBlockParticleIntersection	(	const BlockGeometry< T, D > &	blockGeometry,
		T	invDeltaX,
		LatticeR< D > &	start,
		LatticeR< D > &	end,
		Vector< T, D >	position,
		T	circumRadius )

Here is the caller graph for this function:

isPeriodic()

template<unsigned D>

constexpr bool olb::particles::isPeriodic ( const Vector< bool, D > & periodic )

constexpr

Definition at line 42 of file particleDynamicsFunctions.h.

{
  bool isPeriodic = periodic[0] || periodic[1];
  if constexpr (D == 3) {
    isPeriodic = isPeriodic || periodic[2];
  }
  return isPeriodic;
}

References isPeriodic().

Here is the call graph for this function:

Here is the caller graph for this function:

purgeInvalidParticles()

template<typename T , typename PARTICLETYPE >

void olb::particles::purgeInvalidParticles

(

XParticleSystem< T, PARTICLETYPE > &

xParticleSystem

)

Definition at line 146 of file particleUtilities.h.

{
  using PCONDITION = conditions::invalid_particles;
  if constexpr (access::providesParallelization<PARTICLETYPE>()){
    auto& sParticleSystem = xParticleSystem;
    //Iterate over particle systems
    communication::forSystemsInSuperParticleSystem( sParticleSystem,
      [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
      //Iterate over particles
      std::size_t iP=0;
      while(iP < particleSystem.size()){
        auto particle = particleSystem.get(iP);
        ++iP;
        //Execute F when particle meets condition
        doWhenMeetingCondition<T,PARTICLETYPE,PCONDITION>( particle,
          [&](Particle<T,PARTICLETYPE> particle){
          //Erase particle
          auto& container = particleSystem.get();
          container.erase( particle.getId() );
          --iP; //reset counter
        },globiC);
      }
    });
  } else {
    auto& particleSystem = xParticleSystem;
    std::size_t iP=0;
    while(iP < particleSystem.size()){
      auto particle = particleSystem.get(iP);
      ++iP;
      //Execute F when particle meets condition
      doWhenMeetingCondition<T,PARTICLETYPE,PCONDITION>( particle,
        [&](Particle<T,PARTICLETYPE> particle){
        //Erase particle
        auto& container = particleSystem.get();
        container.erase( particle.getId() );
        --iP; //reset counter
      });
    }
  }
}

References olb::particles::communication::forSystemsInSuperParticleSystem(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

resetAllParticleRelatedFields()

template<typename DESCRIPTOR , typename CELL , typename V = typename CELL::value_t>

void olb::particles::resetAllParticleRelatedFields ( CELL & cell )

inlinenoexcept

Definition at line 82 of file porousBGKdynamics.h.

{
  resetParticleRelatedFields<DESCRIPTOR,CELL,V>(cell);
  resetParticleContactRelatedFields<DESCRIPTOR,CELL,V>(cell);
}

resetBlockContactField()

template<typename T , typename DESCRIPTOR >

void olb::particles::resetBlockContactField	(	const BlockGeometry< T, DESCRIPTOR::d > &	blockGeometry,
		BlockLattice< T, DESCRIPTOR > &	blockLattice )

Definition at line 455 of file blockLatticeInteraction.hh.

{
  constexpr unsigned D       = DESCRIPTOR::d;
  int                padding = blockGeometry.getPadding();
  LatticeR<D>        blockMin(0. - padding);
  LatticeR<D>        blockMax(blockGeometry.getExtent() - 1 + padding);
 
  using namespace descriptors;
  blockLattice.forSpatialLocations(
      blockMin, blockMax, [&](LatticeR<D> latticeR) {
        auto cell = blockLattice.get(latticeR);
        particles::resetParticleContactRelatedFields<DESCRIPTOR, decltype(cell), typename decltype(cell)::value_t>(cell);
      });
}

References olb::BlockStructureD< D >::forSpatialLocations(), olb::BlockLattice< T, DESCRIPTOR >::get(), olb::BlockGeometry< T, D >::getExtent(), and olb::BlockStructureD< D >::getPadding().

Here is the call graph for this function:

Here is the caller graph for this function:

resetBlockParticleField()

template<typename T , typename DESCRIPTOR >

void olb::particles::resetBlockParticleField	(	const BlockGeometry< T, DESCRIPTOR::d > &	blockGeometry,
		BlockLattice< T, DESCRIPTOR > &	blockLattice )

Definition at line 436 of file blockLatticeInteraction.hh.

{
  constexpr unsigned D       = DESCRIPTOR::d;
  int                padding = blockGeometry.getPadding();
  LatticeR<D>        blockMin(0. - padding);
  LatticeR<D>        blockMax(blockGeometry.getExtent() - 1 + padding);
 
  using namespace descriptors;
  blockLattice.forSpatialLocations(
      blockMin, blockMax, [&](const LatticeR<D>& latticeR) {
        auto cell = blockLattice.get(latticeR);
        particles::resetAllParticleRelatedFields<DESCRIPTOR, decltype(cell), typename decltype(cell)::value_t>(cell);
      });
}

References olb::BlockStructureD< D >::forSpatialLocations(), olb::BlockLattice< T, DESCRIPTOR >::get(), olb::BlockGeometry< T, D >::getExtent(), and olb::BlockStructureD< D >::getPadding().

Here is the call graph for this function:

Here is the caller graph for this function:

resetContactField()

template<typename T , typename DESCRIPTOR >

void olb::particles::resetContactField	(	SuperGeometry< T, DESCRIPTOR::d > &	sGeometry,
		SuperLattice< T, DESCRIPTOR > &	sLattice )

Definition at line 102 of file superLatticeInteraction.hh.

{
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    resetBlockContactField( sGeometry.getBlockGeometry(iC), sLattice.getBlock(iC));
  }
}

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

Here is the call graph for this function:

resetParticleContactRelatedFields()

template<typename DESCRIPTOR , typename CELL , typename V = typename CELL::value_t>

void olb::particles::resetParticleContactRelatedFields ( CELL & cell )

inlinenoexcept

Definition at line 71 of file porousBGKdynamics.h.

{
  if constexpr (DESCRIPTOR::template provides<
                    descriptors::CONTACT_DETECTION>()) {
    cell.template setField<descriptors::CONTACT_DETECTION>(
        descriptors::CONTACT_DETECTION::template getInitialValue<V,DESCRIPTOR>() );
  }
}

resetParticleRelatedFields()

template<typename DESCRIPTOR , typename CELL , typename V = typename CELL::value_t>

void olb::particles::resetParticleRelatedFields ( CELL & cell )

inlinenoexcept

Definition at line 47 of file porousBGKdynamics.h.

{
  if constexpr (DESCRIPTOR::template provides<descriptors::POROSITY>()) {
    cell.template setField<descriptors::POROSITY>(
        descriptors::POROSITY::template getInitialValue<V,DESCRIPTOR>() );
  }
  if constexpr (DESCRIPTOR::template provides<
                    descriptors::VELOCITY_DENOMINATOR>()) {
    cell.template setField<descriptors::VELOCITY_DENOMINATOR>(
        descriptors::VELOCITY_DENOMINATOR::template getInitialValue<V,DESCRIPTOR>() );
  }
  if constexpr (DESCRIPTOR::template provides<
                    descriptors::VELOCITY_NUMERATOR>()) {
    cell.template setField<descriptors::VELOCITY_NUMERATOR>(
        descriptors::VELOCITY_NUMERATOR::template getInitialValue<V,DESCRIPTOR>() );
  }
  if constexpr (DESCRIPTOR::template provides<descriptors::VELOCITY_SOLID>()) {
    cell.template setField<descriptors::VELOCITY_SOLID>(
        descriptors::VELOCITY_SOLID::template getInitialValue<V,DESCRIPTOR>() );
  }
}

resetSuperParticleField()

template<typename T , typename DESCRIPTOR >

void olb::particles::resetSuperParticleField	(	SuperGeometry< T, DESCRIPTOR::d > &	sGeometry,
		SuperLattice< T, DESCRIPTOR > &	sLattice )

Reset particle field.

Definition at line 92 of file superLatticeInteraction.hh.

{
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    resetBlockParticleField( sGeometry.getBlockGeometry(iC), sLattice.getBlock(iC));
  }
}

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

Here is the call graph for this function:

searchParticleLocally()

template<typename T , typename PARTICLETYPE , typename PCONDITION = conditions::valid_particles>

bool olb::particles::searchParticleLocally	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	globalIDrequested,
		std::size_t &	localParticleID )

Definition at line 202 of file particleUtilities.h.

{
  using namespace descriptors;
  static_assert(PARTICLETYPE::template providesNested<PARALLELIZATION,ID>(), "Field PARALLELIZATION:ID has to be provided");
  //Initialize return quantities
  localParticleID = 0;
  bool found = false;
  //Loop over particles
  for (std::size_t iP=0; iP<particleSystem.size(); ++iP) {
    if (!found){
      auto particle = particleSystem.get(iP);
      //Execute F when particle meets condition
      doWhenMeetingCondition<T,PARTICLETYPE,PCONDITION>( particle,
        [&](Particle<T,PARTICLETYPE> particle){
        auto globalID = particle.template getField<PARALLELIZATION,ID>();
        if (globalID==globalIDrequested){
          localParticleID = particle.getId();
          found=true;
        }
      });
    } else {
      break;
    }
  }
  return found;
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), olb::particles::Particle< T, PARTICLETYPE >::getId(), searchParticleLocally(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

setBlockParticleField() [1/4]

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

void olb::particles::setBlockParticleField	(	const BlockGeometry< T, DESCRIPTOR::d > &	blockGeometry,
		BlockLattice< T, DESCRIPTOR > &	blockLattice,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		const PhysR< T, DESCRIPTOR::d > &	cellMin,
		const PhysR< T, DESCRIPTOR::d > &	cellMax,
		Particle< T, PARTICLETYPE > &	particle,
		const Vector< bool, DESCRIPTOR::d > &	periodic )

Definition at line 95 of file blockLatticeInteraction.hh.

{
  constexpr unsigned D = DESCRIPTOR::d;
  using namespace descriptors;
  const T           circumRadius = particles::access::getRadius(particle);
  const PhysR<T, D> originalPosition(particles::access::getPosition(particle));
  // Checking if the particle's surface leaves the domain
  bool        surfaceOutOfGeometry;
  PhysR<T, D> ghostPos;
  checkSmoothIndicatorOutOfGeometry(surfaceOutOfGeometry, ghostPos, cellMin,
                                    cellMax, originalPosition, circumRadius,
                                    periodic);
 
  //Do the normal routine if the particle is in the geometry
  if (!surfaceOutOfGeometry) {
    setBlockParticleField(blockGeometry, blockLattice, converter, particle);
  }
  else {
    //sets the Particle to ghost position on the other side of the domain and sets the field
    particle.template setField<GENERAL, POSITION>(ghostPos);
    setBlockParticleField(blockGeometry, blockLattice, converter, particle);
    //Reverting Particle to its Previous position and setting the field
    particle.template setField<GENERAL, POSITION>(originalPosition);
    setBlockParticleField(blockGeometry, blockLattice, converter, particle);
 
    // For parallized particles, the update of the position is processed during relocation
    if constexpr(!particles::access::providesParallelization<PARTICLETYPE>()) {
      // Check if center of mass left the simulation domain
      bool centerOfMassOutOfDomain = false;
      for (unsigned iDim = 0; iDim < D; ++iDim) {
        centerOfMassOutOfDomain = centerOfMassOutOfDomain ||
                                  originalPosition[iDim] < cellMin[iDim] ||
                                  originalPosition[iDim] > cellMax[iDim];
      }
 
      // Replace the position of the center of mass with the ghost position
      // (If the center of mass is outside the domain)
      if (centerOfMassOutOfDomain) {
        particle.template setField<GENERAL, POSITION>(ghostPos);
      }
    }
  }
}

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

Here is the call graph for this function:

setBlockParticleField() [2/4]

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , typename WALLCONTACTTYPE , typename F >

void olb::particles::setBlockParticleField	(	const BlockGeometry< T, DESCRIPTOR::d > &	blockGeometry,
		BlockLattice< T, DESCRIPTOR > &	blockLattice,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		const PhysR< T, DESCRIPTOR::d > &	cellMin,
		const PhysR< T, DESCRIPTOR::d > &	cellMax,
		ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		contact::ContactContainer< T, PARTICLECONTACTTYPE, WALLCONTACTTYPE > &	contactContainer,
		size_t	iP,
		Particle< T, PARTICLETYPE > &	particle,
		std::vector< SolidBoundary< T, DESCRIPTOR::d > > &	solidBoundaries,
		F	getSetupPeriodicity )

Definition at line 147 of file blockLatticeInteraction.hh.

{
  constexpr unsigned D = DESCRIPTOR::d;
  using namespace descriptors;
  const T circumRadius = particles::access::getRadius(particle);
  // Checking if the Particle leaves the Domain
  bool        surfaceOutOfGeometry;
  PhysR<T, D> originalPosition(particles::access::getPosition(particle));
  PhysR<T, D> ghostPos;
  checkSmoothIndicatorOutOfGeometry(
      surfaceOutOfGeometry, ghostPos, cellMin, cellMax, originalPosition,
      circumRadius, getSetupPeriodicity());
 
  //Do the normal routine if the particle is in the geometry
  if (!surfaceOutOfGeometry) {
    setBlockParticleField(blockGeometry, blockLattice, converter,
                          particleSystem, contactContainer, iP, particle,
                          solidBoundaries);
  }
  else {
    //sets the Particle to ghost position on the other side of the domain and sets the field
    particle.template setField<GENERAL, POSITION>(ghostPos);
    setBlockParticleField(blockGeometry, blockLattice, converter,
                          particleSystem, contactContainer, iP, particle,
                          solidBoundaries, cellMin, cellMax,
                          getSetupPeriodicity);
    //Reverting Particle to its Previous position and setting the field
    particle.template setField<GENERAL, POSITION>(originalPosition);
    setBlockParticleField(blockGeometry, blockLattice, converter,
                          particleSystem, contactContainer, iP, particle,
                          solidBoundaries, cellMin, cellMax,
                          getSetupPeriodicity);
  }
}

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

Here is the call graph for this function:

setBlockParticleField() [3/4]

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

void olb::particles::setBlockParticleField	(	const BlockGeometry< T, DESCRIPTOR::d > &	blockGeometry,
		BlockLattice< T, DESCRIPTOR > &	blockLattice,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		Particle< T, PARTICLETYPE > &	particle )

Definition at line 220 of file blockLatticeInteraction.hh.

{
  constexpr unsigned D = DESCRIPTOR::d;
 
  using namespace descriptors;
  auto circumRadius =
      particle.template getField<SURFACE, SINDICATOR>()->getCircumRadius();
  auto position = particle.template getField<GENERAL, POSITION>();
 
  //For all cells in block particle intersection
  int padding = blockGeometry.getPadding();
  forSpatialLocationsInBlockParticleIntersection(
      blockGeometry, blockLattice, padding, position, circumRadius,
      [&](const LatticeR<D>& latticeR) {
        //Get phys position
        T physR[D] = {};
        blockGeometry.getPhysR(physR, latticeR);
        //Retrieve porosity
        FieldD<T, DESCRIPTOR, descriptors::POROSITY> porosity {};
        particles::resolved::evalSolidVolumeFraction(porosity.data(), physR, particle);
 
        //For cells containing particle bits
        if (!util::nearZero(porosity[0])) {
          auto material = blockGeometry.get(latticeR);
          //TODO: remove material 1 from hardcoded version
          if (material == 1) {
            //Retrieve local velocity
            FieldD<T, DESCRIPTOR, descriptors::VELOCITY> velocity {};
            velocity = particles::dynamics::calculateLocalVelocity(
                particle, PhysR<T, D>(physR));
            for (unsigned iDim = 0; iDim != D; ++iDim) {
              velocity[iDim] = converter.getLatticeVelocity(velocity[iDim]);
            }
            //Calculate solid volume fraction
            T solidVolumeFraction = 1. - porosity[0];
            //Write to fields
            {
              auto cell = blockLattice.get(latticeR);
              if constexpr (!DESCRIPTOR::template provides<descriptors::VELOCITY_SOLID>()) {
                cell.template getFieldPointer<
                    descriptors::VELOCITY_NUMERATOR>() += porosity[0] * velocity;
                cell.template getFieldPointer<
                    descriptors::VELOCITY_DENOMINATOR>() += porosity;
              }
              else {
                cell.template getFieldPointer<
                    descriptors::VELOCITY_SOLID>() += velocity;
              }
              cell.template getFieldPointer<descriptors::POROSITY>() *=
                  solidVolumeFraction;
            }
          } //if (material==1)
        }   //if (!util::nearZero(porosity[0]))
      });
}

References olb::particles::dynamics::calculateLocalVelocity(), olb::particles::resolved::evalSolidVolumeFraction(), forSpatialLocationsInBlockParticleIntersection(), olb::BlockLattice< T, DESCRIPTOR >::get(), olb::BlockGeometry< T, D >::get(), olb::UnitConverter< T, DESCRIPTOR >::getLatticeVelocity(), olb::BlockStructureD< D >::getPadding(), olb::BlockGeometry< T, D >::getPhysR(), and olb::util::nearZero().

Here is the call graph for this function:

Here is the caller graph for this function:

setBlockParticleField() [4/4]

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , typename WALLCONTACTTYPE , typename F = decltype(defaults::periodicity<PARTICLETYPE::d>)>

void olb::particles::setBlockParticleField	(	const BlockGeometry< T, DESCRIPTOR::d > &	blockGeometry,
		BlockLattice< T, DESCRIPTOR > &	blockLattice,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		contact::ContactContainer< T, PARTICLECONTACTTYPE, WALLCONTACTTYPE > &	particleContacts,
		size_t	iP,
		Particle< T, PARTICLETYPE > &	particle,
		std::vector< SolidBoundary< T, DESCRIPTOR::d > > &	solidBoundaries,
		const PhysR< T, DESCRIPTOR::d > &	cellMin = PhysR<T, DESCRIPTOR::d>(std::numeric_limits<T>::quiet_NaN()),
		const PhysR< T, DESCRIPTOR::d > &	cellMax = PhysR<T, DESCRIPTOR::d>(std::numeric_limits<T>::quiet_NaN()),
		F	getSetupPeriodicity = defaults::periodicity<PARTICLETYPE::d> )

Definition at line 281 of file blockLatticeInteraction.hh.

{
  using namespace descriptors;
  constexpr unsigned D      = DESCRIPTOR::d;
  const T deltaX = blockGeometry.getDeltaR();
  auto    sIndicator   = particle.template getField<SURFACE, SINDICATOR>();
  const T detectionDistance = particles::contact::evalContactDetectionDistance(particle, deltaX);
  const T circumRadius = particles::contact::evalCircumRadius(
      detectionDistance, sIndicator->getCircumRadius(), sIndicator->getEpsilon());
  auto position = particle.template getField<GENERAL, POSITION>();
  //Retrieve wallMaterials
  std::unordered_set<int> wallMaterials = getLatticeMaterials( solidBoundaries );
 
  //For all cells in block particle intersection
  int padding = blockGeometry.getPadding();
  forSpatialLocationsInBlockParticleIntersection(
      blockGeometry, blockLattice, padding, position, circumRadius,
      [&](const LatticeR<D>& latticeR) {
        //Get phys position
        T physR[D] = {};
        blockGeometry.getPhysR(physR, latticeR);
        T const signedDist = particles::resolved::signedDistanceToParticle(
            particle, PhysR<T, D>(physR));
        //Retrieve porosity
        FieldD<T, DESCRIPTOR, descriptors::POROSITY> porosity {};
        sdf::evalSolidVolumeFraction(porosity.data(), signedDist,
                          sIndicator->getEpsilon());
 
        //For cells containing particle bits
        if (!util::nearZero(porosity[0])) {
          //Retrieve material at cell and ensure location outside of boundary
          auto material = blockGeometry.getMaterial(latticeR);
          if (material != 0 && wallMaterials.find(material)==wallMaterials.end()) {
            //Retrieve local velocity
            FieldD<T, DESCRIPTOR, descriptors::VELOCITY> velocity {};
            velocity = particles::dynamics::calculateLocalVelocity(
                particle, PhysR<T, D>(physR));
            for (unsigned iDim = 0; iDim != D; ++iDim) {
                velocity[iDim] = converter.getLatticeVelocity(velocity[iDim]);
            }
            //Calculate solid volume fraction
            T solidVolumeFraction = 1. - porosity[0];
            //Write to fields
            {
              auto cell = blockLattice.get(latticeR);
              if constexpr (!DESCRIPTOR::template provides<descriptors::VELOCITY_SOLID>()) {
                cell.template getFieldPointer<descriptors::VELOCITY_NUMERATOR>() +=
                  porosity[0] * velocity;
                cell.template getFieldPointer<
                  descriptors::VELOCITY_DENOMINATOR>() += porosity;
              }
              else {
                cell.template getFieldPointer<descriptors::VELOCITY_SOLID>() += velocity;
              }
              cell.template getFieldPointer<descriptors::POROSITY>() *=
                  solidVolumeFraction;
            }
          } //if (wallMaterials.find(material)==wallMaterials.end())
        } //if (!util::nearZero(porosity[0]))
 
        // For contacts we have another distance
        // Particle-particle detection (0.5 * deltaX layer for each equals deltaX which is then the same as for the wall detection)
        if (signedDist < detectionDistance) {
          // We must ignore cells on padding
          bool ignoreCell = false;
          for (unsigned i = 0; i < D; ++i) {
            if (latticeR[i] < 0 ||
                latticeR[i] > blockGeometry.getExtent()[i] - 1) {
              ignoreCell = true;
            }
          }
 
          // processing contact detection
          if (!ignoreCell) {
            auto contactHelper = blockLattice.get(latticeR)
                                       .template getFieldPointer<
                                           descriptors::CONTACT_DETECTION>();
            // this checks if another particle is already on this cell, if yes, the contacts are updated. If no, the ID (shifted by 1) is stored.
            std::size_t iP2 = contactHelper[0] - 1;
            if (contactHelper[0] > 0 && iP2 != iP) {
              std::size_t localiP2 = iP2;
              if constexpr (particles::access::providesParallelization<
                                PARTICLETYPE>()) {
                for (std::size_t localiP = 0; localiP < particleSystem.size();
                     ++localiP) {
                  const std::size_t globalParticleID =
                      particleSystem.get(localiP)
                          .template getField<PARALLELIZATION, ID>();
                  if (globalParticleID == iP2) {
                    localiP2 = localiP;
                    break;
                  }
                }
              }
              auto particle2 = particleSystem.get(localiP2);
 
              // Check that at least one particle should not ignore contacts
              bool detectParticleContacts = true;
              if constexpr (access::providesComputeContact<PARTICLETYPE>()) {
                detectParticleContacts =
                    access::isContactComputationEnabled(particle, particle2);
              }
 
              if (detectParticleContacts) {
                particles::contact::updateContacts(
                    contactContainer, std::array<std::size_t, 2>({iP2, iP}),
                    PhysR<T, D>(physR), particle2, particle, cellMin, cellMax,
                    getSetupPeriodicity, deltaX);
              }
            }
            else {
              contactHelper[0] = iP + 1;
            }
 
            // Check if contacts should be ignored
            bool detectWallContacts = true;
            if constexpr (access::providesComputeContact<PARTICLETYPE>()) {
              detectWallContacts =
                  access::isContactComputationEnabled(particle);
            }
 
            if (detectWallContacts) {
              // TODO: Use the following line with c++20
              //for (unsigned short solidBoundaryID = 0; SolidBoundary<T, DESCRIPTOR::d>& solidBoundary : solidBoundaries)
              unsigned solidBoundaryID = 0;
              for (SolidBoundary<T, DESCRIPTOR::d>& solidBoundary :
                   solidBoundaries) {
                const T solidBoundaryDetectionDistance =
                    0.5 * util::sqrt(D) * deltaX +
                    solidBoundary.getEnlargementForContact();
                if (solidBoundary.getIndicator()->signedDistance(
                        PhysR<T, D>(physR)) < solidBoundaryDetectionDistance) {
                  particles::contact::updateContacts(
                      contactContainer, iP, solidBoundaryID, PhysR<T, D>(physR),
                      particle, cellMin, cellMax, getSetupPeriodicity, deltaX);
                }
                ++solidBoundaryID;
              }
            }
          }
        }
      });
}

References olb::particles::dynamics::calculateLocalVelocity(), olb::particles::contact::evalCircumRadius(), olb::particles::contact::evalContactDetectionDistance(), olb::sdf::evalSolidVolumeFraction(), forSpatialLocationsInBlockParticleIntersection(), olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), olb::BlockLattice< T, DESCRIPTOR >::get(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getExtent(), olb::getLatticeMaterials(), olb::UnitConverter< T, DESCRIPTOR >::getLatticeVelocity(), olb::BlockGeometry< T, D >::getMaterial(), olb::BlockStructureD< D >::getPadding(), olb::BlockGeometry< T, D >::getPhysR(), olb::particles::access::isContactComputationEnabled(), olb::util::nearZero(), olb::particles::access::providesParallelization(), olb::particles::resolved::signedDistanceToParticle(), olb::particles::ParticleSystem< T, PARTICLETYPE >::size(), olb::util::sqrt(), and olb::particles::contact::updateContacts().

Here is the call graph for this function:

setSuperParticleField() [1/2]

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , typename WALLCONTACTTYPE , typename F >

void olb::particles::setSuperParticleField	(	const SuperGeometry< T, DESCRIPTOR::d > &	sGeometry,
		const PhysR< T, DESCRIPTOR::d > &	min,
		const PhysR< T, DESCRIPTOR::d > &	max,
		SuperLattice< T, DESCRIPTOR > &	sLattice,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		contact::ContactContainer< T, PARTICLECONTACTTYPE, WALLCONTACTTYPE > &	particleContacts,
		size_t	iP,
		Particle< T, PARTICLETYPE > &	particle,
		std::vector< SolidBoundary< T, DESCRIPTOR::d > > &	solidBoundaries,
		F	getSetupPeriodicity,
		int	globiC = -1 )

Definition at line 60 of file superLatticeInteraction.hh.

{
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    if(globaliC == sLattice.getLoadBalancer().glob(iC)
        || !particles::access::providesParallelization<PARTICLETYPE>()) {
      if constexpr ( isPeriodic(getSetupPeriodicity()) ) {
        setBlockParticleField( sGeometry.getBlockGeometry(iC),
                               sLattice.getBlock(iC), converter, min, max,
                               particleSystem, contactContainer, iP,
                               particle, solidBoundaries, getSetupPeriodicity);
      }
      else {
        setBlockParticleField( sGeometry.getBlockGeometry(iC),
            sLattice.getBlock(iC), converter, particleSystem, contactContainer,
            iP, particle, solidBoundaries);
      }
    }
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperGeometry< T, D >::getBlockGeometry(), olb::SuperStructure< T, D >::getLoadBalancer(), isPeriodic(), and setBlockParticleField().

Here is the call graph for this function:

setSuperParticleField() [2/2]

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

void olb::particles::setSuperParticleField	(	const SuperGeometry< T, DESCRIPTOR::d > &	sGeometry,
		SuperLattice< T, DESCRIPTOR > &	sLattice,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		Particle< T, PARTICLETYPE > &	particle,
		const Vector< bool, DESCRIPTOR::d > &	periodicity )

Set particle field with peridic support.

Definition at line 34 of file superLatticeInteraction.hh.

{
  constexpr unsigned D = DESCRIPTOR::d;
  const PhysR<T,D> min = communication::getCuboidMin<T,D>(sGeometry.getCuboidGeometry());
  const PhysR<T,D> max = communication::getCuboidMax<T,D>(sGeometry.getCuboidGeometry(), min);
 
 
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    if ( isPeriodic(periodicity) ) {
      setBlockParticleField( sGeometry.getBlockGeometry(iC),
                           sLattice.getBlock(iC), converter, min, max,
                           particle, periodicity);
    }
    else {
      setBlockParticleField( sGeometry.getBlockGeometry(iC),
                           sLattice.getBlock(iC), converter, particle);
    }
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperGeometry< T, D >::getBlockGeometry(), olb::SuperStructure< T, D >::getCuboidGeometry(), olb::SuperStructure< T, D >::getLoadBalancer(), isPeriodic(), and setBlockParticleField().

Here is the call graph for this function:

Here is the caller graph for this function: