Velocity verlet particle dynamics with deposition modelling by checking domain bounds in cartesion direcion. More...

#include <particleDynamicsBase.h>

Inheritance diagram for olb::particles::dynamics::VerletParticleDynamicsCubicBoundsDeposition< T, PARTICLETYPE, DEPOSITION_MODEL >:

Collaboration diagram for olb::particles::dynamics::VerletParticleDynamicsCubicBoundsDeposition< T, PARTICLETYPE, DEPOSITION_MODEL >:

Public Member Functions
	VerletParticleDynamicsCubicBoundsDeposition (PhysR< T, PARTICLETYPE::d > &domainMin, PhysR< T, PARTICLETYPE::d > &domainMax, DEPOSITION_MODEL &depositionModel)
	Constructor.

void	process (Particle< T, PARTICLETYPE > &particle, T timeStepSize) override
	Procesisng step.

Public Member Functions inherited from olb::particles::dynamics::ParticleDynamics< T, PARTICLETYPE >
virtual	~ParticleDynamics ()
	Destructor: virtual to enable inheritance.

std::string &	getName ()
	read and write access to name

std::string const &	getName () const
	read only access to name

Detailed Description

template<typename T, typename PARTICLETYPE, typename DEPOSITION_MODEL>
class olb::particles::dynamics::VerletParticleDynamicsCubicBoundsDeposition< T, PARTICLETYPE, DEPOSITION_MODEL >

Velocity verlet particle dynamics with deposition modelling by checking domain bounds in cartesion direcion.

Definition at line 295 of file particleDynamicsBase.h.

Constructor & Destructor Documentation

◆ VerletParticleDynamicsCubicBoundsDeposition()

template<typename T , typename PARTICLETYPE , typename DEPOSITION_MODEL >

olb::particles::dynamics::VerletParticleDynamicsCubicBoundsDeposition< T, PARTICLETYPE, DEPOSITION_MODEL >::VerletParticleDynamicsCubicBoundsDeposition	(	PhysR< T, PARTICLETYPE::d > &	domainMin,
		PhysR< T, PARTICLETYPE::d > &	domainMax,
		DEPOSITION_MODEL &	depositionModel )

Constructor.

Definition at line 529 of file particleDynamicsBase.hh.

  : _domainMin(domainMin), _domainMax(domainMax),
    _depositionModel( depositionModel )
{
  this->getName() = "VerletParticleDynamicsCubicBoundsDeposition";
}

References olb::particles::dynamics::ParticleDynamics< T, PARTICLETYPE >::getName().

Here is the call graph for this function:

Member Function Documentation

◆ process()

template<typename T , typename PARTICLETYPE , typename DEPOSITION_MODEL >

void olb::particles::dynamics::VerletParticleDynamicsCubicBoundsDeposition< T, PARTICLETYPE, DEPOSITION_MODEL >::process	(	Particle< T, PARTICLETYPE > &	particle,
		T	timeStepSize )

overridevirtual

Procesisng step.

Implements olb::particles::dynamics::ParticleDynamics< T, PARTICLETYPE >.

Definition at line 543 of file particleDynamicsBase.hh.

{
  using namespace particles::access;
  static_assert( providesActive<PARTICLETYPE>(), "Field ACTIVE has to be provided");
 
  //Check if active
  if (particle.template getField<descriptors::DYNBEHAVIOUR,descriptors::ACTIVE>()) {
 
    auto force = getForce( particle );
    auto velocity = getVelocity( particle );
 
    //Check domain contact and check deposition
    bool deposition = false;
    doAtCubicBoundPenetration( particle, _domainMin, _domainMax,
    [&](unsigned iDim, Vector<T,PARTICLETYPE::d>& normal, T distToBound ) {
      //Check deposition
      deposition = deposition || _depositionModel.checkDeposition(velocity,normal);
      //Wall contact treatment
      if (!deposition) {
        auto radius = getRadius( particle );
        T penetrationDepth = -distToBound;
        T velNormal = -normal[iDim]*velocity[iDim]; //Necessary for damping
        T forceNormal = _depositionModel.contactForceSphereHalfSpaceDampened(
                          radius, penetrationDepth, velNormal );
        force[iDim] = forceNormal*normal[iDim];
      }
    });
    particle.template setField<descriptors::FORCING,descriptors::FORCE>( force );
 
    //Run verlet or deactivate depending on deposition
    if (!deposition) {
      //Calculate acceleration
      auto acceleration = getAcceleration( particle );
      //Note position before calculating movement
      auto positionPre = getPosition( particle );
      //Check for angular components
      if constexpr ( providesAngle<PARTICLETYPE>() ) {
        //Calculate angular acceleration
        auto angularAcceleration = getAngAcceleration( particle );
        //Verlet algorithm
        particles::dynamics::velocityVerletIntegration>(
          particle, timeStepSize, acceleration, angularAcceleration );
        //Update rotation matrix
        updateRotationMatrix( particle );
      }
      else {
        //Verlet algorithm without angle
        particles::dynamics::velocityVerletIntegration>(
          particle, timeStepSize, acceleration );
      }
    }
    else {
      particle.template setField<descriptors::DYNBEHAVIOUR,descriptors::ACTIVE>( false );
      particle.template setField<descriptors::MOBILITY,descriptors::VELOCITY>( 0. );
      particle.template setField<descriptors::MOBILITY,descriptors::ACCELERATION_STRD>( 0. );
      if constexpr ( providesAngle<PARTICLETYPE>() ) {
        particle.template setField<descriptors::MOBILITY,descriptors::ANG_VELOCITY>( 0. );
        particle.template setField<descriptors::MOBILITY,descriptors::ANG_ACC_STRD>( 0. );
      }
    }
  }
}

References olb::particles::dynamics::doAtCubicBoundPenetration(), olb::particles::dynamics::updateRotationMatrix(), and olb::particles::dynamics::velocityVerletIntegration().