simpleEquationsOfMotion Kernels

Functions
bool	gpu_brownian_eom_integration (Dscalar2 *forces, Dscalar2 *displacements, curandState *RNGs, int N, Dscalar deltaT, Dscalar mu, Dscalar T)
	set the vector of displacements from forces and noise More...
bool	gpu_prepare_KE_vector (Dscalar2 *velocities, Dscalar *masses, Dscalar *keArray, int N)
	(Dscalar) ans = (Dscalar2) vec1 . vec2 More...
bool	gpu_NoseHooverChainNVT_scale_velocities (Dscalar2 *velocities, Dscalar *kineticEnergyScaleFactor, int N)
	Rescale the velocities according to the given scale factor. More...
bool	gpu_NoseHooverChainNVT_update_velocities (Dscalar2 *velocities, Dscalar2 *forces, Dscalar *masses, Dscalar deltaT, int N)
	update the velocities according to the forces and the masses More...
bool	gpu_spp_aligning_eom_integration (Dscalar2 *forces, Dscalar2 *velocities, Dscalar2 *displacements, Dscalar2 *motility, Dscalar *cellDirectors, curandState *RNGs, int N, Dscalar deltaT, int Timestep, Dscalar mu, Dscalar J)
	set the vector of displacements from forces and activity More...
bool	gpu_spp_cellVertex_eom_integration (Dscalar2 *forces, Dscalar2 *displacements, Dscalar2 *motility, Dscalar *cellDirectors, int *vertexNeighbors, curandState *RNGs, int Nvertices, int Ncells, Dscalar deltaT, int Timestep, Dscalar mu)
	set the vector of displacements from forces and activity More...
bool	gpu_spp_eom_integration (Dscalar2 *forces, Dscalar2 *velocities, Dscalar2 *displacements, Dscalar2 *motility, Dscalar *cellDirectors, curandState *RNGs, int N, Dscalar deltaT, int Timestep, Dscalar mu)
	set the vector of displacements from forces and activity More...
bool	gpu_spp_vicsek_aligning_eom_integration (Dscalar2 *forces, Dscalar2 *velocities, Dscalar2 *displacements, Dscalar2 *motility, Dscalar *cellDirectors, int *nNeighbors, int *neighbors, Index2D &n_idx, curandState *RNGs, int N, Dscalar deltaT, int Timestep, Dscalar mu, Dscalar Eta)
	set the vector of displacements from forces and activity More...
__global__ void	brownian_eom_integration_kernel (Dscalar2 *forces, Dscalar2 *displacements, curandState *RNGs, int N, Dscalar deltaT, Dscalar mu, Dscalar T)
__global__ void	NoseHooverChainNVT_prepare_KE_kernel (Dscalar2 *velocities, Dscalar *masses, Dscalar *keArray, int N)
__global__ void	NoseHooverChainNVT_scale_velocities_kernel (Dscalar2 *velocities, Dscalar *kineticEnergyScaleFactor, int N)
__global__ void	NoseHooverChainNVT_update_velocities_kernel (Dscalar2 *velocities, Dscalar2 *forces, Dscalar *masses, Dscalar deltaT, int N)
__global__ void	spp_aligning_eom_integration_kernel (Dscalar2 *forces, Dscalar2 *velocities, Dscalar2 *displacements, Dscalar2 *motility, Dscalar *cellDirectors, curandState *RNGs, int N, Dscalar deltaT, int Timestep, Dscalar mu, Dscalar J)
__global__ void	calculate_vertex_displacement_kernel (Dscalar2 *d_forces, Dscalar2 *d_displacements, Dscalar2 *motility, Dscalar *d_cellDirectors, int *d_vertexCellNeighbors, Dscalar deltaT, Dscalar mu, int Nvertices)
__global__ void	rotate_directors_kernel (Dscalar *d_cellDirectors, curandState *d_curandRNGs, Dscalar2 *motility, Dscalar deltaT, int Ncells)
__global__ void	spp_eom_integration_kernel (Dscalar2 *forces, Dscalar2 *velocities, Dscalar2 *displacements, Dscalar2 *motility, Dscalar *cellDirectors, curandState *RNGs, int N, Dscalar deltaT, int Timestep, Dscalar mu)
__global__ void	spp_vicsek_aligning_eom_integration_kernel (Dscalar2 *forces, Dscalar2 *velocities, Dscalar2 *displacements, Dscalar2 *motility, Dscalar *cellDirectors, int *nNeighbors, int *neighbors, Index2D n_idx, curandState *RNGs, int N, Dscalar deltaT, int Timestep, Dscalar mu, Dscalar Eta)
__global__ void	initialize_RNG_kernel (curandState *state, int N, int Timestep, int GlobalSeed)
bool	gpu_initialize_RNG (curandState *states, int N, int Timestep, int GlobalSeed)
	Call the kernel to initialize a different RNG for each particle. More...

Detailed Description

Function Documentation

gpu_brownian_eom_integration()

bool gpu_brownian_eom_integration	(	Dscalar2 *	forces,
		Dscalar2 *	displacements,
		curandState *	RNGs,
		int	N,
		Dscalar	deltaT,
		Dscalar	mu,
		Dscalar	T
	)

set the vector of displacements from forces and noise

get the current timesteps vector of displacements into the displacement vector

Referenced by brownianParticleDynamics::integrateEquationsOfMotionGPU().

gpu_prepare_KE_vector()

bool gpu_prepare_KE_vector	(	Dscalar2 *	velocities,
		Dscalar *	masses,
		Dscalar *	keArray,
		int	N
	)

(Dscalar) ans = (Dscalar2) vec1 . vec2

Parameters

velocities	Dscalar2 array of current velocities
masses	Dscalar array of current masses
keArray	Dscalar output array
N	the length of the arrays

Postcondition

keArray[idx] = 0.5*masses[idx]*(velocities[idx])^2

Referenced by NoseHooverChainNVT::calculateKineticEnergyGPU().

gpu_NoseHooverChainNVT_scale_velocities()

bool gpu_NoseHooverChainNVT_scale_velocities	(	Dscalar2 *	velocities,
		Dscalar *	kineticEnergyScaleFactor,
		int	N
	)

Rescale the velocities according to the given scale factor.

Simply rescale every component of V by the scale factor.

Referenced by NoseHooverChainNVT::rescaleVelocitiesGPU().

gpu_NoseHooverChainNVT_update_velocities()

bool gpu_NoseHooverChainNVT_update_velocities	(	Dscalar2 *	velocities,
		Dscalar2 *	forces,
		Dscalar *	masses,
		Dscalar	deltaT,
		int	N
	)

update the velocities according to the forces and the masses

simple update of velocity based on force and mass

gpu_spp_aligning_eom_integration()

bool gpu_spp_aligning_eom_integration	(	Dscalar2 *	forces,
		Dscalar2 *	velocities,
		Dscalar2 *	displacements,
		Dscalar2 *	motility,
		Dscalar *	cellDirectors,
		curandState *	RNGs,
		int	N,
		Dscalar	deltaT,
		int	Timestep,
		Dscalar	mu,
		Dscalar	J
	)

set the vector of displacements from forces and activity

get the current timesteps vector of displacements into the displacement vector

Referenced by selfPropelledAligningParticleDynamics::integrateEquationsOfMotionGPU().

gpu_spp_cellVertex_eom_integration()

bool gpu_spp_cellVertex_eom_integration	(	Dscalar2 *	forces,
		Dscalar2 *	displacements,
		Dscalar2 *	motility,
		Dscalar *	cellDirectors,
		int *	vertexNeighbors,
		curandState *	RNGs,
		int	Nvertices,
		int	Ncells,
		Dscalar	deltaT,
		int	Timestep,
		Dscalar	mu
	)

set the vector of displacements from forces and activity

get the current timesteps vector of displacements into the displacement vector, rotate the cells

Referenced by selfPropelledCellVertexDynamics::integrateEquationsOfMotionGPU().

gpu_spp_eom_integration()

bool gpu_spp_eom_integration	(	Dscalar2 *	forces,
		Dscalar2 *	velocities,
		Dscalar2 *	displacements,
		Dscalar2 *	motility,
		Dscalar *	cellDirectors,
		curandState *	RNGs,
		int	N,
		Dscalar	deltaT,
		int	Timestep,
		Dscalar	mu
	)

set the vector of displacements from forces and activity

get the current timesteps vector of displacements into the displacement vector

Referenced by selfPropelledParticleDynamics::integrateEquationsOfMotionGPU().

gpu_spp_vicsek_aligning_eom_integration()

bool gpu_spp_vicsek_aligning_eom_integration	(	Dscalar2 *	forces,
		Dscalar2 *	velocities,
		Dscalar2 *	displacements,
		Dscalar2 *	motility,
		Dscalar *	cellDirectors,
		int *	nNeighbors,
		int *	neighbors,
		Index2D &	n_idx,
		curandState *	RNGs,
		int	N,
		Dscalar	deltaT,
		int	Timestep,
		Dscalar	mu,
		Dscalar	Eta
	)

set the vector of displacements from forces and activity

get the current timesteps vector of displacements into the displacement vector

Referenced by selfPropelledVicsekAligningParticleDynamics::integrateEquationsOfMotionGPU().

brownian_eom_integration_kernel()

__global__ void brownian_eom_integration_kernel	(	Dscalar2 *	forces,
		Dscalar2 *	displacements,
		curandState *	RNGs,
		int	N,
		Dscalar	deltaT,
		Dscalar	mu,
		Dscalar	T
	)

Each thread calculates the displacement of an individual cell

NoseHooverChainNVT_prepare_KE_kernel()

__global__ void NoseHooverChainNVT_prepare_KE_kernel	(	Dscalar2 *	velocities,
		Dscalar *	masses,
		Dscalar *	keArray,
		int	N
	)

into the output vector put 0.5*m[i]*v[i]^2

NoseHooverChainNVT_scale_velocities_kernel()

__global__ void NoseHooverChainNVT_scale_velocities_kernel	(	Dscalar2 *	velocities,
		Dscalar *	kineticEnergyScaleFactor,
		int	N
	)

Each thread scales the velocity of one particle by the second component of the helper array

NoseHooverChainNVT_update_velocities_kernel()

__global__ void NoseHooverChainNVT_update_velocities_kernel	(	Dscalar2 *	velocities,
		Dscalar2 *	forces,
		Dscalar *	masses,
		Dscalar	deltaT,
		int	N
	)

Each thread updates the velocity of one particle

spp_aligning_eom_integration_kernel()

__global__ void spp_aligning_eom_integration_kernel	(	Dscalar2 *	forces,
		Dscalar2 *	velocities,
		Dscalar2 *	displacements,
		Dscalar2 *	motility,
		Dscalar *	cellDirectors,
		curandState *	RNGs,
		int	N,
		Dscalar	deltaT,
		int	Timestep,
		Dscalar	mu,
		Dscalar	J
	)

Each thread calculates the displacement of an individual cell

calculate_vertex_displacement_kernel()

__global__ void calculate_vertex_displacement_kernel	(	Dscalar2 *	d_forces,
		Dscalar2 *	d_displacements,
		Dscalar2 *	motility,
		Dscalar *	d_cellDirectors,
		int *	d_vertexCellNeighbors,
		Dscalar	deltaT,
		Dscalar	mu,
		int	Nvertices
	)

In this version of the active vertex model, the motility of a vertex is a straight average of the motility of the three adjacent cells

rotate_directors_kernel()

__global__ void rotate_directors_kernel	(	Dscalar *	d_cellDirectors,
		curandState *	d_curandRNGs,
		Dscalar2 *	motility,
		Dscalar	deltaT,
		int	Ncells
	)

After the vertices have been moved, the directors of the cells have some noise.

spp_eom_integration_kernel()

__global__ void spp_eom_integration_kernel	(	Dscalar2 *	forces,
		Dscalar2 *	velocities,
		Dscalar2 *	displacements,
		Dscalar2 *	motility,
		Dscalar *	cellDirectors,
		curandState *	RNGs,
		int	N,
		Dscalar	deltaT,
		int	Timestep,
		Dscalar	mu
	)

Each thread calculates the displacement of an individual cell

spp_vicsek_aligning_eom_integration_kernel()

__global__ void spp_vicsek_aligning_eom_integration_kernel	(	Dscalar2 *	forces,
		Dscalar2 *	velocities,
		Dscalar2 *	displacements,
		Dscalar2 *	motility,
		Dscalar *	cellDirectors,
		int *	nNeighbors,
		int *	neighbors,
		Index2D	n_idx,
		curandState *	RNGs,
		int	N,
		Dscalar	deltaT,
		int	Timestep,
		Dscalar	mu,
		Dscalar	Eta
	)

Each thread calculates the displacement of an individual cell

initialize_RNG_kernel()

__global__ void initialize_RNG_kernel	(	curandState *	state,
		int	N,
		int	Timestep,
		int	GlobalSeed
	)

Each thread – most likely corresponding to each cell – is initialized with a different sequence of the same seed of a cudaRNG

gpu_initialize_RNG()

bool gpu_initialize_RNG	(	curandState *	states,
		int	N,
		int	Timestep,
		int	GlobalSeed
	)

Call the kernel to initialize a different RNG for each particle.

Initialize the GPU's random number generator.