2D.h File Reference

Type definitions for the OpenCL kernels (2D version). More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	vec   float2
#define	dvec   double2
#define	ivec   int2
#define	lvec   long2
#define	uivec   uint2
#define	ulvec   ulong2
#define	svec   usize2
#define	ssvec   ssize2
#define	matrix   float4
#define	VEC_ZERO   ((float2)(0.f,0.f))
	Null vec, i.e. filled with zero components.
#define	VEC_ONE   ((float2)(1.f, 1.f))
	Ones vec, i.e. filled with one components.
#define	VEC_ALL_ONE   VEC_ONE
	VEC_ONE.
#define	VEC_INFINITY   ((float2)(INFINITY, INFINITY))
	Infinity vec, i.e. filled with infinity components.
#define	VEC_ALL_INFINITY   VEC_INFINITY
	VEC_INFINITY.
#define	VEC_NEG_INFINITY   (-VEC_INFINITY)
	-Infinity vec, i.e. filled with -infinity components.
#define	VEC_ALL_NEG_INFINITY   (-VEC_ALL_INFINITY)
	VEC_NEG_INFINITY.
#define	MAT_ZERO
	Null matrix, i.e. filled with zero components.
#define	MAT_ONE
	Ones matrix, i.e. filled with one components.
#define	MAT_ALL_ONE   MAT_ONE
	MAT_ONE.
#define	MAT_EYE
	Eye matrix.
#define	MAT_ALL_EYE   MAT_EYE
	MAT_EYE.
#define	XYZ   xy
	Convenient access to the vector components.
#define	BEGIN_LOOP_OVER_NEIGHS()
	Loop over the neighs to compute the interactions.
#define	END_LOOP_OVER_NEIGHS()
	End of the loop over the neighs to compute the interactions.
#define	BEGIN_NEIGHS(CELL, NPARTS, NCELLS, ICELL, IHOC)
	Loop over the neighbours to compute the interactions.
#define	END_NEIGHS()
	End of the loop over the neighs to compute the interactions.
#define	MATRIX_DOT(_M, _V)
	Multiply a matrix by a vector (inner product)
#define	MATRIX_DOT_ALL   MATRIX_DOT
	MATRIX_DOT
#define	MATRIX_MUL(_M1, _M2)
	Multiply a matrix by a matrix (inner product)
#define	MATRIX_MUL_ALL   MATRIX_MUL
	MATRIX_MUL
#define	TRANSPOSE   s0213
	Transpose a matrix.
#define	DIAG   s03
	The matrix diagonal (as vector)
#define	MATRIX_FROM_DIAG(_V)
	Build up a matrix from the diagonal information (as vector)
#define	MATRIX_TRACE(_M)
	Trace of the matrix.
#define	MATRIX_INV(_M)
	Pseudo-inverse of a matrix.
#define	vec_xyz   vec2
	Vectors with the minimum number of components.
#define	dvec_xyz   dvec2
#define	ivec_xyz   ivec2
#define	lvec_xyz   lvec2
#define	uivec_xyz   uivec2
#define	ulvec_xyz   ulvec2
#define	svec_xyz   svec2
#define	ssvec_xyz   ssvec2

Functions
matrix	outer (const vec v1, const vec v2)
	Perform the outer product of two vectors.
float	det (const matrix m)
	Determinant of a matrix.
matrix	inv (const matrix m)
	Inverse of a matrix.

Detailed Description

Type definitions for the OpenCL kernels (2D version).

Macro Definition Documentation

BEGIN_LOOP_OVER_NEIGHS

#define BEGIN_LOOP_OVER_NEIGHS

(

)

Value:

    C_I();                                                                     \
    for(int ci = -1; ci <= 1; ci++) {                                          \
        for(int cj = -1; cj <= 1; cj++) {                                      \
            const usize c_j = c_i +                                            \
                              ci +                                             \
                              cj * n_cells.x;                                  \
            usize j = ihoc[c_j];                                               \
            while((j < N) && (icell[j] == c_j)) {

Loop over the neighs to compute the interactions.

All the code between this macro and END_LOOP_OVER_NEIGHS will be executed for all the neighbours.

To use this macro, the main particle (the one which the interactions are intended to be computed) should be identified by an unsigned integer variable i, while the resulting neighs will be automatically identified by the unsigned integer variable j. To discard a neighbour particle, remember calling

j++ 

before

continue 

The following variables will be declared, and therefore cannot be used elsewhere:

• c_i: The cell where the particle i is placed
• ci: Index of the cell of the neighbour particle j, in the x direction
• cj: Index of the cell of the neighbour particle j, in the x direction
• ck: Index of the cell of the neighbour particle j, in the x direction
• c_j: Index of the cell of the neighbour particle j
• j: Index of the neighbour particle.

See also

END_LOOP_OVER_NEIGHS

BEGIN_NEIGHS

#define BEGIN_NEIGHS	(		CELL,
			NPARTS,
			NCELLS,
			ICELL,
			IHOC )

Value:

    for(int __ci = -1; __ci <= 1; __ci++) {                                    \
        for(int __cj = -1; __cj <= 1; __cj++) {                                \
            const usize __c_j = CELL +                                         \
                                __ci +                                         \
                                __cj * NCELLS.x;                               \
            usize j = IHOC[__c_j];                                             \
            while((j < NPARTS) && (ICELL[j] == __c_j)) {

Loop over the neighbours to compute the interactions.

All the code between this macro and END_NEIGHS will be executed for all the neighbours.

The resulting neighs will be automatically identified by the unsigned integer variable j. To discard a neighbour particle, remember calling

j++ 

followed by

continue 

The following variables will be declared, and therefore cannot be used within the loop scope:

• __ci: Index of the cell of the neighbour particle j, in the x direction
• __cj: Index of the cell of the neighbour particle j, in the x direction
• __ck: Index of the cell of the neighbour particle j, in the x direction
• __c_j: Index of the cell of the neighbour particle j
• j: Index of the neighbour particle

Parameters

CELL	Cell of the main particle (usually icell[i] )
NPARTS	Number of particles (usually N )
NCELLS	Number of cells at each direction (usually n_cells )
ICELL	Array of cells for each particle (usually icell )
IHOC	Array of head of cells (usually ihoc )

See also

END_NEIGHS

Note

This macro is created to replace the old BEGIN_LOOP_OVER_NEIGHS, which does not easily allows to do multi-gpu computations

DIAG

#define DIAG   s03

The matrix diagonal (as vector)

dvec

#define dvec   double2

dvec_xyz

#define dvec_xyz   dvec2

END_LOOP_OVER_NEIGHS

#define END_LOOP_OVER_NEIGHS

(

)

Value:

                j++;                                                           \
            }                                                                  \
        }                                                                      \
    }

End of the loop over the neighs to compute the interactions.

See also

BEGIN_LOOP_OVER_NEIGHS

END_NEIGHS

#define END_NEIGHS

(

)

Value:

                j++;                                                           \
            }                                                                  \
        }                                                                      \
    }

End of the loop over the neighs to compute the interactions.

See also

BEGIN_NEIGHS

Note

This macro is created to replace the old END_LOOP_OVER_NEIGHS, which does not easily allows to do multi-gpu computations

ivec

#define ivec   int2

ivec_xyz

#define ivec_xyz   ivec2

lvec

#define lvec   long2

lvec_xyz

#define lvec_xyz   lvec2

MAT_ALL_EYE

#define MAT_ALL_EYE   MAT_EYE

MAT_EYE.

MAT_ALL_ONE

#define MAT_ALL_ONE   MAT_ONE

MAT_ONE.

MAT_EYE

#define MAT_EYE

Value:

                             ((float4)(1.f, 0.f,                                            \
                             0.f, 1.f))

Eye matrix.

\( m_{ii} = 1; m_{ij} = 1 \leftrightarrow i \neq j \)

MAT_ONE

#define MAT_ONE

Value:

                          ((float4)(1.f, 1.f,                                            \
                          1.f, 1.f))

Ones matrix, i.e. filled with one components.

MAT_ZERO

#define MAT_ZERO

Value:

                           ((float4)(0.f, 0.f,                                           \
                           0.f, 0.f))

Null matrix, i.e. filled with zero components.

matrix

#define matrix   float4

MATRIX_DOT

#define MATRIX_DOT	(		_M,
			_V )

Value:

    ((float2)(dot(_M.s01, _V),                                                 \
              dot(_M.s23, _V)))

Multiply a matrix by a vector (inner product)

MATRIX_DOT_ALL

#define MATRIX_DOT_ALL   MATRIX_DOT

MATRIX_DOT

MATRIX_FROM_DIAG

#define MATRIX_FROM_DIAG

(

_V

)

Value:

    ((float4)(_V.x,  0.f,                                                      \
               0.f, _V.y))

Build up a matrix from the diagonal information (as vector)

MATRIX_INV

#define MATRIX_INV

(

_M

)

Value:

    MATRIX_MUL(inv(MATRIX_MUL(_M.TRANSPOSE, _M)), _M.TRANSPOSE)

Pseudo-inverse of a matrix.

The SVD Moore-Penrose method is applied:

\[ A^{\dag} = \left( A^T A \right)^{-1} A^T \]

MATRIX_MUL

#define MATRIX_MUL	(		_M1,
			_M2 )

Value:

    ((float4)(dot(_M1.s01, _M2.s02), dot(_M1.s01, _M2.s13),                    \
              dot(_M1.s23, _M2.s02), dot(_M1.s23, _M2.s13)))

Multiply a matrix by a matrix (inner product)

MATRIX_MUL_ALL

#define MATRIX_MUL_ALL   MATRIX_MUL

MATRIX_MUL

MATRIX_TRACE

#define MATRIX_TRACE

(

_M

)

Value:

(_M.s0 + _M.s3)

Trace of the matrix.

i.e. The sum of the diagonal elements of the matrix.

ssvec

#define ssvec   ssize2

ssvec_xyz

#define ssvec_xyz   ssvec2

svec

#define svec   usize2

svec_xyz

#define svec_xyz   svec2

TRANSPOSE

#define TRANSPOSE   s0213

Transpose a matrix.

uivec

#define uivec   uint2

uivec_xyz

#define uivec_xyz   uivec2

ulvec

#define ulvec   ulong2

ulvec_xyz

#define ulvec_xyz   ulvec2

vec

#define vec   float2

VEC_ALL_INFINITY

#define VEC_ALL_INFINITY   VEC_INFINITY

VEC_INFINITY.

VEC_ALL_NEG_INFINITY

#define VEC_ALL_NEG_INFINITY   (-VEC_ALL_INFINITY)

VEC_NEG_INFINITY.

VEC_ALL_ONE

#define VEC_ALL_ONE   VEC_ONE

VEC_ONE.

VEC_INFINITY

#define VEC_INFINITY   ((float2)(INFINITY, INFINITY))

Infinity vec, i.e. filled with infinity components.

VEC_NEG_INFINITY

#define VEC_NEG_INFINITY   (-VEC_INFINITY)

-Infinity vec, i.e. filled with -infinity components.

VEC_ONE

#define VEC_ONE   ((float2)(1.f, 1.f))

Ones vec, i.e. filled with one components.

vec_xyz

#define vec_xyz   vec2

Vectors with the minimum number of components.

The number of components depends on weather the 2D version or 3D version is compiled:

• 2D = 2 components
• 3D = 3 components

This type can be used for the local variables to reduce the VGPRs.

VEC_ZERO

#define VEC_ZERO   ((float2)(0.f,0.f))

Null vec, i.e. filled with zero components.

XYZ

#define XYZ   xy

Convenient access to the vector components.

It is useful to be used with vec_xyz, ivec_xyz and uivec_xyz type:

• 2D = .xy
• 3D = .xyz

Function Documentation

det()

float det

(

const matrix

m

)

Determinant of a matrix.

Parameters

m	Matrix to invert

Returns

Determinant

inv()

matrix inv

(

const matrix

m

)

Inverse of a matrix.

Parameters

m	Matrix to invert

Returns

Inverse of the matrix

Remarks

If the input matrix m is singular, nan values matrix will be returned. Consider using MATRIX_INV pseudo-inverse instead

Here is the call graph for this function:

outer()

matrix outer	(	const vec	v1,
		const vec	v2 )

Perform the outer product of two vectors.

Parameters

v1	Left operand vector
v2	Right operand vector

Returns

Outer product matrix