Peano

Searching...

No Matches

Associate particles to spacetree vertices. More...

Inheritance diagram for peano4.toolbox.particles.api.UpdateParticleGridAssociation_LiftDrop.UpdateParticleGridAssociation_LiftDrop:

[legend]

Collaboration diagram for peano4.toolbox.particles.api.UpdateParticleGridAssociation_LiftDrop.UpdateParticleGridAssociation_LiftDrop:

[legend]

Public Member Functions
	__init__ (self, particle_set, guard="true")

	get_body_of_operation (self, operation_name)
	Core algorithm.

	get_action_set_name (self)
	Return unique action set name.

Public Member Functions inherited from peano4.toolbox.particles.api.AbstractUpdateParticleGridAssociation.AbstractUpdateParticleGridAssociation
	get_body_of_getGridControlEvents (self)

	user_should_modify_template (self)
	Is the user allowed to modify the output.

	get_includes (self)
	Inject all the default includes.

	get_constructor_body (self)
	Define a tailored constructor body.

	get_attributes (self)
	Return attributes as copied and pasted into the generated class.

	get_body_of_unprepareTraversal (self)
	Create prepareTraversal function.

Public Member Functions inherited from peano4.solversteps.ActionSet.ActionSet
	get_static_initialisations (self, full_qualified_classname)

	get_destructor_body (self)

	get_body_of_prepareTraversal (self)

Static Protected Attributes
	_Template_Sieve

Static Protected Attributes inherited from peano4.toolbox.particles.api.AbstractUpdateParticleGridAssociation.AbstractUpdateParticleGridAssociation
	_Template_BeginTraversal

	_Template_EndTraversal

	_Template_ValidateParticleLevelAssociation

	_Template_Drop

	_Template_LiftAllParticles

Static Private Attributes
	__Template_LiftOrReassignParticles

Additional Inherited Members
Data Fields inherited from peano4.toolbox.particles.api.AbstractUpdateParticleGridAssociation.AbstractUpdateParticleGridAssociation
	d

Data Fields inherited from peano4.solversteps.ActionSet.ActionSet
	descend_invocation_order

	parallel

Static Public Attributes inherited from peano4.toolbox.particles.api.AbstractUpdateParticleGridAssociation.AbstractUpdateParticleGridAssociation
int	DefaultDescendInvocationOrder = -65536

Static Public Attributes inherited from peano4.solversteps.ActionSet.ActionSet
str	OPERATION_BEGIN_TRAVERSAL = "beginTraversal"

str	OPERATION_END_TRAVERSAL = "endTraversal"

str	OPERATION_CREATE_PERSISTENT_VERTEX = "createPersistentVertex"

str	OPERATION_DESTROY_PERSISTENT_VERTEX = "destroyPersistentVertex"

str	OPERATION_CREATE_HANGING_VERTEX = "createHangingVertex"

str	OPERATION_DESTROY_HANGING_VERTEX = "destroyHangingVertex"

str	OPERATION_CREATE_PERSISTENT_FACE = "createPersistentFace"

str	OPERATION_DESTROY_PERSISTENT_FACE = "destroyPersistentFace"

str	OPERATION_CREATE_HANGING_FACE = "createHangingFace"

str	OPERATION_DESTROY_HANGING_FACE = "destroyHangingFace"

str	OPERATION_CREATE_CELL = "createCell"

str	OPERATION_DESTROY_CELL = "destroyCell"

str	OPERATION_TOUCH_VERTEX_FIRST_TIME = "touchVertexFirstTime"

str	OPERATION_TOUCH_VERTEX_LAST_TIME = "touchVertexLastTime"

str	OPERATION_TOUCH_FACE_FIRST_TIME = "touchFaceFirstTime"

str	OPERATION_TOUCH_FACE_LAST_TIME = "touchFaceLastTime"

str	OPERATION_TOUCH_CELL_FIRST_TIME = "touchCellFirstTime"

str	OPERATION_TOUCH_CELL_LAST_TIME = "touchCellLastTime"

Protected Attributes inherited from peano4.toolbox.particles.api.AbstractUpdateParticleGridAssociation.AbstractUpdateParticleGridAssociation
	_particle_set

Detailed Description

Associate particles to spacetree vertices.

Sort particles into the respective levels and cells. This mapping should be used every time you move particles around.

Algorithm

The re-association has different ingredients. We have two implementations currently available. The present version does not touch any particle within the cell events. It realises the following steps/checks:

If I touch a vertex for the last time, I check if its particles are within h/2 Manhattan distance. If not, I lift them to the next coarser level.
Drop particles down within the tree hierarchy such that they reside on an as fine level as possible. This happens in touchVertexFirstTime(), i.e. in-between two grid traversals, particles are distributed over all resolutions, but we move them down in the hierarchy as kind of a preamble of the subsequent grid sweep.

This variant is algorithmically simpler than other ones, but it moves particles around more often: If a particle moves closer to another vertex than the one it is currently associated, we do not directly reassign it to a new vertex. Instead, we move it one level up within the tree. Just before the subsequent grid sweep, I sieve the particles all down again. So the move from one vertex to the next is realised via a move through the next coarser level. The first variant does not move particles up and down that often, but it checks particles more often, as each particle is checked from up to 2^d adjacent cells. So it is not clear which variant is superior.

Tunneling and horizontal data movements between trees

All cores run through their trees. On the finest mesh level, we have a non-overlapping domain decomposition. Each cell has a unique owner tree. On the coarser resolutions, the association is not unique anymore. We make it unique, i.e. each cell on any level has a unique owner. The owners (aka threads or ranks) run through their trees concurrently and exchange their boundary data after the traversal. If particles are to be lifted, this causes issues, as we cannot exchange them between two levels after the traversal. We could, but then we can't lift them any further within the first traversal, and we also cannot drop them into another rank at the same time.

Therefore, I employ a mixture of the pidt technique from the paper and the sieve approach also discussed there. Usually, I do all lifts and drops right throughout the mesh traversal. If I'd lift into a cell/level which is owned by another tree, I don't lift but instead dump the particle into a rank-global list. These lists are then exchanged after each traversal sweep. Drops now can either happen from the next coarser level or this global list. I call the latter a sieve.

Due to this global list approach, I can support tunneling, i.e. particles racing through multiple cells in one time step, and all of this works with MPI, too.

Statistics

The mapping keeps some statistics on any state update. These statistics however are not shared via MPI or synchronised between different threads. It is the job of the ParticleSet to ensure that we have a proper global bookkeeping.

Where and how to use

Within your algorithm step, this update action set should always be the first or one of the first action sets before you add any other action set. If you add it first, it ensures that the drop of particles is one of the first things that happen, before any user code is triggered. As Peano automatically inverts the action set order throughout the backtracking, adding UpdateParticleGridAssociation as first action set ensures that the lifts are basically the last thing you do. This is particular imporant if your user code alters particle positions in touchVertexLastTime().

Your main code has to call finishedTraversal() on the tracer set after each sweep on each rank. This important to roll those particles over that have been sieved or have been lifted. todo this might be wrong

You will always needs to instances of this action set in a row, as the first one might lift particles and put them into a sieve list. After that, the subsequent grid sweep will drop the particles and sieve them in again. As long as particles do not move, this variant becomes idempotent after two mesh sweeps.

Hanging vertices

Hanging vertices do never hold information and therefore are never assigned any particles.

Interpolay with particle storage

This sorting scheme should not be used if you use a particle memory pool, i.e. if you try to store particles continuously - unless you insert explicit gather/resort steps. Read through the memory implications for any particle sorting.

Definition at line 12 of file UpdateParticleGridAssociation_LiftDrop.py.

Constructor & Destructor Documentation

◆ init()

peano4.toolbox.particles.api.UpdateParticleGridAssociation_LiftDrop.UpdateParticleGridAssociation_LiftDrop.__init__	(	self,
		particle_set,
		guard = "true" )

Reimplemented from peano4.toolbox.particles.api.AbstractUpdateParticleGridAssociation.AbstractUpdateParticleGridAssociation.

Definition at line 119 of file UpdateParticleGridAssociation_LiftDrop.py.

References peano4.toolbox.particles.api.UpdateParticleGridAssociation_LiftDrop.UpdateParticleGridAssociation_LiftDrop.__init__().

Referenced by peano4.toolbox.particles.api.UpdateParticleGridAssociation_LiftDrop.UpdateParticleGridAssociation_LiftDrop.__init__().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ get_action_set_name()

peano4.toolbox.particles.api.UpdateParticleGridAssociation_LiftDrop.UpdateParticleGridAssociation_LiftDrop.get_action_set_name ( self )

Return unique action set name.

Returns a description (word) for the mapping which is also used as class name for the generated type. As a consequence, the result should be one word (if possible) and uppercase. Also, every subclass should overwrite this routine.

The generator will take the result and construct eventually classes similar to MyStep2Dummy.h and MyStep2Dummy.cpp or similar for the example below, where we return Dummy.

Reimplemented from peano4.solversteps.ActionSet.ActionSet.

Definition at line 279 of file UpdateParticleGridAssociation_LiftDrop.py.

◆ get_body_of_operation()

peano4.toolbox.particles.api.UpdateParticleGridAssociation_LiftDrop.UpdateParticleGridAssociation_LiftDrop.get_body_of_operation	(		self,
			operation_name )