olb::BlockLatticeStokesDragForce< T, DESCRIPTOR, PARTICLETYPE, serialize > Class Template Reference

#include <latticeStokesDragForce.h>

Inheritance diagram for olb::BlockLatticeStokesDragForce< T, DESCRIPTOR, PARTICLETYPE, serialize >:

Collaboration diagram for olb::BlockLatticeStokesDragForce< T, DESCRIPTOR, PARTICLETYPE, serialize >:

Public Member Functions
	BlockLatticeStokesDragForce (BlockLattice< T, DESCRIPTOR > &blockLattice, const BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, particles::ParticleSystem< T, PARTICLETYPE > &particleSystem, const UnitConverter< T, DESCRIPTOR > &converter, PhysR< T, DESCRIPTOR::d > cellMin=PhysR< T, DESCRIPTOR::d >(0.), PhysR< T, DESCRIPTOR::d > cellMax=PhysR< T, DESCRIPTOR::d >(0.), Vector< bool, DESCRIPTOR::d > periodic=Vector< bool, DESCRIPTOR::d >(false), std::size_t iP0=0, const std::set< int > &ignoredMaterials=std::set< int >{}, const F f=[](auto &, const auto &, const auto &, const auto &){})
void	evaluate (T output[], particles::Particle< T, PARTICLETYPE > &particle, int iP)
bool	operator() (T output[], const int input[]) override

Static Public Attributes
static constexpr bool	serializeForce = serialize

Detailed Description

template<typename T, typename DESCRIPTOR, typename PARTICLETYPE, bool serialize = true>
class olb::BlockLatticeStokesDragForce< T, DESCRIPTOR, PARTICLETYPE, serialize >

Definition at line 39 of file latticeStokesDragForce.h.

Constructor & Destructor Documentation

BlockLatticeStokesDragForce()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE , bool serialize>

olb::BlockLatticeStokesDragForce< T, DESCRIPTOR, PARTICLETYPE, serialize >::BlockLatticeStokesDragForce	(	BlockLattice< T, DESCRIPTOR > &	blockLattice,
		const BlockGeometry< T, DESCRIPTOR::d > &	blockGeometry,
		particles::ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		const UnitConverter< T, DESCRIPTOR > &	converter,
		PhysR< T, DESCRIPTOR::d >	cellMin = PhysR<T,DESCRIPTOR::d> (0.),
		PhysR< T, DESCRIPTOR::d >	cellMax = PhysR<T,DESCRIPTOR::d> (0.),
		Vector< bool, DESCRIPTOR::d >	periodic = Vector<bool,DESCRIPTOR::d> (false),
		std::size_t	iP0 = 0,
		const std::set< int > &	ignoredMaterials = std::set<int>{},
		const F	f = [](auto&, const auto&, const auto&, const auto&){} )

Definition at line 33 of file latticeStokesDragForce.hh.

  : BlockLatticePhysF<T,DESCRIPTOR>(blockLattice, converter,
                                   (DESCRIPTOR::d)*(particleSystem.size()-iP0)),
    _blockGeometry(blockGeometry), _blockLattice(blockLattice),
    _particleSystem(particleSystem),
    _cellMin(cellMin), _cellMax(cellMax), _periodic(periodic),
    _iP0(iP0), _ignoredMaterials(ignoredMaterials), _f(f)
{
  this->getName() = "physStokesDragForce";
  //Calculate precalculated constants
  _delTinv = 1./this->_converter.getPhysDeltaT();
  _C1 = 6. * M_PI
           * converter.getPhysViscosity()
           * converter.getPhysDensity()
           * converter.getConversionFactorTime();
}

References olb::UnitConverter< T, DESCRIPTOR >::getConversionFactorTime(), olb::getName(), olb::UnitConverter< T, DESCRIPTOR >::getPhysDensity(), olb::UnitConverter< T, DESCRIPTOR >::getPhysViscosity(), and M_PI.

Here is the call graph for this function:

Member Function Documentation

evaluate()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE , bool serialize>

void olb::BlockLatticeStokesDragForce< T, DESCRIPTOR, PARTICLETYPE, serialize >::evaluate	(	T	output[],
		particles::Particle< T, PARTICLETYPE > &	particle,
		int	iP )

Definition at line 60 of file latticeStokesDragForce.hh.

{
  constexpr unsigned D = DESCRIPTOR::d;
  const int serialSize = D;
 
  using namespace descriptors;
 
  //Retrieve particle quantities
  Vector<T,D> position = particle.template getField<GENERAL,POSITION>();
  Vector<T,D> velocity = particle.template getField<MOBILITY,VELOCITY>();
  T radius = particle.template getField<PHYSPROPERTIES,RADIUS>();
  T mass = particle.template getField<PHYSPROPERTIES,MASS>();
  T* positionArray = position.data();
 
  //TODO: check, whether creation can be avoided by using a second _blockF list
  const auto& cuboid = _blockGeometry.getCuboid();
  BlockLatticeInterpPhysVelocity<T,DESCRIPTOR> blockInterpPhysVelF(
    _blockLattice, this->_converter, cuboid);
 
  //Calculate particle coefficiants
  T c = _C1 * radius * 1./mass;
  T C2 = 1. / (1. + c);
 
  T fluidVelArray[D] = {0.};
 
  //Check whether inside cuboid (when not parallelized)
  bool inside = true;
  if constexpr ( !particles::access::providesParallelization<PARTICLETYPE>() ){
    inside = cuboid.isInside(position);
  }
  if (inside){
 
    //Retrieve interpolated velocity at position
    blockInterpPhysVelF(fluidVelArray, positionArray);
 
    //Record interpolated fluid field, if MOBILITY,FLUIDVEL provided
    if constexpr( PARTICLETYPE::template providesNested<MOBILITY,FLUIDVEL>() ){
      particle.template setField<MOBILITY, FLUIDVEL>(fluidVelArray);
    }
 
    //Calculate stokes force
    Vector<T,D> tmpForce(0.);
    for (int iDim = 0; iDim < PARTICLETYPE::d; ++iDim) {
      tmpForce[iDim] = mass * _delTinv
        * ((c * fluidVelArray[iDim] + velocity[iDim]) * C2 - velocity[iDim]);
    }
 
    _f(particle, position, tmpForce, Vector<T,utilities::dimensions::convert<D>::rotation>(T{0}));
 
    //Add force and torque to output or apply directly
    //INFO: serialization only possible to provide analogy to momentumExchange!
    if constexpr (serialize){
      std::size_t iPeval = iP-_iP0; //Shifted output index, if iP!=0
      for (unsigned iDim=0; iDim<D; iDim++) {
        output[iDim+iPeval*serialSize] += tmpForce[iDim];
      }
    } else {
      //Apply tmpForce as absolute force (no increment, as no empty output[] available)
      particle.template setField<FORCING,FORCE>( tmpForce );
    }
  }
}

References olb::Vector< T, Size >::data(), and olb::particles::access::providesParallelization().

Here is the call graph for this function:

operator()()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE , bool serialize>

bool olb::BlockLatticeStokesDragForce< T, DESCRIPTOR, PARTICLETYPE, serialize >::operator() ( T output[], const int input[] )

override

Definition at line 127 of file latticeStokesDragForce.hh.

{
  using namespace descriptors;
  // iterate over all particles in _indicator //TODO: add periodic treatment analogous to momentum exchange
  for (std::size_t iP=_iP0; iP!=_particleSystem.size(); iP++) {
    auto particle = _particleSystem.get(iP);
    if (particles::access::isValid(particle)){
      evaluate(output, particle, iP);
    }
  }
  return true;
}

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

Here is the call graph for this function:

Member Data Documentation

serializeForce

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE , bool serialize = true>

bool olb::BlockLatticeStokesDragForce< T, DESCRIPTOR, PARTICLETYPE, serialize >::serializeForce = serialize

staticconstexpr

Definition at line 69 of file latticeStokesDragForce.h.

---

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

• src/functors/lattice/latticeStokesDragForce.h
• src/functors/lattice/latticeStokesDragForce.hh