olb::particles::subgrid Namespace Reference

Functions
template<typename T , typename PARTICLETYPE , typename DESCRIPTOR >
void	initializeParticleVelocity (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, UnitConverter< T, DESCRIPTOR > const &converter, SuperParticleSystem< T, PARTICLETYPE > &supParticleSystem)
template<typename T , typename PARTICLETYPE >
void	addParticles (SuperParticleSystem< T, PARTICLETYPE > &supParticleSystem, IndicatorF3D< T > &ind, T partRho, T radius, const std::size_t noOfParticles, util::Randomizer< T > &randomizer)
template<typename T , typename PARTICLETYPE , bool verbose = true>
void	captureStatistics (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, SuperIndicatorMaterial< T, PARTICLETYPE::d > &materialIndicatorOutput, std::size_t &noActive, std::size_t reprParticleID=0)

Function Documentation

addParticles()

template<typename T , typename PARTICLETYPE >

void olb::particles::subgrid::addParticles	(	SuperParticleSystem< T, PARTICLETYPE > &	supParticleSystem,
		IndicatorF3D< T > &	ind,
		T	partRho,
		T	radius,
		const std::size_t	noOfParticles,
		util::Randomizer< T > &	randomizer )

Definition at line 75 of file subgridUtilities.h.

{
  Vector<T,3> pos(0.);
  std::size_t noP = 0;
  while (noP<noOfParticles){
    //Generate randomized position
       pos[0] = ind.getMin()[0]
         + randomizer.generate() * (ind.getMax()[0] - ind.getMin()[0]);
       pos[1] = ind.getMin()[1]
         + randomizer.generate() * (ind.getMax()[1] - ind.getMin()[1]);
       pos[2] = ind.getMin()[2]
         + randomizer.generate() * (ind.getMax()[2] - ind.getMin()[2]);
    //Call sub-grid creator if in indicator domain
    bool inside[1] = { false };
    ind(inside, pos.data());
    if (inside[0]){
      creators::addSubgridSphere3D( supParticleSystem, pos, radius, partRho );
      noP++;
    }
  }
}

References olb::particles::creators::addSubgridSphere3D(), olb::Vector< T, D >::data(), olb::util::Randomizer< T, useStored >::generate(), olb::IndicatorF3D< S >::getMax(), and olb::IndicatorF3D< S >::getMin().

Here is the call graph for this function:

captureStatistics()

template<typename T , typename PARTICLETYPE , bool verbose = true>

void olb::particles::subgrid::captureStatistics	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		SuperIndicatorMaterial< T, PARTICLETYPE::d > &	materialIndicatorOutput,
		std::size_t &	noActive,
		std::size_t	reprParticleID = 0 )

Definition at line 104 of file subgridUtilities.h.

{
  noActive = 0;
  std::size_t noFound = 0;
  std::size_t noExcaped = 0;
  communication::forParticlesInSuperParticleSystem(sParticleSystem,
    [&](Particle<T,PARTICLETYPE>& particle,
      ParticleSystem<T,PARTICLETYPE>& particleSystem, int globiC){
    //Check activity
    bool active = access::isActive(particle);
    if (active){
      noActive++;
      //Check whether representative particle and potentially print
      std::size_t globalId = access::getGlobalID(particle);
      if constexpr (verbose){
        if (globalId==reprParticleID){
          particles::io::printSubgridParticleInfo( particle );
        }
      }
    }
    //Check individual material vicinities
    bool outputVicinity = boundaries::checkMaterialVicinity(
      materialIndicatorOutput, particle );
    if (outputVicinity){ noExcaped++; }
    //Increase particle counter
    noFound++;
  });
  singleton::mpi().reduceAndBcast(noActive, MPI_SUM);
  singleton::mpi().reduceAndBcast(noFound, MPI_SUM);
  singleton::mpi().reduceAndBcast(noExcaped, MPI_SUM);
 
  //Calculate escape and capture rate
  T escapeRate = T(noExcaped)/T(noFound);
  T captureRate = 1.-escapeRate;
 
  //Output
  if constexpr (verbose){
    OstreamManager clout( std::cout, "captureStatistics" );
    clout << "globalNumOfParticles=" << noFound;
    clout << "; activeParticles=" << noActive;
    clout << "; escapedParticles=" << noExcaped << std::endl;
    clout << "captureRate=" << captureRate << "; escapeRate=" << escapeRate;
    clout << std::endl;
  }
}

References olb::particles::boundaries::checkMaterialVicinity(), olb::particles::communication::forParticlesInSuperParticleSystem(), olb::particles::access::getGlobalID(), olb::particles::access::isActive(), olb::singleton::mpi(), olb::particles::io::printSubgridParticleInfo(), and olb::singleton::MpiManager::reduceAndBcast().

Here is the call graph for this function:

initializeParticleVelocity()

template<typename T , typename PARTICLETYPE , typename DESCRIPTOR >

void olb::particles::subgrid::initializeParticleVelocity	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, DESCRIPTOR::d > &	superGeometry,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		SuperParticleSystem< T, PARTICLETYPE > &	supParticleSystem )

Definition at line 40 of file subgridUtilities.h.

{
  using namespace descriptors;
  constexpr unsigned D = DESCRIPTOR::d;
  // Iterate over individual particle systems
  communication::forSystemsInSuperParticleSystem( supParticleSystem,
    [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
    // Retrieve block quantities
    auto& blockLattice = sLattice.getBlock(iC);
    auto& blockGeometry = superGeometry.getBlockGeometry(iC);
    const auto& cuboid = blockGeometry.getCuboid();
    // Create block velocity interpolation functor
    BlockLatticeInterpPhysVelocity<T,DESCRIPTOR> blockInterpPhysVelF(
      blockLattice, converter, cuboid);
    // Loop over all particles in particle system
    forParticlesInParticleSystem<T,PARTICLETYPE>( particleSystem,
      [&](Particle<T,PARTICLETYPE>& particle){
      // Retrieve particle position
      Vector<T,D> position = particle.template getField<GENERAL,POSITION>();
      // Calculate interpolated velocity
      Vector<T,D> fluidVel(0.);
      blockInterpPhysVelF(fluidVel.data(), position.data());
      //Apply velocity to particle
      particle.template setField<MOBILITY,VELOCITY>( fluidVel );
    });
  });
}

References olb::Vector< T, D >::data(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperGeometry< T, D >::getBlockGeometry().

Here is the call graph for this function: