olb::BlockLatticeSchillerNaumannDragForce< T, DESCRIPTOR, PARTICLETYPE > Class Template Reference

#include <latticeSchillerNaumannDragForce.h>

Inheritance diagram for olb::BlockLatticeSchillerNaumannDragForce< T, DESCRIPTOR, PARTICLETYPE >:

Collaboration diagram for olb::BlockLatticeSchillerNaumannDragForce< T, DESCRIPTOR, PARTICLETYPE >:

Public Member Functions
	BlockLatticeSchillerNaumannDragForce (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)
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 = false

Detailed Description

template<typename T, typename DESCRIPTOR, typename PARTICLETYPE>
class olb::BlockLatticeSchillerNaumannDragForce< T, DESCRIPTOR, PARTICLETYPE >

Definition at line 47 of file latticeSchillerNaumannDragForce.h.

Constructor & Destructor Documentation

BlockLatticeSchillerNaumannDragForce()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

olb::BlockLatticeSchillerNaumannDragForce< T, DESCRIPTOR, PARTICLETYPE >::BlockLatticeSchillerNaumannDragForce	(	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 )

Definition at line 32 of file latticeSchillerNaumannDragForce.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)
{
  this->getName() = "physSchillerNaumannDragForce";
}

References olb::getName().

Here is the call graph for this function:

Member Function Documentation

evaluate()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

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

Definition at line 50 of file latticeSchillerNaumannDragForce.hh.

{
  constexpr unsigned D = DESCRIPTOR::d;
  const int serialSize = D;
 
  using namespace descriptors;
    static_assert(PARTICLETYPE::template providesNested<MOBILITY, FLUIDVEL>(), "Field MOBILITY:FLUIDVEL has to be provided");
 
  //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 general constants
  T part_density = mass/ (4./3.*M_PI*radius*radius*radius);
 
  T Coeff = 18* this->_converter.getPhysViscosity()*this->_converter.getPhysDensity()/(part_density*2*radius*2*radius);
 
  //Calculate particle coefficiants
 
 
  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);
 particle.template setField<MOBILITY, FLUIDVEL>(fluidVelArray);
 T relVel = std::sqrt((velocity[0]-fluidVelArray[0])*(velocity[0]-fluidVelArray[0])+(velocity[1]-fluidVelArray[1])*(velocity[1]-fluidVelArray[1])+(velocity[2]-fluidVelArray[2])*(velocity[2]-fluidVelArray[2]));
 
 T Re_p = relVel*2*radius/this->_converter.getPhysViscosity();
 
 T C_d;
 if (Re_p < 0.0000000001)
   C_d=0;
 else
 {
 if (Re_p <1000)
  C_d = 24./Re_p*(1+0.15*olb::util::pow(Re_p, 0.687));
 else
  C_d = 0.44;
 }
 
    //Calculate SchillerNaumann force
    T tmpForce[D] = {0.};
    for (int iDim = 0; iDim < PARTICLETYPE::d; ++iDim) {
      tmpForce[iDim] = C_d*Coeff*(fluidVelArray[iDim] - velocity[iDim])*mass/24.*Re_p;
    }
 
    particle.template setField<FORCING,FORCE> (tmpForce);
  }
}

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

Here is the call graph for this function:

operator()()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

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

override

Definition at line 118 of file latticeSchillerNaumannDragForce.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);
    evaluate(output, particle, iP);
  }
  return true;
}

Member Data Documentation

serializeForce

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

bool olb::BlockLatticeSchillerNaumannDragForce< T, DESCRIPTOR, PARTICLETYPE >::serializeForce = false

staticconstexpr

Definition at line 67 of file latticeSchillerNaumannDragForce.h.

---

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

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