Octopus
batch_ops_oct_m Module Reference

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 = a*x + b*y \) More...
 
interface  batch_axpy
 batchified version of the BLAS axpy routine: \( y = a*x + y \) More...
 
interface  batch_copy_with_map
 
interface  batch_gemv
 batchified linear combination: \( y = b*y + \sum_k a_k*x_k \) More...
 
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, public batch_copy_precision (src, dst, np)
 Copy the data of a batch to another batch of the same logical shape but the opposite precision (double <-> single), casting element-wise directly on packed device or host storage, or unpacked host storage. 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_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_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,:) = aa*xx(ist,:) + bb*yy(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_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 dbatch_gemv (np, xx, aa, bb, yy, aa2, bb2, yy2)
 Linear combination of batches: yy(ist) = bb(ist) yy(ist) + sum_k aa(k, ist) xx(k)(ist) More...
 
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_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_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,:) = aa*xx(ist,:) + bb*yy(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_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 zbatch_gemv (np, xx, aa, bb, yy, aa2, bb2, yy2)
 Linear combination of batches: yy(ist) = bb(ist) yy(ist) + sum_k aa(k, ist) xx(k)(ist) More...
 
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...
 
subroutine sbatch_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 sbatch_set_state1 (this, ist, np, psi)
 Write a single state with np points into a batch at position ist. More...
 
subroutine sbatch_set_state2 (this, index, np, psi)
 Write a single state with np points into a batch at position defined by index. More...
 
subroutine sbatch_set_state3 (this, ii, np, psi)
 Write a set of state with np points into a batch. More...
 
subroutine sbatch_get_state1 (this, ist, np, psi, async)
 Write a get of state with np points from a batch. More...
 
subroutine sbatch_get_state2 (this, index, np, psi, async)
 
subroutine sbatch_get_state3 (this, ii, np, psi, async)
 
subroutine cbatch_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 cbatch_set_state1 (this, ist, np, psi)
 Write a single state with np points into a batch at position ist. More...
 
subroutine cbatch_set_state2 (this, index, np, psi)
 Write a single state with np points into a batch at position defined by index. More...
 
subroutine cbatch_set_state3 (this, ii, np, psi)
 Write a set of state with np points into a batch. More...
 
subroutine cbatch_get_state1 (this, ist, np, psi, async)
 Write a get of state with np points from a batch. More...
 
subroutine cbatch_get_state2 (this, index, np, psi, async)
 
subroutine cbatch_get_state3 (this, ii, np, psi, async)
 

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]npnumber 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]thisthe batch
[in]spstarting point
[in]epend point
[in,out]psidevice buffer for mesh function
[in]ldpsi1number of states: stnst
[in]ldpsi2states dimensions: ddim

Definition at line 374 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]thisthe batch
[in]spstarting point
[in]epend point
[in]psidevice buffer of mesh function
[in]ldpsi1number of states: stnst
[in]ldpsi2state dimensions ddim

Definition at line 441 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 510 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 519 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 646 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 674 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 706 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 733 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]npnumber of mesh points to consider
[in]xxoriginal batch (must be of type TYPE_CMPLX)
[in,out]yybatch containing real part of xx (must be of type TYPE_FLOAT)
[in,out]zzbatch containing imaginary part of xx (must be of type TYPE_FLOAT)

Definition at line 769 of file batch_ops.F90.

◆ batch_copy_precision()

subroutine, public batch_ops_oct_m::batch_copy_precision ( class(batch_t), intent(in)  src,
class(batch_t), intent(inout)  dst,
integer, intent(in)  np 
)

Copy the data of a batch to another batch of the same logical shape but the opposite precision (double <-> single), casting element-wise directly on packed device or host storage, or unpacked host storage.

src and dst must have the same nst_linear, the same real/complex character and the same packing status; exactly one of them is single precision. Only the first np points and the nst_linear real states are copied (padding is left untouched).

One handle per kernel, indexed by (real/complex, to_double/to_single): accel_kernel_start_call() is a no-op once a handle is initialized, so a single shared handle would keep running whichever kernel was built first.

Definition at line 835 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]npnumber of points
[in,out]yyyy(:,:) = aa*xx(:,:) + yy(:,:)

Definition at line 1037 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]thisbatch to write the state to
[in]istposition where to write
[in]npnumber of points
[in]psithe state to write

Definition at line 1133 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]thisbatch to write the state into
[in]indexhow to access the state. For further information see batch_ops_oct_m::batch_set_state
[in]npnumber of points
[in]psistate to write to the batch

Definition at line 1245 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]thisbatch to write the states into
[in]iiposition
[in]npnumber of points
[in]psistates to write

Definition at line 1263 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]asynconly working with pinned memory

Definition at line 1283 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]asynconly working with pinned memory

Definition at line 1397 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]asynconly working with pinned memory

Definition at line 1415 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 1441 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]npnumber of points
[in]xxinput batch
[in,out]psiresult: \( psi = \sum_{ist=1}^{nst} aa(ist) * xx(ist) \)
[in]aaarray of multipliers
[in]nstoptional upper bound of sum

Definition at line 1590 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]npnumber of points
[in]aaarray of multipliers
[in]psimesh functions psi
[in,out]yyresulting batch yy(ist) = yy(ist) + aa(ist) * psi

Definition at line 1700 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa

Definition at line 1790 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 1828 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]npnumber of points
[in]aaarray of constants aa(ist)
[in,out]yyyy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:)

Definition at line 1963 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]npnumber of points
[in,out]yyyy(ist) = xx(ist) + a*yy(ist)

Definition at line 2106 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 2137 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 2260 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 2409 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]thisthe batch to get points from
[in]spstarting point
[in]epend point
[in,out]psimesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 2568 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]thisthe batch to write points into
[in]spstarting point
[in]epend point
[in]psimesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 2648 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 2733 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 2775 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), contiguous  map,
class(batch_t), intent(in)  xx,
real(real64), dimension(:,:), intent(inout), contiguous  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 2818 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs aa of size st:nst?

Definition at line 2864 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 2888 of file batch_ops.F90.

◆ dbatch_gemv()

subroutine batch_ops_oct_m::dbatch_gemv ( integer, intent(in)  np,
type(batch_p_t), dimension(:), intent(in)  xx,
real(real64), dimension(:, :), intent(in)  aa,
real(real64), dimension(:), intent(in)  bb,
class(batch_t), intent(inout)  yy,
real(real64), dimension(:, :), intent(in), optional  aa2,
real(real64), dimension(:), intent(in), optional  bb2,
class(batch_t), intent(inout), optional  yy2 
)
private

Linear combination of batches: yy(ist) = bb(ist) yy(ist) + sum_k aa(k, ist) xx(k)(ist)

The coefficients are indexed by the states of the batch, 1:yynst. With aa2, bb2 and yy2, a second combination of the same xx is computed. For packed batches on the CPU, each xx is then read only once for both results.

Parameters
[in]aa(1:size(xx), 1:yynst)
[in]bb(1:yynst)

Definition at line 2919 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]npnumber of points
[in,out]yyyy(:,:) = aa*xx(:,:) + yy(:,:)

Definition at line 3130 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]thisbatch to write the state to
[in]istposition where to write
[in]npnumber of points
[in]psithe state to write

Definition at line 3214 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]thisbatch to write the state into
[in]indexhow to access the state. For further information see batch_ops_oct_m::batch_set_state
[in]npnumber of points
[in]psistate to write to the batch

Definition at line 3322 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]thisbatch to write the states into
[in]iiposition
[in]npnumber of points
[in]psistates to write

Definition at line 3340 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]asynconly working with pinned memory

Definition at line 3360 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]asynconly working with pinned memory

Definition at line 3487 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]asynconly working with pinned memory

Definition at line 3505 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 3531 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]npnumber of points
[in]xxinput batch
[in,out]psiresult: \( psi = \sum_{ist=1}^{nst} aa(ist) * xx(ist) \)
[in]aaarray of multipliers
[in]nstoptional upper bound of sum

Definition at line 3663 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]npnumber of points
[in]aaarray of multipliers
[in]psimesh functions psi
[in,out]yyresulting batch yy(ist) = yy(ist) + aa(ist) * psi

Definition at line 3773 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa

Definition at line 3863 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 3901 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]npnumber of points
[in]aaarray of constants aa(ist)
[in,out]yyyy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:)

Definition at line 4019 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]npnumber of points
[in,out]yyyy(ist) = xx(ist) + a*yy(ist)

Definition at line 4137 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 4168 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 4258 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 4375 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]thisthe batch to get points from
[in]spstarting point
[in]epend point
[in,out]psimesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 4500 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]thisthe batch to write points into
[in]spstarting point
[in]epend point
[in]psimesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 4592 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 4666 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 4708 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), contiguous  map,
class(batch_t), intent(in)  xx,
complex(real64), dimension(:,:), intent(inout), contiguous  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 4751 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs aa of size st:nst?

Definition at line 4797 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 4821 of file batch_ops.F90.

◆ zbatch_gemv()

subroutine batch_ops_oct_m::zbatch_gemv ( integer, intent(in)  np,
type(batch_p_t), dimension(:), intent(in)  xx,
complex(real64), dimension(:, :), intent(in)  aa,
complex(real64), dimension(:), intent(in)  bb,
class(batch_t), intent(inout)  yy,
complex(real64), dimension(:, :), intent(in), optional  aa2,
complex(real64), dimension(:), intent(in), optional  bb2,
class(batch_t), intent(inout), optional  yy2 
)
private

Linear combination of batches: yy(ist) = bb(ist) yy(ist) + sum_k aa(k, ist) xx(k)(ist)

The coefficients are indexed by the states of the batch, 1:yynst. With aa2, bb2 and yy2, a second combination of the same xx is computed. For packed batches on the CPU, each xx is then read only once for both results.

Parameters
[in]aa(1:size(xx), 1:yynst)
[in]bb(1:yynst)

Definition at line 4852 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 5060 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 5206 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 5418 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 5547 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 5745 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 5891 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 6103 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 6232 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 6430 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 6576 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 6788 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 6917 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 7115 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 7261 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 7473 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 7602 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 7800 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 7946 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]npnumber of points
[in]aaarray of multipliers
[in,out]yyy(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]a_startfirst state to operate on (default = 1)
[in]a_fullIs 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 8158 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]npnumber of points
[in,out]xxxx(ist) = xx(ist) * aa(ist)

Definition at line 8287 of file batch_ops.F90.

◆ sbatch_axpy_const()

subroutine batch_ops_oct_m::sbatch_axpy_const ( integer, intent(in)  np,
real(real32), 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]npnumber of points
[in,out]yyyy(:,:) = aa*xx(:,:) + yy(:,:)

Definition at line 8494 of file batch_ops.F90.

◆ sbatch_set_state1()

subroutine batch_ops_oct_m::sbatch_set_state1 ( class(batch_t), intent(inout)  this,
integer, intent(in)  ist,
integer, intent(in)  np,
real(real32), dimension(:), intent(in), contiguous  psi 
)
private

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

Parameters
[in,out]thisbatch to write the state to
[in]istposition where to write
[in]npnumber of points
[in]psithe state to write

Definition at line 8605 of file batch_ops.F90.

◆ sbatch_set_state2()

subroutine batch_ops_oct_m::sbatch_set_state2 ( class(batch_t), intent(inout)  this,
integer, dimension(:), intent(in)  index,
integer, intent(in)  np,
real(real32), dimension(:), intent(in), contiguous  psi 
)
private

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

Parameters
[in,out]thisbatch to write the state into
[in]indexhow to access the state. For further information see batch_ops_oct_m::batch_set_state
[in]npnumber of points
[in]psistate to write to the batch

Definition at line 8726 of file batch_ops.F90.

◆ sbatch_set_state3()

subroutine batch_ops_oct_m::sbatch_set_state3 ( class(batch_t), intent(inout)  this,
integer, intent(in)  ii,
integer, intent(in)  np,
real(real32), dimension(:, :), intent(in), contiguous  psi 
)
private

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

Parameters
[in,out]thisbatch to write the states into
[in]iiposition
[in]npnumber of points
[in]psistates to write

Definition at line 8744 of file batch_ops.F90.

◆ sbatch_get_state1()

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

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

Parameters
[in]asynconly working with pinned memory

Definition at line 8764 of file batch_ops.F90.

◆ sbatch_get_state2()

subroutine batch_ops_oct_m::sbatch_get_state2 ( class(batch_t), intent(in)  this,
integer, dimension(:), intent(in)  index,
integer, intent(in)  np,
real(real32), dimension(:), intent(out), contiguous  psi,
logical, intent(in), optional  async 
)
private
Parameters
[in]asynconly working with pinned memory

Definition at line 8878 of file batch_ops.F90.

◆ sbatch_get_state3()

subroutine batch_ops_oct_m::sbatch_get_state3 ( class(batch_t), intent(in)  this,
integer, intent(in)  ii,
integer, intent(in)  np,
real(real32), dimension(:, :), intent(out), contiguous  psi,
logical, intent(in), optional  async 
)
private
Parameters
[in]asynconly working with pinned memory

Definition at line 8896 of file batch_ops.F90.

◆ cbatch_axpy_const()

subroutine batch_ops_oct_m::cbatch_axpy_const ( integer, intent(in)  np,
complex(real32), 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]npnumber of points
[in,out]yyyy(:,:) = aa*xx(:,:) + yy(:,:)

Definition at line 9008 of file batch_ops.F90.

◆ cbatch_set_state1()

subroutine batch_ops_oct_m::cbatch_set_state1 ( class(batch_t), intent(inout)  this,
integer, intent(in)  ist,
integer, intent(in)  np,
complex(real32), dimension(:), intent(in), contiguous  psi 
)
private

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

Parameters
[in,out]thisbatch to write the state to
[in]istposition where to write
[in]npnumber of points
[in]psithe state to write

Definition at line 9099 of file batch_ops.F90.

◆ cbatch_set_state2()

subroutine batch_ops_oct_m::cbatch_set_state2 ( class(batch_t), intent(inout)  this,
integer, dimension(:), intent(in)  index,
integer, intent(in)  np,
complex(real32), dimension(:), intent(in), contiguous  psi 
)
private

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

Parameters
[in,out]thisbatch to write the state into
[in]indexhow to access the state. For further information see batch_ops_oct_m::batch_set_state
[in]npnumber of points
[in]psistate to write to the batch

Definition at line 9207 of file batch_ops.F90.

◆ cbatch_set_state3()

subroutine batch_ops_oct_m::cbatch_set_state3 ( class(batch_t), intent(inout)  this,
integer, intent(in)  ii,
integer, intent(in)  np,
complex(real32), dimension(:, :), intent(in), contiguous  psi 
)
private

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

Parameters
[in,out]thisbatch to write the states into
[in]iiposition
[in]npnumber of points
[in]psistates to write

Definition at line 9225 of file batch_ops.F90.

◆ cbatch_get_state1()

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

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

Parameters
[in]asynconly working with pinned memory

Definition at line 9245 of file batch_ops.F90.

◆ cbatch_get_state2()

subroutine batch_ops_oct_m::cbatch_get_state2 ( class(batch_t), intent(in)  this,
integer, dimension(:), intent(in)  index,
integer, intent(in)  np,
complex(real32), dimension(:), intent(out), contiguous  psi,
logical, intent(in), optional  async 
)
private
Parameters
[in]asynconly working with pinned memory

Definition at line 9372 of file batch_ops.F90.

◆ cbatch_get_state3()

subroutine batch_ops_oct_m::cbatch_get_state3 ( class(batch_t), intent(in)  this,
integer, intent(in)  ii,
integer, intent(in)  np,
complex(real32), dimension(:, :), intent(out), contiguous  psi,
logical, intent(in), optional  async 
)
private
Parameters
[in]asynconly working with pinned memory

Definition at line 9390 of file batch_ops.F90.