Peano

Searching...

No Matches

Base class for any particle in the project. More...

Inheritance diagram for swift2.particle.Particle.Particle:

[legend]

Collaboration diagram for swift2.particle.Particle.Particle:

[legend]

Data Structures
class	SpeciesAspect
	Every generated particle belongs to a species. More...

Public Member Functions
	__init__ (self, name, particles_per_cell, min_h, max_h)
	Initialise the particle.

	algorithm_steps (self)
	Return sequence of algorithm steps that have to be called per time step.

	initialisation_steps (self)
	Return sequence of algorithm steps that have to be performed throughout initialisation.

	readme_descriptor (self)
	Create default readme descriptor.

Public Member Functions inherited from peano4.datamodel.DaStGen2.DaStGen2
	configure (self, namespace, association, subdirectory="")
	I always need the MPI aspect, but I can't add the right one before I don't know whether this DaStGen model is used for vertices, faces or cells.

	additional_load_and_store_arguments (self)

	additional_load_and_store_arguments (self, new_arguments)

Public Member Functions inherited from peano4.datamodel.DoF.DoF
	get_full_qualified_type (self)

	get_logical_type_name (self)
	What should the data type be called within the data repository, or within action sets.

	get_enumeration_type (self)
	What should the data type be called within the data repository.

	additional_load_and_store_arguments_for_other_dof (self, argument_name, use_dof_association=None)
	You can make Peano's store and load arguments of any DoF depend on other DoFs that you have loaded before.

	subnamespace (self)

Data Fields
	particles_per_cell

	min_h

	max_h

	name

Data Fields inherited from peano4.toolbox.particles.Particle.Particle
	name

	partid

Data Fields inherited from peano4.datamodel.DaStGen2.DaStGen2
	generator

	data

	peano4_mpi_and_storage_aspect

Data Fields inherited from peano4.datamodel.DoF.DoF
	association

	name

	namespace

	subdirectory

Static Public Attributes
str	DependencyChecks_Attribute_Prefix = "dependencyChecks"

list	DependencyChecks_Ifdefs = ["PeanoDebug > 0"]

Static Public Attributes inherited from peano4.datamodel.DaStGen2.DaStGen2
str	readme_package_descriptor

Protected Member Functions
	_dependency_checks_modify_steps (self, steplist, step_type_name, peano4_event_enum)
	Add dependency checks as well as mesh consistency checks to the algorithm steps.

	_add_dependency_checks (self)
	Add dependency (particle consistency) checks.

Protected Attributes
	_algorithm_steps

	_initialisation_steps

Protected Attributes inherited from peano4.datamodel.DaStGen2.DaStGen2
	_additional_load_and_store_arguments

Protected Attributes inherited from peano4.datamodel.DoF.DoF
	_additional_load_and_store_arguments

Detailed Description

Base class for any particle in the project.

You usually do not initialise this base class, but you pick one of the subclasses which define which time stepping scheme is realised by a particle. The time stepping scheme defines through which phases or steps each particle runs through per time step, while this generic base class has no steps at all.

The type is a specialisation of Peano's particle as it is provided via the toolbox. In line with the docu there, you can use this particle and add further attributes via

my_particle.data.add_attribute( peano4.dastgen2.Peano4DoubleArray("v","Dimensions") )

peano4.dastgen2.Peano4DoubleArray.Peano4DoubleArray

Specialisation of dastgen2.attributes.DoubleArray which relies on Peano's tarch.

Definition Peano4DoubleArray.py:7

Definition at line 10 of file Particle.py.

Constructor & Destructor Documentation

◆ init()

swift2.particle.Particle.Particle.__init__	(	self,
		name,
		particles_per_cell,
		min_h,
		max_h )

Initialise the particle.

This is the baseclass for a particle, i.e. we only add the absolute minimum of information to a particle. As we inherit from the toolbox particle, we already have some attributes defined. These are the guys which are not explicitly visible from the code snippet below, i.e. they are introduced by the superclass constructor.

Here's an overview of pre-defined attributes that each and every particle hosts:

A position which is a double vector with Dimension entries.
A search radius which describes the range with which other particles a particle might theoretically interact. The effective interaction might be smaller if a code decides to ignore potential interaction partners, i.e. this is an absolute maximum. The search radius will decide on which resolution level within the tree a particle is held.
A MoveState flag. This flag is essential. We use it later to label those particles that have been moved to avoid that we move particles multiple times.
A flag that indicates if a particle has been updated within a cell. Consult our code release papers: In short, a particle does not uniquely belong to one cell but can belong to many cells. We nevertheless want to update them only once.

See also: swift2.actionsets.UpdateParticleMarker

Reimplemented from peano4.toolbox.particles.Particle.Particle.

Reimplemented in swift2.particle.tests.testLeapfrogFixedTimeStepSize.testLeapfrogFixedTimeStepSize, swift2.particle.ExplicitEulerFixedSearchRadius.ExplicitEulerFixedSearchRadius, swift2.particle.LeapfrogFixedSearchRadius.LeapfrogFixedSearchRadius, swift2.particle.tests.DisappearingParticleTest.DisappearingParticleTest, swift2.particle.ExplicitEulerDynamicSearchRadius.ExplicitEulerDynamicSearchRadius, swift2.particle.tests.testDensityCalculation.testDensityCalculation, swift2.particle.SPHLeapfrogFixedSearchRadius.SPHLeapfrogFixedSearchRadius, swift2.particle.SPHParticle.SPHParticle, and swift2.particle.tests.DastgenTestDummyParticle.DastgenTestDummyParticle.

Definition at line 74 of file Particle.py.

Referenced by swift2.particle.Particle.Particle.__init__().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ _add_dependency_checks()

swift2.particle.Particle.Particle._add_dependency_checks ( self )

protected

Add dependency (particle consistency) checks.

This routine should be called in the subclass directly after you have befilled self._algorithm_steps and self._initialisation_steps. It is safe to add this stuff to your particle model all the time - the actual checks kick in if and only if you run in non-release modes. However, you might want to call the function only in these cases to ensure that no (empty) C++ code is generated and the compiler can optimise more aggressively.

Realisation

We first create Enumerations representing each algorithm step defined for the Particle, as well as each sweep stage of any grid traversal.

Then for each defined algorithm step, we add a call to the dependency check functions for each sweep stage (touch vertex first time, cell kernel, touch vertex last time...)

The check consists of 1) marking down which step in the full algorithm a particle has completed in the current simulation step 2) verifying that each step and sweep stage before the one the particle currently finds itself in has been completed.

This is done both for the main algorithm steps as well as for the initialisation steps individually.

Definition at line 482 of file Particle.py.

Here is the call graph for this function:

◆ _dependency_checks_modify_steps()

swift2.particle.Particle.Particle._dependency_checks_modify_steps	(	self,
		steplist,
		step_type_name,
		peano4_event_enum )

protected

Add dependency checks as well as mesh consistency checks to the algorithm steps.

This function actually modifies the AlgorithmSteps to contain the debug dependency checks. Is called by self._add_dependency_checks() and uses the validation routines from swift2::dependencychecks.

The routine is used to either add checks for the init phase or the actual time stepping. Which one is meant is identified through step_type_name. You can obviously call the routine twice: once for init and once for the time stepping. Later on, you might want to add further steps.

Besides the name of interest, we also require a list of algorithmic steps through which the code runs through.

Default settings

If the user does not define bespoke default settings, this routine adds default ones. These are set through instances of swift::dependencychecks::Invariant.

For vertices, this is touch-at-most-once-mask-out-otherwise-all-previous-steps-update-at-least-once.
For cells, this is also touch-at-most-once-mask-out-otherwise-all-previous-steps-update-at-least-once.

Additional attributes

First, the particle is added two counters which count up how often a particle is touched or masked out.

Parameters

Steplist	list list of AlgorithmStep objects to work on
step_type_name	str name of type of steps we're dealing with. Either AlgorithmStep or InitStep.
peano4_event_enum	list list of enums of peano4 events within a single mesh traversal (e.g. touch vertex first time, cell kernel, ...)