selfPropelledVicsekAligningParticleDynamics Class Reference

A class that implements simple self-propelled particle dynamics in 2D. More...

#include <selfPropelledVicsekAligningParticleDynamics.h>

Inheritance diagram for selfPropelledVicsekAligningParticleDynamics:

Public Member Functions
	selfPropelledVicsekAligningParticleDynamics ()
	base constructor sets the default time step size
	selfPropelledVicsekAligningParticleDynamics (int N, Dscalar _eta=0.0, Dscalar _tau=1.0)
	additionally set the number of particles andinitialize things More...
virtual void	integrateEquationsOfMotion ()
	the fundamental function that models will call, using vectors of different data structures More...
virtual void	integrateEquationsOfMotionCPU ()
	call the CPU routine to integrate the e.o.m. More...
virtual void	integrateEquationsOfMotionGPU ()
	call the GPU routine to integrate the e.o.m. More...
Dscalar	getMu ()
	Get the inverse friction constant, mu.
void	setMu (Dscalar _mu)
	Set the number of degrees of freedom of the equation of motion.
void	setEta (Dscalar _Eta)
void	setTau (Dscalar _tau)
virtual void	spatialSorting ()
	call the Simple2DCell spatial vertex sorter, and re-index arrays of cell activity More...
virtual void	set2DModel (shared_ptr< Simple2DModel > _model)
	set the active model More...
int	getTimestep ()
	get the number of timesteps run
Dscalar	getTime ()
	get the current simulation time
virtual void	setDeltaT (Dscalar dt)
	Set the simulation time stepsize.
virtual void	performUpdate ()
	performUpdate just maps to integrateEquationsOfMotion
virtual void	setReproducible (bool rep)
	Set whether the source of noise should always use the same random numbers.
void	reIndexRNG (GPUArray< curandState > &array)
	re-index the any RNGs associated with the e.o.m.
virtual void	Update (int timestep)
	The fundamental function that a controlling Simulation can call.
void	setPeriod (int _p)
	set the period
void	setPhase (int _p)
	set the phase
virtual void	setGPU ()
	Enforce GPU-only operation. This is the default mode, so this method need not be called most of the time.
virtual void	setCPU ()
	Enforce CPU-only operation. Derived classes might have to do more work when the CPU mode is invoked.
int	getNdof ()
	Get the number of degrees of freedom of the equation of motion.
void	setNdof (int _n)
	Set the number of degrees of freedom of the equation of motion.

Public Attributes
shared_ptr< Simple2DModel >	model
	A pointer to a Simple2DModel that the updater acts on.

Protected Member Functions
void	reIndexArray (GPUArray< int > &array)
	Re-index cell arrays after a spatial sorting has occured.
void	reIndexArray (GPUArray< Dscalar > &array)
	why use templates when you can type more?
void	reIndexArray (GPUArray< Dscalar2 > &array)
	why use templates when you can type more?

Protected Attributes
shared_ptr< Simple2DActiveCell >	activeModel
	A shared pointer to a simple active model.
Dscalar	tau
	The value of the alignment coupling.
Dscalar	mu
	The value of the inverse friction constant.
Dscalar	Eta
	The value of the strength of vectorial noise.
int	Timestep
	Count the number of integration timesteps.
Dscalar	deltaT
	The time stepsize of the simulation.
GPUArray< Dscalar2 >	displacements
	an internal GPUArray for holding displacements
noiseSource	noise
	A source of noise for the equation of motion.
int	Period
	The period of the updater... the updater will work every Period timesteps.
int	Phase
	The phase of the updater... the updater will work every Period timesteps offset by a phase.
bool	GPUcompute
	whether the updater does its work on the GPU or not
int	Ndof
	The number of degrees of freedom the equations of motion need to know about.
vector< int >	reIndexing
	a vector of the re-indexing information

Detailed Description

A class that implements simple self-propelled particle dynamics in 2D.

implements dr/dt = mu*F + v_0 {n}, where {n} = (cos(theta),sin(theta))

Additionally there is a tendancy for the directors to align with the directors of nearby particles theta_j(t+ t) = arg ({neighbors of j} (e^(i*theta_k(t)) + *n*e^(i*^t) ), where k denotes a neighbor of j, where n is the number of neighbors of j, is a random number between 0 and 2Pi

Constructor & Destructor Documentation

selfPropelledVicsekAligningParticleDynamics()

selfPropelledVicsekAligningParticleDynamics::selfPropelledVicsekAligningParticleDynamics	(	int	_N,
		Dscalar	_eta = 0.0,
		Dscalar	_tau = 1.0
	)

additionally set the number of particles andinitialize things

An extremely simple constructor that does nothing, but enforces default GPU operation

Parameters

the	number of points in the system (cells or particles)

Member Function Documentation

integrateEquationsOfMotion()

void selfPropelledVicsekAligningParticleDynamics::integrateEquationsOfMotion ( )

virtual

the fundamental function that models will call, using vectors of different data structures

Advances self-propelled dynamics with random noise in the director by one time step

Reimplemented from simpleEquationOfMotion.

References activeModel, simpleEquationOfMotion::displacements, updater::GPUcompute, noiseSource::initialize(), integrateEquationsOfMotionCPU(), integrateEquationsOfMotionGPU(), updater::Ndof, updaterWithNoise::noise, GPUArray< T >::resize(), and simpleEquationOfMotion::Timestep.

integrateEquationsOfMotionCPU()

void selfPropelledVicsekAligningParticleDynamics::integrateEquationsOfMotionCPU ( )

virtual

call the CPU routine to integrate the e.o.m.

The straightforward CPU implementation

References activeModel, simpleEquationOfMotion::displacements, access_location::host, updater::Ndof, access_mode::overwrite, and access_mode::read.

Referenced by integrateEquationsOfMotion().

integrateEquationsOfMotionGPU()

void selfPropelledVicsekAligningParticleDynamics::integrateEquationsOfMotionGPU ( )

virtual

call the GPU routine to integrate the e.o.m.

The straightforward GPU implementation

References activeModel, ArrayHandle< T >::data, simpleEquationOfMotion::deltaT, access_location::device, simpleEquationOfMotion::displacements, Eta, gpu_spp_vicsek_aligning_eom_integration(), mu, updater::Ndof, updaterWithNoise::noise, access_mode::overwrite, access_mode::read, access_mode::readwrite, noiseSource::RNGs, and simpleEquationOfMotion::Timestep.

Referenced by integrateEquationsOfMotion().

spatialSorting()

void selfPropelledVicsekAligningParticleDynamics::spatialSorting ( )

virtual

call the Simple2DCell spatial vertex sorter, and re-index arrays of cell activity

When spatial sorting is performed, re-index the array of cuda RNGs... This function is currently commented out, for greater flexibility (i.e., to not require that the indexToTag (or Itt) be the re-indexing array), since that assumes cell and not particle-based dynamics

Reimplemented from updater.

set2DModel()

void selfPropelledVicsekAligningParticleDynamics::set2DModel ( shared_ptr< Simple2DModel >  _model )

virtual

set the active model

Set the shared pointer of the base class to passed variable; cast it as an active cell model

Reimplemented from updater.

References activeModel, and updater::model.

---

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

• selfPropelledVicsekAligningParticleDynamics.h
• selfPropelledVicsekAligningParticleDynamics.cpp