This module implements common operations on batches of mesh functions. More...

Detailed Description

This module implements common operations on batches of mesh functions.

Data Types
interface	batch_add_with_map

interface	batch_axpby
	batchified axpby: \( y = ax + by \) More...

interface	batch_axpy
	batchified version of the BLAS axpy routine: \( y = a*x + y \) More...

interface	batch_copy_with_map

interface	batch_get_points

interface	batch_get_state

interface	batch_mul_mf
	batchified multiplication by mesh function with optional conjugation: \( y_i = f(r_i) * CJ(x_i) \) More...

interface	batch_pointwise_mul

interface	batch_scal
	scale a batch by a constant or vector \( y = a*x \) More...

interface	batch_scal2v
	batchified scale with optional conjugation: \( y = a*CJ(x) \) More...

interface	batch_set_points

interface	batch_set_state
	There are several ways how to call batch_set_state and batch_get_state: More...

interface	batch_xpay
	batchified version of \( y = x + a*y \) More...

Functions/Subroutines
subroutine, public	batch_set_zero (this, np, async)
	fill all mesh functions of the batch with zero More...

subroutine	batch_get_points_accel (this, sp, ep, psi, ldpsi1, ldpsi2)
	GPU version of batch_get_points. More...

subroutine	batch_set_points_accel (this, sp, ep, psi, ldpsi1, ldpsi2)
	GPU version of batch_set_points. More...

integer pure function, public	batch_points_block_size ()
	determine the device block size More...

subroutine	batch_mul_cj (np, xx, yy, zz, conjugate_yy)
	Point-wise multiply two batches with optional conjugation on yy: zz_i = xx_i * CJ(yy_i) More...

subroutine	batch_add_with_map_cpu (np, map, xx, yy, zz)

subroutine	batch_add_with_map_accel (np, map, xx, yy, zz)

subroutine	batch_copy_with_map_cpu (np, map, xx, yy)

subroutine	batch_copy_with_map_accel (np, map, xx, yy)

subroutine, public	batch_split_complex (np, xx, yy, zz)
	extract the real and imaginary parts of a complex batch More...

subroutine	dbatch_axpy_const (np, aa, xx, yy)
	This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy, where the same constant aa is used for all functions. More...

subroutine	dbatch_axpy_vec_generic (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine, public	dbatch_axpy_function (np, aa, xx, psi, nst)
	This routine performs a set of axpy operations for each function x of a batch (xx), and accumulate the result to y (psi in this case), a single function. More...

subroutine, public	dbatch_ax_function_py (np, aa, psi, yy)
	This routine performs a set of axpy operations adding the same function psi to all functions of a batch (yy),. More...

subroutine	dbatch_scal_const (np, aa, xx)
	scale all functions in a batch by constant aa More...

subroutine	dbatch_scal_vec_generic (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	dbatch_xpay_vec (np, xx, aa, yy, a_start, a_full)
	calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch More...

subroutine	dbatch_xpay_const (np, xx, aa, yy)
	calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch More...

subroutine	dbatch_axpby (np, aa, xx, bb, yy)
	calculate yy(ist,:) = aaxx(ist,:) + bbyy(ist,:) for a batch More...

subroutine	dbatch_scal2v (np, aa, xx, yy, conjugate_xx)
	calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch More...

subroutine	dbatch_mul_mf (np, ff, xx, yy, conjugate_xx)
	calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch More...

subroutine	dbatch_set_state1 (this, ist, np, psi)
	Write a single state with np points into a batch at position ist. More...

subroutine	dbatch_set_state2 (this, index, np, psi)
	Write a single state with np points into a batch at position defined by index. More...

subroutine	dbatch_set_state3 (this, ii, np, psi)
	Write a set of state with np points into a batch. More...

subroutine	dbatch_get_state1 (this, ist, np, psi, async)
	Write a get of state with np points from a batch. More...

subroutine	dbatch_get_state2 (this, index, np, psi, async)

subroutine	dbatch_get_state3 (this, ii, np, psi, async)

subroutine	dbatch_get_points (this, sp, ep, psi)
	copy a set of points into a mesh function More...

subroutine	dbatch_set_points (this, sp, ep, psi)
	copy a set of points into a mesh function More...

subroutine	dbatch_add_with_map (np, map, xx, yy, zz)

subroutine	dbatch_copy_with_map (np, map, xx, yy)

subroutine, public	dbatch_copy_with_map_to_array (np, map, xx, array)
	Transfer a batch from the mesh to an array on the submesh (defined by a map) More...

subroutine	dbatch_axpy_vec (np, aa, xx, yy, a_start, a_full)
	A simple switch between specialized kernels and generic kernels. More...

subroutine	dbatch_scal_vec (np, aa, xx, a_start, a_full)

subroutine	zbatch_axpy_const (np, aa, xx, yy)
	This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy, where the same constant aa is used for all functions. More...

subroutine	zbatch_axpy_vec_generic (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine, public	zbatch_axpy_function (np, aa, xx, psi, nst)
	This routine performs a set of axpy operations for each function x of a batch (xx), and accumulate the result to y (psi in this case), a single function. More...

subroutine, public	zbatch_ax_function_py (np, aa, psi, yy)
	This routine performs a set of axpy operations adding the same function psi to all functions of a batch (yy),. More...

subroutine	zbatch_scal_const (np, aa, xx)
	scale all functions in a batch by constant aa More...

subroutine	zbatch_scal_vec_generic (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_xpay_vec (np, xx, aa, yy, a_start, a_full)
	calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch More...

subroutine	zbatch_xpay_const (np, xx, aa, yy)
	calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch More...

subroutine	zbatch_axpby (np, aa, xx, bb, yy)
	calculate yy(ist,:) = aaxx(ist,:) + bbyy(ist,:) for a batch More...

subroutine	zbatch_scal2v (np, aa, xx, yy, conjugate_xx)
	calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch More...

subroutine	zbatch_mul_mf (np, ff, xx, yy, conjugate_xx)
	calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch More...

subroutine	zbatch_set_state1 (this, ist, np, psi)
	Write a single state with np points into a batch at position ist. More...

subroutine	zbatch_set_state2 (this, index, np, psi)
	Write a single state with np points into a batch at position defined by index. More...

subroutine	zbatch_set_state3 (this, ii, np, psi)
	Write a set of state with np points into a batch. More...

subroutine	zbatch_get_state1 (this, ist, np, psi, async)
	Write a get of state with np points from a batch. More...

subroutine	zbatch_get_state2 (this, index, np, psi, async)

subroutine	zbatch_get_state3 (this, ii, np, psi, async)

subroutine	zbatch_get_points (this, sp, ep, psi)
	copy a set of points into a mesh function More...

subroutine	zbatch_set_points (this, sp, ep, psi)
	copy a set of points into a mesh function More...

subroutine	zbatch_add_with_map (np, map, xx, yy, zz)

subroutine	zbatch_copy_with_map (np, map, xx, yy)

subroutine, public	zbatch_copy_with_map_to_array (np, map, xx, array)
	Transfer a batch from the mesh to an array on the submesh (defined by a map) More...

subroutine	zbatch_axpy_vec (np, aa, xx, yy, a_start, a_full)
	A simple switch between specialized kernels and generic kernels. More...

subroutine	zbatch_scal_vec (np, aa, xx, a_start, a_full)

subroutine	dbatch_axpy_vec_2 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	dbatch_scal_vec_2 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_axpy_vec_2 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	zbatch_scal_vec_2 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	dbatch_axpy_vec_3 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	dbatch_scal_vec_3 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_axpy_vec_3 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	zbatch_scal_vec_3 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	dbatch_axpy_vec_4 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	dbatch_scal_vec_4 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_axpy_vec_4 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	zbatch_scal_vec_4 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	dbatch_axpy_vec_6 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	dbatch_scal_vec_6 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_axpy_vec_6 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	zbatch_scal_vec_6 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	dbatch_axpy_vec_8 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	dbatch_scal_vec_8 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_axpy_vec_8 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	zbatch_scal_vec_8 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

Function/Subroutine Documentation

◆ batch_set_zero()

subroutine, public batch_ops_oct_m::batch_set_zero	(	class(batch_t), intent(inout)	this,
		integer, intent(in), optional	np,
		logical, intent(in), optional	async
	)

fill all mesh functions of the batch with zero

Parameters

[in] np number of mesh points to consider. By deafult, all points are set to zero, meaning that np = np_part. This allows to set the batch to zero only for points up to np

Definition at line 264 of file batch_ops.F90.

◆ batch_get_points_accel()

subroutine batch_ops_oct_m::batch_get_points_accel	(	class(batch_t), intent(in)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		type(accel_mem_t), intent(inout)	psi,
		integer, intent(in)	ldpsi1,
		integer, intent(in)	ldpsi2
	)

private

GPU version of batch_get_points.

Parameters

[in]	this	the batch
[in]	sp	starting point
[in]	ep	end point
[in,out]	psi	device buffer for mesh function
[in]	ldpsi1	number of states: stnst
[in]	ldpsi2	states dimensions: ddim

Definition at line 340 of file batch_ops.F90.

◆ batch_set_points_accel()

subroutine batch_ops_oct_m::batch_set_points_accel	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		type(accel_mem_t), intent(in)	psi,
		integer, intent(in)	ldpsi1,
		integer, intent(in)	ldpsi2
	)

private

GPU version of batch_set_points.

Parameters

[in,out]	this	the batch
[in]	sp	starting point
[in]	ep	end point
[in]	psi	device buffer of mesh function
[in]	ldpsi1	number of states: stnst
[in]	ldpsi2	state dimensions ddim

Definition at line 407 of file batch_ops.F90.

◆ batch_points_block_size()

integer pure function, public batch_ops_oct_m::batch_points_block_size

determine the device block size

Currently, this is just set to a constant.

Definition at line 476 of file batch_ops.F90.

◆ batch_mul_cj()

subroutine batch_ops_oct_m::batch_mul_cj	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(in)	yy,
		class(batch_t), intent(inout)	zz,
		logical, intent(in), optional	conjugate_yy
	)

private

Point-wise multiply two batches with optional conjugation on yy: zz_i = xx_i * CJ(yy_i)

Definition at line 485 of file batch_ops.F90.

◆ batch_add_with_map_cpu()

subroutine batch_ops_oct_m::batch_add_with_map_cpu	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(in)	yy,
		class(batch_t), intent(inout)	zz
	)

private

Definition at line 612 of file batch_ops.F90.

◆ batch_add_with_map_accel()

subroutine batch_ops_oct_m::batch_add_with_map_accel	(	integer, intent(in)	np,
		class(accel_mem_t), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(in)	yy,
		class(batch_t), intent(inout)	zz
	)

private

Definition at line 640 of file batch_ops.F90.

◆ batch_copy_with_map_cpu()

subroutine batch_ops_oct_m::batch_copy_with_map_cpu	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

Definition at line 672 of file batch_ops.F90.

◆ batch_copy_with_map_accel()

subroutine batch_ops_oct_m::batch_copy_with_map_accel	(	integer, intent(in)	np,
		class(accel_mem_t), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

Definition at line 699 of file batch_ops.F90.

◆ batch_split_complex()

subroutine, public batch_ops_oct_m::batch_split_complex	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		class(batch_t), intent(inout)	zz
	)

extract the real and imaginary parts of a complex batch

Note: all batches must be of the same status.

Parameters

[in]	np	number of mesh points to consider
[in]	xx	original batch (must be of type TYPE_CMPLX)
[in,out]	yy	batch containing real part of xx (must be of type TYPE_FLOAT)
[in,out]	zz	batch containing imaginary part of xx (must be of type TYPE_FLOAT)

Definition at line 735 of file batch_ops.F90.

◆ dbatch_axpy_const()

subroutine batch_ops_oct_m::dbatch_axpy_const	(	integer, intent(in)	np,
		real(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy, where the same constant aa is used for all functions.

Parameters

[in]	np	number of points
[in,out]	yy	yy(:,:) = aa*xx(:,:) + yy(:,:)

Definition at line 863 of file batch_ops.F90.

◆ dbatch_axpy_vec_generic()

subroutine batch_ops_oct_m::dbatch_axpy_vec_generic	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 949 of file batch_ops.F90.

◆ dbatch_axpy_function()

subroutine, public batch_ops_oct_m::dbatch_axpy_function	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in), contiguous	aa,
		class(batch_t), intent(in)	xx,
		real(real64), dimension(:,:), intent(inout), contiguous	psi,
		integer, intent(in), optional	nst
	)

This routine performs a set of axpy operations for each function x of a batch (xx), and accumulate the result to y (psi in this case), a single function.

Parameters

[in]	np	number of points
[in]	xx	input batch
[in,out]	psi	result: \( psi = \sum_{ist=1}^{nst} aa(ist) * xx(ist) \)
[in]	aa	array of multipliers
[in]	nst	optional upper bound of sum

Definition at line 1098 of file batch_ops.F90.

◆ dbatch_ax_function_py()

subroutine, public batch_ops_oct_m::dbatch_ax_function_py	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in), contiguous	aa,
		real(real64), dimension(:,:), intent(in), contiguous	psi,
		class(batch_t), intent(inout)	yy
	)

This routine performs a set of axpy operations adding the same function psi to all functions of a batch (yy),.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in]	psi	mesh functions psi
[in,out]	yy	resulting batch yy(ist) = yy(ist) + aa(ist) * psi

Definition at line 1202 of file batch_ops.F90.

◆ dbatch_scal_const()

subroutine batch_ops_oct_m::dbatch_scal_const	(	integer, intent(in)	np,
		real(real64), intent(in)	aa,
		class(batch_t), intent(inout)	xx
	)

private

scale all functions in a batch by constant aa

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa

Definition at line 1286 of file batch_ops.F90.

◆ dbatch_scal_vec_generic()

subroutine batch_ops_oct_m::dbatch_scal_vec_generic	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 1324 of file batch_ops.F90.

◆ dbatch_xpay_vec()

subroutine batch_ops_oct_m::dbatch_xpay_vec	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch

Parameters

[in]	np	number of points
[in]	aa	array of constants aa(ist)
[in,out]	yy	yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:)

Definition at line 1459 of file batch_ops.F90.

◆ dbatch_xpay_const()

subroutine batch_ops_oct_m::dbatch_xpay_const	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		real(real64), intent(in)	aa,
		class(batch_t), intent(inout)	yy
	)

private

calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch

Parameters

[in]	np	number of points
[in,out]	yy	yy(ist) = xx(ist) + a*yy(ist)

Definition at line 1602 of file batch_ops.F90.

◆ dbatch_axpby()

subroutine batch_ops_oct_m::dbatch_axpby	(	integer, intent(in)	np,
		real(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		real(real64), intent(in)	bb,
		class(batch_t), intent(inout)	yy
	)

private

calculate yy(ist,:) = aa*xx(ist,:) + bb*yy(ist,:) for a batch

Definition at line 1633 of file batch_ops.F90.

◆ dbatch_scal2v()

subroutine batch_ops_oct_m::dbatch_scal2v	(	integer, intent(in)	np,
		real(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		logical, intent(in), optional	conjugate_xx
	)

private

calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch

Definition at line 1752 of file batch_ops.F90.

◆ dbatch_mul_mf()

subroutine batch_ops_oct_m::dbatch_mul_mf	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	ff,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		logical, intent(in), optional	conjugate_xx
	)

private

calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch

Definition at line 1896 of file batch_ops.F90.

◆ dbatch_set_state1()

subroutine batch_ops_oct_m::dbatch_set_state1	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	ist,
		integer, intent(in)	np,
		real(real64), dimension(:), intent(in), contiguous	psi
	)

private

Write a single state with np points into a batch at position ist.

Parameters

[in,out]	this	batch to write the state to
[in]	ist	position where to write
[in]	np	number of points
[in]	psi	the state to write

Definition at line 2048 of file batch_ops.F90.

◆ dbatch_set_state2()

subroutine batch_ops_oct_m::dbatch_set_state2	(	class(batch_t), intent(inout)	this,
		integer, dimension(:), intent(in)	index,
		integer, intent(in)	np,
		real(real64), dimension(:), intent(in), contiguous	psi
	)

private

Write a single state with np points into a batch at position defined by index.

Parameters

[in,out]	this	batch to write the state into
[in]	index	how to access the state. For further information see batch_ops_oct_m::batch_set_state
[in]	np	number of points
[in]	psi	state to write to the batch

Definition at line 2161 of file batch_ops.F90.

◆ dbatch_set_state3()

subroutine batch_ops_oct_m::dbatch_set_state3	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	ii,
		integer, intent(in)	np,
		real(real64), dimension(:, :), intent(in), contiguous	psi
	)

private

Write a set of state with np points into a batch.

Parameters

[in,out]	this	batch to write the states into
[in]	ii	position
[in]	np	number of points
[in]	psi	states to write

Definition at line 2179 of file batch_ops.F90.

◆ dbatch_get_state1()

subroutine batch_ops_oct_m::dbatch_get_state1	(	class(batch_t), intent(in)	this,
		integer, intent(in)	ist,
		integer, intent(in)	np,
		real(real64), dimension(:), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Write a get of state with np points from a batch.

Parameters

[in] async only working with pinned memory

Definition at line 2199 of file batch_ops.F90.

◆ dbatch_get_state2()

subroutine batch_ops_oct_m::dbatch_get_state2	(	class(batch_t), intent(in)	this,
		integer, dimension(:), intent(in)	index,
		integer, intent(in)	np,
		real(real64), dimension(:), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Parameters

[in] async only working with pinned memory

Definition at line 2320 of file batch_ops.F90.

◆ dbatch_get_state3()

subroutine batch_ops_oct_m::dbatch_get_state3	(	class(batch_t), intent(in)	this,
		integer, intent(in)	ii,
		integer, intent(in)	np,
		real(real64), dimension(:, :), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Parameters

[in] async only working with pinned memory

Definition at line 2338 of file batch_ops.F90.

◆ dbatch_get_points()

subroutine batch_ops_oct_m::dbatch_get_points	(	class(batch_t), intent(in)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		real(real64), dimension(:, :, sp:), intent(inout), contiguous	psi
	)

private

copy a set of points into a mesh function

Parameters

[in]	this	the batch to get points from
[in]	sp	starting point
[in]	ep	end point
[in,out]	psi	mesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 2359 of file batch_ops.F90.

◆ dbatch_set_points()

subroutine batch_ops_oct_m::dbatch_set_points	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		real(real64), dimension(:, :, sp:), intent(in), contiguous	psi
	)

private

copy a set of points into a mesh function

Parameters

[in,out]	this	the batch to write points into
[in]	sp	starting point
[in]	ep	end point
[in]	psi	mesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 2439 of file batch_ops.F90.

◆ dbatch_add_with_map()

subroutine batch_ops_oct_m::dbatch_add_with_map	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(in)	yy,
		class(batch_t), intent(inout)	zz
	)

private

Definition at line 2524 of file batch_ops.F90.

◆ dbatch_copy_with_map()

subroutine batch_ops_oct_m::dbatch_copy_with_map	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

Definition at line 2566 of file batch_ops.F90.

◆ dbatch_copy_with_map_to_array()

subroutine, public batch_ops_oct_m::dbatch_copy_with_map_to_array	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		real(real64), dimension(:,:), intent(inout)	array
	)

Transfer a batch from the mesh to an array on the submesh (defined by a map)

Parameters

[in,out] array (psibnst_linear, submeshnp)

Definition at line 2609 of file batch_ops.F90.

◆ dbatch_axpy_vec()

subroutine batch_ops_oct_m::dbatch_axpy_vec	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

A simple switch between specialized kernels and generic kernels.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

Definition at line 2655 of file batch_ops.F90.

◆ dbatch_scal_vec()

subroutine batch_ops_oct_m::dbatch_scal_vec	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 2679 of file batch_ops.F90.

◆ zbatch_axpy_const()

subroutine batch_ops_oct_m::zbatch_axpy_const	(	integer, intent(in)	np,
		complex(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy, where the same constant aa is used for all functions.

Parameters

[in]	np	number of points
[in,out]	yy	yy(:,:) = aa*xx(:,:) + yy(:,:)

Definition at line 2781 of file batch_ops.F90.

◆ zbatch_axpy_vec_generic()

subroutine batch_ops_oct_m::zbatch_axpy_vec_generic	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 2867 of file batch_ops.F90.

◆ zbatch_axpy_function()

subroutine, public batch_ops_oct_m::zbatch_axpy_function	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in), contiguous	aa,
		class(batch_t), intent(in)	xx,
		complex(real64), dimension(:,:), intent(inout), contiguous	psi,
		integer, intent(in), optional	nst
	)

This routine performs a set of axpy operations for each function x of a batch (xx), and accumulate the result to y (psi in this case), a single function.

Parameters

[in]	np	number of points
[in]	xx	input batch
[in,out]	psi	result: \( psi = \sum_{ist=1}^{nst} aa(ist) * xx(ist) \)
[in]	aa	array of multipliers
[in]	nst	optional upper bound of sum

Definition at line 2999 of file batch_ops.F90.

◆ zbatch_ax_function_py()

subroutine, public batch_ops_oct_m::zbatch_ax_function_py	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in), contiguous	aa,
		complex(real64), dimension(:,:), intent(in), contiguous	psi,
		class(batch_t), intent(inout)	yy
	)

This routine performs a set of axpy operations adding the same function psi to all functions of a batch (yy),.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in]	psi	mesh functions psi
[in,out]	yy	resulting batch yy(ist) = yy(ist) + aa(ist) * psi

Definition at line 3103 of file batch_ops.F90.

◆ zbatch_scal_const()

subroutine batch_ops_oct_m::zbatch_scal_const	(	integer, intent(in)	np,
		complex(real64), intent(in)	aa,
		class(batch_t), intent(inout)	xx
	)

private

scale all functions in a batch by constant aa

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa

Definition at line 3187 of file batch_ops.F90.

◆ zbatch_scal_vec_generic()

subroutine batch_ops_oct_m::zbatch_scal_vec_generic	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 3225 of file batch_ops.F90.

◆ zbatch_xpay_vec()

subroutine batch_ops_oct_m::zbatch_xpay_vec	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch

Parameters

[in]	np	number of points
[in]	aa	array of constants aa(ist)
[in,out]	yy	yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:)

Definition at line 3343 of file batch_ops.F90.

◆ zbatch_xpay_const()

subroutine batch_ops_oct_m::zbatch_xpay_const	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		complex(real64), intent(in)	aa,
		class(batch_t), intent(inout)	yy
	)

private

calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch

Parameters

[in]	np	number of points
[in,out]	yy	yy(ist) = xx(ist) + a*yy(ist)

Definition at line 3461 of file batch_ops.F90.

◆ zbatch_axpby()

subroutine batch_ops_oct_m::zbatch_axpby	(	integer, intent(in)	np,
		complex(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		complex(real64), intent(in)	bb,
		class(batch_t), intent(inout)	yy
	)

private

calculate yy(ist,:) = aa*xx(ist,:) + bb*yy(ist,:) for a batch

Definition at line 3492 of file batch_ops.F90.

◆ zbatch_scal2v()

subroutine batch_ops_oct_m::zbatch_scal2v	(	integer, intent(in)	np,
		complex(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		logical, intent(in), optional	conjugate_xx
	)

private

calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch

Definition at line 3579 of file batch_ops.F90.

◆ zbatch_mul_mf()

subroutine batch_ops_oct_m::zbatch_mul_mf	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	ff,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		logical, intent(in), optional	conjugate_xx
	)

private

calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch

Definition at line 3692 of file batch_ops.F90.

◆ zbatch_set_state1()

subroutine batch_ops_oct_m::zbatch_set_state1	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	ist,
		integer, intent(in)	np,
		complex(real64), dimension(:), intent(in), contiguous	psi
	)

private

Write a single state with np points into a batch at position ist.

Parameters

[in,out]	this	batch to write the state to
[in]	ist	position where to write
[in]	np	number of points
[in]	psi	the state to write

Definition at line 3811 of file batch_ops.F90.

◆ zbatch_set_state2()

subroutine batch_ops_oct_m::zbatch_set_state2	(	class(batch_t), intent(inout)	this,
		integer, dimension(:), intent(in)	index,
		integer, intent(in)	np,
		complex(real64), dimension(:), intent(in), contiguous	psi
	)

private

Write a single state with np points into a batch at position defined by index.

Parameters

[in,out]	this	batch to write the state into
[in]	index	how to access the state. For further information see batch_ops_oct_m::batch_set_state
[in]	np	number of points
[in]	psi	state to write to the batch

Definition at line 3911 of file batch_ops.F90.

◆ zbatch_set_state3()

subroutine batch_ops_oct_m::zbatch_set_state3	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	ii,
		integer, intent(in)	np,
		complex(real64), dimension(:, :), intent(in), contiguous	psi
	)

private

Write a set of state with np points into a batch.

Parameters

[in,out]	this	batch to write the states into
[in]	ii	position
[in]	np	number of points
[in]	psi	states to write

Definition at line 3929 of file batch_ops.F90.

◆ zbatch_get_state1()

subroutine batch_ops_oct_m::zbatch_get_state1	(	class(batch_t), intent(in)	this,
		integer, intent(in)	ist,
		integer, intent(in)	np,
		complex(real64), dimension(:), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Write a get of state with np points from a batch.

Parameters

[in] async only working with pinned memory

Definition at line 3949 of file batch_ops.F90.

◆ zbatch_get_state2()

subroutine batch_ops_oct_m::zbatch_get_state2	(	class(batch_t), intent(in)	this,
		integer, dimension(:), intent(in)	index,
		integer, intent(in)	np,
		complex(real64), dimension(:), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Parameters

[in] async only working with pinned memory

Definition at line 4083 of file batch_ops.F90.

◆ zbatch_get_state3()

subroutine batch_ops_oct_m::zbatch_get_state3	(	class(batch_t), intent(in)	this,
		integer, intent(in)	ii,
		integer, intent(in)	np,
		complex(real64), dimension(:, :), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Parameters

[in] async only working with pinned memory

Definition at line 4101 of file batch_ops.F90.

◆ zbatch_get_points()

subroutine batch_ops_oct_m::zbatch_get_points	(	class(batch_t), intent(in)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		complex(real64), dimension(:, :, sp:), intent(inout), contiguous	psi
	)

private

copy a set of points into a mesh function

Parameters

[in]	this	the batch to get points from
[in]	sp	starting point
[in]	ep	end point
[in,out]	psi	mesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 4122 of file batch_ops.F90.

◆ zbatch_set_points()

subroutine batch_ops_oct_m::zbatch_set_points	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		complex(real64), dimension(:, :, sp:), intent(in), contiguous	psi
	)

private

copy a set of points into a mesh function

Parameters

[in,out]	this	the batch to write points into
[in]	sp	starting point
[in]	ep	end point
[in]	psi	mesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 4214 of file batch_ops.F90.

◆ zbatch_add_with_map()

subroutine batch_ops_oct_m::zbatch_add_with_map	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(in)	yy,
		class(batch_t), intent(inout)	zz
	)

private

Definition at line 4288 of file batch_ops.F90.

◆ zbatch_copy_with_map()

subroutine batch_ops_oct_m::zbatch_copy_with_map	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

Definition at line 4330 of file batch_ops.F90.

◆ zbatch_copy_with_map_to_array()

subroutine, public batch_ops_oct_m::zbatch_copy_with_map_to_array	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		complex(real64), dimension(:,:), intent(inout)	array
	)

Transfer a batch from the mesh to an array on the submesh (defined by a map)

Parameters

[in,out] array (psibnst_linear, submeshnp)

Definition at line 4373 of file batch_ops.F90.

◆ zbatch_axpy_vec()

subroutine batch_ops_oct_m::zbatch_axpy_vec	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

A simple switch between specialized kernels and generic kernels.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

Definition at line 4419 of file batch_ops.F90.

◆ zbatch_scal_vec()

subroutine batch_ops_oct_m::zbatch_scal_vec	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 4443 of file batch_ops.F90.

◆ dbatch_axpy_vec_2()

subroutine batch_ops_oct_m::dbatch_axpy_vec_2	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 4547 of file batch_ops.F90.

◆ dbatch_scal_vec_2()

subroutine batch_ops_oct_m::dbatch_scal_vec_2	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 4693 of file batch_ops.F90.

◆ zbatch_axpy_vec_2()

subroutine batch_ops_oct_m::zbatch_axpy_vec_2	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 4901 of file batch_ops.F90.

◆ zbatch_scal_vec_2()

subroutine batch_ops_oct_m::zbatch_scal_vec_2	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 5030 of file batch_ops.F90.

◆ dbatch_axpy_vec_3()

subroutine batch_ops_oct_m::dbatch_axpy_vec_3	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 5224 of file batch_ops.F90.

◆ dbatch_scal_vec_3()

subroutine batch_ops_oct_m::dbatch_scal_vec_3	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 5370 of file batch_ops.F90.

◆ zbatch_axpy_vec_3()

subroutine batch_ops_oct_m::zbatch_axpy_vec_3	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 5578 of file batch_ops.F90.

◆ zbatch_scal_vec_3()

subroutine batch_ops_oct_m::zbatch_scal_vec_3	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 5707 of file batch_ops.F90.

◆ dbatch_axpy_vec_4()

subroutine batch_ops_oct_m::dbatch_axpy_vec_4	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 5901 of file batch_ops.F90.

◆ dbatch_scal_vec_4()

subroutine batch_ops_oct_m::dbatch_scal_vec_4	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 6047 of file batch_ops.F90.

◆ zbatch_axpy_vec_4()

subroutine batch_ops_oct_m::zbatch_axpy_vec_4	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 6255 of file batch_ops.F90.

◆ zbatch_scal_vec_4()

subroutine batch_ops_oct_m::zbatch_scal_vec_4	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 6384 of file batch_ops.F90.

◆ dbatch_axpy_vec_6()

subroutine batch_ops_oct_m::dbatch_axpy_vec_6	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 6578 of file batch_ops.F90.

◆ dbatch_scal_vec_6()

subroutine batch_ops_oct_m::dbatch_scal_vec_6	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 6724 of file batch_ops.F90.

◆ zbatch_axpy_vec_6()

subroutine batch_ops_oct_m::zbatch_axpy_vec_6	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 6932 of file batch_ops.F90.

◆ zbatch_scal_vec_6()

subroutine batch_ops_oct_m::zbatch_scal_vec_6	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 7061 of file batch_ops.F90.

◆ dbatch_axpy_vec_8()

subroutine batch_ops_oct_m::dbatch_axpy_vec_8	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 7255 of file batch_ops.F90.

◆ dbatch_scal_vec_8()

subroutine batch_ops_oct_m::dbatch_scal_vec_8	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 7401 of file batch_ops.F90.

◆ zbatch_axpy_vec_8()

subroutine batch_ops_oct_m::zbatch_axpy_vec_8	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 7609 of file batch_ops.F90.

◆ zbatch_scal_vec_8()

subroutine batch_ops_oct_m::zbatch_scal_vec_8	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 7738 of file batch_ops.F90.

Detailed Description

Data Types

Functions/Subroutines

Function/Subroutine Documentation

◆ batch_set_zero()

◆ batch_get_points_accel()

◆ batch_set_points_accel()

◆ batch_points_block_size()

◆ batch_mul_cj()

◆ batch_add_with_map_cpu()

◆ batch_add_with_map_accel()

◆ batch_copy_with_map_cpu()

◆ batch_copy_with_map_accel()

◆ batch_split_complex()

◆ dbatch_axpy_const()

◆ dbatch_axpy_vec_generic()

◆ dbatch_axpy_function()

◆ dbatch_ax_function_py()

◆ dbatch_scal_const()

◆ dbatch_scal_vec_generic()

◆ dbatch_xpay_vec()

◆ dbatch_xpay_const()

◆ dbatch_axpby()

◆ dbatch_scal2v()

◆ dbatch_mul_mf()

◆ dbatch_set_state1()

◆ dbatch_set_state2()

◆ dbatch_set_state3()

◆ dbatch_get_state1()

◆ dbatch_get_state2()

◆ dbatch_get_state3()

◆ dbatch_get_points()

◆ dbatch_set_points()

◆ dbatch_add_with_map()

◆ dbatch_copy_with_map()

◆ dbatch_copy_with_map_to_array()

◆ dbatch_axpy_vec()

◆ dbatch_scal_vec()

◆ zbatch_axpy_const()

◆ zbatch_axpy_vec_generic()

◆ zbatch_axpy_function()

◆ zbatch_ax_function_py()

◆ zbatch_scal_const()

◆ zbatch_scal_vec_generic()

◆ zbatch_xpay_vec()

◆ zbatch_xpay_const()

◆ zbatch_axpby()

◆ zbatch_scal2v()

◆ zbatch_mul_mf()

◆ zbatch_set_state1()

◆ zbatch_set_state2()

◆ zbatch_set_state3()

◆ zbatch_get_state1()

◆ zbatch_get_state2()

◆ zbatch_get_state3()

◆ zbatch_get_points()

◆ zbatch_set_points()

◆ zbatch_add_with_map()

◆ zbatch_copy_with_map()

◆ zbatch_copy_with_map_to_array()

◆ zbatch_axpy_vec()

◆ zbatch_scal_vec()

◆ dbatch_axpy_vec_2()

◆ dbatch_scal_vec_2()

◆ zbatch_axpy_vec_2()

◆ zbatch_scal_vec_2()

◆ dbatch_axpy_vec_3()

◆ dbatch_scal_vec_3()

◆ zbatch_axpy_vec_3()

◆ zbatch_scal_vec_3()

◆ dbatch_axpy_vec_4()

◆ dbatch_scal_vec_4()

◆ zbatch_axpy_vec_4()

◆ zbatch_scal_vec_4()

◆ dbatch_axpy_vec_6()

◆ dbatch_scal_vec_6()

◆ zbatch_axpy_vec_6()

◆ zbatch_scal_vec_6()

◆ dbatch_axpy_vec_8()

◆ dbatch_scal_vec_8()