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

#include <latticeTranCongDragForce.h>

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

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

Public Member Functions
	BlockLatticeTranCongDragForce (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::BlockLatticeTranCongDragForce< T, DESCRIPTOR, PARTICLETYPE >

Definition at line 47 of file latticeTranCongDragForce.h.

Constructor & Destructor Documentation

BlockLatticeTranCongDragForce()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

olb::BlockLatticeTranCongDragForce< T, DESCRIPTOR, PARTICLETYPE >::BlockLatticeTranCongDragForce	(	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 31 of file latticeTranCongDragForce.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() = "physTranCongDragForce";
}

References olb::getName().

Here is the call graph for this function:

Member Function Documentation

evaluate()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

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

Definition at line 49 of file latticeTranCongDragForce.hh.

{
  constexpr unsigned Dd = DESCRIPTOR::d;
  const int serialSize = Dd;
  using namespace descriptors;
    static_assert(PARTICLETYPE::template providesNested<MOBILITY, FLUIDVEL>(), "Field MOBILITY:FLUIDVEL has to be provided");
 
  //Retrieve particle quantities
  Vector<T,Dd> position = particle.template getField<GENERAL,POSITION>();
  Vector<T,Dd> 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 = particle.template getField<PHYSPROPERTIES,DENSITY>();;
 
  T fluidVelArray[Dd] = {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 = util::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]));
 
  Vector<T,Dd> direction  ((velocity[0]-fluidVelArray[0])/relVel,(velocity[1]-fluidVelArray[1])/relVel,(velocity[2]-fluidVelArray[2])/relVel);
 T Re_p = relVel*2*radius/this->_converter.getPhysViscosity();//needed
 T C_d;
  if (Re_p < 0.000001)
   C_d = 0.;
  else
   C_d = 24./Re_p*particle.template getField<NUMERICPROPERTIES, DA_DN>()*(1.+0.15/util::sqrt(particle.template getField<NUMERICPROPERTIES,CIRCULARITY>())*util::pow(particle.template getField<NUMERICPROPERTIES, DA_DN>()*Re_p,0.687))+
 (0.42*particle.template getField<NUMERICPROPERTIES, DA_DN>()*particle.template getField<NUMERICPROPERTIES, DA_DN>())/(util::sqrt(particle.template getField<NUMERICPROPERTIES, CIRCULARITY>())*(1+4.25*10000*util::pow(particle.template getField<NUMERICPROPERTIES,DA_DN>()*Re_p,-1.16)));
 
 
    //Calculate TranCong force
    T tmpForce[Dd] = {0.};
    for (int iDim = 0; iDim < PARTICLETYPE::d; ++iDim) {
      tmpForce[iDim] =-C_d*particle.template getField<NUMERICPROPERTIES, PROJECTED_SURFACE>()*this->_converter.getPhysDensity()*relVel*relVel*direction[iDim];
 
    }
    particle.template setField<FORCING,FORCE> (tmpForce);
  }
}

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

Here is the call graph for this function:

operator()()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

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

override

Definition at line 108 of file latticeTranCongDragForce.hh.

{
  using namespace descriptors;
  using namespace particles;
  // iterate over all particles in _indicator //TODO: add periodic treatment analogous to momentum exchange
 
      forParticlesInParticleSystem<T,PARTICLETYPE,conditions::valid_particles>( _particleSystem,
      [&](Particle<T,PARTICLETYPE>& particle){
 
      evaluate(output, particle, particle.getId());
 
 
    });
  return true;
}

Member Data Documentation

serializeForce

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

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

staticconstexpr

Definition at line 67 of file latticeTranCongDragForce.h.

---

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

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