Functor that returns forces acting on a particle surface, returns data in output for every particle in a row(described are return values for the first particle). More...

#include <latticeMomentumExchangeForce.h>

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

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

Public Member Functions
	BlockLatticeMomentumExchangeForce (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 = true

Detailed Description

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

Functor that returns forces acting on a particle surface, returns data in output for every particle in a row(described are return values for the first particle).

Returns: output[0]-output[2] translational force - physical units; output[3]-output[5] torque - physical units; output[7] number of voxels

Definition at line 50 of file latticeMomentumExchangeForce.h.

Constructor & Destructor Documentation

◆ BlockLatticeMomentumExchangeForce()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

olb::BlockLatticeMomentumExchangeForce< T, DESCRIPTOR, PARTICLETYPE >::BlockLatticeMomentumExchangeForce	(	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 86 of file latticeMomentumExchangeForce.hh.

  : BlockLatticePhysF<T,DESCRIPTOR>(blockLattice, converter,
                                   (DESCRIPTOR::d+utilities::dimensions::convert<DESCRIPTOR::d>::rotation+1)*(particleSystem.size()-iP0)),
    _blockGeometry(blockGeometry), _blockLattice(blockLattice),
    _particleSystem(particleSystem),
    _cellMin(cellMin), _cellMax(cellMax), _periodic(periodic),
    _iP0(iP0), _ignoredMaterials(ignoredMaterials), _f(f)
{
  this->getName() = "physMomentumExchangeForce";
}

References olb::getName().

Here is the call graph for this function:

Member Function Documentation

◆ evaluate()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

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

Definition at line 105 of file latticeMomentumExchangeForce.hh.

{
  constexpr unsigned D = DESCRIPTOR::d;
  constexpr unsigned Drot = utilities::dimensions::convert<D>::rotation; //TODO: prevent rotation calculatiion, when no angle
  constexpr int serialSize = D+Drot+1;
 
  using namespace descriptors;
  const PhysR<T, D> position = particles::access::getPosition(particle);
  const T circumRadius = particles::access::getRadius(particle);
 
  //For all cells in block particle intersection
  int numVoxels = 0;
  constexpr int padding = 0;
  const std::size_t iPeval = iP - _iP0; //Shifted output index, if iP!=0
  particles::forSpatialLocationsInBlockParticleIntersection( _blockGeometry,
      _blockLattice, padding, position, circumRadius,
  [&](const LatticeR<D>& latticeRinner) {
 
    if (_ignoredMaterials.find(_blockGeometry.getMaterial(latticeRinner)) == _ignoredMaterials.end()) {
      Vector<T,D>tmpForce(0.);
      PhysR<T,D> lever(0.);
      if ( particles::resolved::momentumExchangeAtSurfaceLocation(tmpForce.data(),
            lever, latticeRinner, this->_blockGeometry,
            this->_blockLattice, this->_converter, particle) ){
 
        // count cells of considered object
        ++numVoxels;
 
        //Shift centre of mass (for oblique rotation) if offset provided
        if constexpr ( PARTICLETYPE::template providesNested<SURFACE,COR_OFFSET>() ){
          lever -= Vector<T,D> ( particle.template getField<SURFACE,COR_OFFSET>() );
        }
 
        //Calculate torque
        const Vector<T,Drot> torque = particles::dynamics::torque_from_force<D,T>::calculate( tmpForce, lever );
 
        Vector<T,D> physRv;
        this->_blockGeometry.getPhysR(physRv, latticeRinner);
        _f(particle, physRv.data(), tmpForce, torque);
 
        //Add force and torque to output
        for (unsigned iDim=0; iDim<D; ++iDim) {
          output[iDim+iPeval*serialSize] += tmpForce[iDim];
        }
        for (unsigned iRot=0; iRot<Drot; ++iRot) {
          output[(iRot+D)+iPeval*serialSize] += torque[iRot];
        }
      }
    }
  });
 
  output[D+Drot+iPeval*serialSize] += numVoxels;
}

References olb::particles::dynamics::torque_from_force< D, T >::calculate(), olb::Vector< T, Size >::data(), olb::particles::forSpatialLocationsInBlockParticleIntersection(), olb::particles::access::getPosition(), olb::particles::access::getRadius(), and olb::particles::resolved::momentumExchangeAtSurfaceLocation().

Here is the call graph for this function:

◆ operator()()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

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

override

Definition at line 160 of file latticeMomentumExchangeForce.hh.

{
  constexpr unsigned D = DESCRIPTOR::d;
 
  using namespace descriptors;
 
  //Evaluate periodicity
  bool anyPeriodic = false;
  for (unsigned iDim=0; iDim<D; ++iDim) {
    anyPeriodic = anyPeriodic || _periodic[iDim];
  }
 
  // iterate over all particles in _particleSystem
  for (std::size_t iP=_iP0; iP!=_particleSystem.size(); ++iP) {
    auto particle = _particleSystem.get(iP);
    if (particles::access::isValid(particle)){
      // If any direction requires periodic treatment
      if (anyPeriodic) {
        const T circumRadius = particles::access::getRadius(particle);
        const PhysR<T,D> position = particles::access::getPosition(particle);
 
        bool surfaceOutOfGeometry = false;
        PhysR<T,D> ghostPos;
        particles::checkSmoothIndicatorOutOfGeometry(surfaceOutOfGeometry, ghostPos,
          _cellMin, _cellMax, position, circumRadius, _periodic);
 
        if (!surfaceOutOfGeometry) {
          evaluate(output, particle, iP);
        }
        else {
          // Calculate force for the ghost particle
          particle.template setField<GENERAL,POSITION>(ghostPos);
          evaluate(output, particle, iP);
          // Calculate force of actual particle
          particle.template setField<GENERAL,POSITION>(position);
          evaluate(output, particle, iP);
        }
      }
      else {
        evaluate(output, particle, iP);
      }
    }
  }
  return true;
}