olb::particles::dynamics::ParticleManager< T, DESCRIPTOR, PARTICLETYPE > Class Template Reference

#include <particleManager.h>

Collaboration diagram for olb::particles::dynamics::ParticleManager< T, DESCRIPTOR, PARTICLETYPE >:

Public Member Functions
	ParticleManager (XParticleSystem< T, PARTICLETYPE > &xParticleSystem, SuperGeometry< T, DESCRIPTOR::d > &sGeometry, SuperLattice< T, DESCRIPTOR > &sLattice, UnitConverter< T, DESCRIPTOR > const &converter, Vector< T, PARTICLETYPE::d > externalAcceleration=Vector< T, PARTICLETYPE::d >(0.), Vector< bool, PARTICLETYPE::d > periodic=Vector< bool, PARTICLETYPE::d >(false))
template<typename ... TASKLIST>
void	execute (T timeStepSize)
template<typename ... TASKLIST>
void	execute ()
const communication::ParticleCommunicator &	getParticleCommunicator ()
void	setExternalAcceleration (const Vector< T, PARTICLETYPE::d > &externalAcceleration)
	Set external acceleration.

Detailed Description

template<typename T, typename DESCRIPTOR, typename PARTICLETYPE>
class olb::particles::dynamics::ParticleManager< T, DESCRIPTOR, PARTICLETYPE >

Definition at line 42 of file particleManager.h.

Constructor & Destructor Documentation

ParticleManager()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

olb::particles::dynamics::ParticleManager< T, DESCRIPTOR, PARTICLETYPE >::ParticleManager	(	XParticleSystem< T, PARTICLETYPE > &	xParticleSystem,
		SuperGeometry< T, DESCRIPTOR::d > &	sGeometry,
		SuperLattice< T, DESCRIPTOR > &	sLattice,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		Vector< T, PARTICLETYPE::d >	externalAcceleration = Vector<T,PARTICLETYPE::d>(0.),
		Vector< bool, PARTICLETYPE::d >	periodic = Vector<bool,PARTICLETYPE::d>(false) )

Definition at line 39 of file particleManager.hh.

   : _xParticleSystem(xParticleSystem), _sGeometry(sGeometry),
     _sLattice(sLattice), _converter(converter), _externalAcceleration(externalAcceleration),
     _periodic(periodic)
{}

Member Function Documentation

execute() [1/2]

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

template<typename ... TASKLIST>

void olb::particles::dynamics::ParticleManager< T, DESCRIPTOR, PARTICLETYPE >::execute

(

)

Definition at line 164 of file particleManager.hh.

{ execute<TASKLIST...>(_converter.getPhysDeltaT()); }

execute() [2/2]

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

template<typename ... TASKLIST>

void olb::particles::dynamics::ParticleManager< T, DESCRIPTOR, PARTICLETYPE >::execute

(

T

timeStepSize

)

Definition at line 86 of file particleManager.hh.

                                                                      {
#ifdef VERBOSE_PARTICLEMANAGER
      OstreamManager clout( std::cout,"ParticleManager" );
      clout << "TASKLIST:" << std::endl;
      singleton::mpi().synchronizeIO();
#endif
  //Create meta::list of TASKLIST parameter pack
  using taskList = typename meta::list<TASKLIST...>;
  //Retrieve index sequence for tasks to be executed without loop
  auto indexSequenceNoLoop =
    meta::filter_index_sequence<taskList,requires_no_loop>();
  //Define function for tasks not requiring loop
  auto executeNoLoopTask = [&](auto task){
    using TASK = typename decltype(task)::type;
#ifdef VERBOSE_PARTICLEMANAGER
      singleton::mpi().synchronizeIO();
      OstreamManager clout( std::cout,"ParticleManager" );
      if constexpr (access::providesParallelization<PARTICLETYPE>()){
        clout.setMultiOutput(true);
      }
      std::string taskStr = typeid(TASK).name();
      taskStr.resize(50);
      clout << "-Task: " << taskStr << std::endl;
      clout.setMultiOutput(false);
      singleton::mpi().synchronizeIO();
#endif
    if constexpr(TASK::latticeCoupling){
      TASK::execute( _xParticleSystem, _sGeometry, _sLattice, _converter, _periodic );
    } else {
      if constexpr (std::is_invocable_v<decltype(TASK::execute),
        XParticleSystem<T,PARTICLETYPE>&, const T,
        const communication::ParticleCommunicator&,
        const Vector<bool,PARTICLETYPE::d>&>)
      {
        TASK::execute( _xParticleSystem, _converter.getPhysDeltaX(),
            _communicator, _periodic);
      }
      else {
        TASK::execute( _xParticleSystem, _communicator);
      }
    }
#ifdef VERBOSE_PARTICLEMANAGER
      singleton::mpi().synchronizeIO(1000);
#endif
  };
  //Define function for sequence of tasks requiring loop
  auto executeLoopedTasks = [&](auto indexSequence){
    if constexpr( access::providesParallelization<PARTICLETYPE>() ){
      //Loop over valid particles
      communication::forParticlesInSuperParticleSystem<T,PARTICLETYPE,
        conditions::valid_particles>( _xParticleSystem,
        [&](Particle<T,PARTICLETYPE>& particle,
        ParticleSystem<T,PARTICLETYPE>& particleSystem, int globiC){
        //Unpack tasks to be looped
        unpackTasksLooped<taskList>( particle, timeStepSize, indexSequence, globiC );
      });
    } else {
      //Loop over all particles
      forParticlesInParticleSystem<T,PARTICLETYPE,conditions::all_particles>( _xParticleSystem,
        [&](Particle<T,PARTICLETYPE>& particle){
        //Unpack tasks to be looped
        unpackTasksLooped<taskList>( particle, timeStepSize, indexSequence, 0 );
      });
    }
   };
   //Evaluate index sequence and evaluate tasks or tasks sequences
   //- Example execution:
   //   Direct: T1
   //   Looped: [T2,T3,T4] (iterate taks for same particle)
   //   Direct: T5
   //   Direct: T6
   //   Looped: [T7,T8]    (iterate taks for same particle)
   meta::index_sequence_for_subsequence<taskList>(
    executeNoLoopTask, executeLoopedTasks, indexSequenceNoLoop);
}

References olb::meta::filter_index_sequence(), olb::particles::forParticlesInParticleSystem(), olb::particles::communication::forParticlesInSuperParticleSystem(), olb::meta::index_sequence_for_subsequence(), olb::singleton::mpi(), olb::particles::access::providesParallelization(), olb::OstreamManager::setMultiOutput(), and olb::singleton::MpiManager::synchronizeIO().

Here is the call graph for this function:

getParticleCommunicator()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

const communication::ParticleCommunicator & olb::particles::dynamics::ParticleManager< T, DESCRIPTOR, PARTICLETYPE >::getParticleCommunicator

(

)

Definition at line 167 of file particleManager.hh.

                                                                                                            {
  return _communicator;
}

setExternalAcceleration()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

void olb::particles::dynamics::ParticleManager< T, DESCRIPTOR, PARTICLETYPE >::setExternalAcceleration

(

const Vector< T, PARTICLETYPE::d > &

externalAcceleration

)

Set external acceleration.

Definition at line 172 of file particleManager.hh.

{
  _externalAcceleration = externalAcceleration;
}

---

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

• src/particles/particleManager.h
• src/particles/particleManager.hh