![]() |
Octopus
|
This module implements common operations on batches of mesh functions. More...
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) |
| 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
| [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.
|
private |
GPU version of batch_get_points.
| [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 374 of file batch_ops.F90.
|
private |
GPU version of batch_set_points.
| [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 441 of file batch_ops.F90.
| 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.
|
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.
|
private |
Definition at line 646 of file batch_ops.F90.
|
private |
Definition at line 674 of file batch_ops.F90.
|
private |
Definition at line 706 of file batch_ops.F90.
|
private |
Definition at line 733 of file batch_ops.F90.
| 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
| [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 769 of file batch_ops.F90.
| 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.
|
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.
| [in] | np | number of points |
| [in,out] | yy | yy(:,:) = aa*xx(:,:) + yy(:,:) |
Definition at line 1037 of file batch_ops.F90.
|
private |
Write a single state with np points into a batch at position ist.
| [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 1133 of file batch_ops.F90.
|
private |
Write a single state with np points into a batch at position defined by index.
| [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 1245 of file batch_ops.F90.
|
private |
Write a set of state with np points into a batch.
| [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 1263 of file batch_ops.F90.
|
private |
Write a get of state with np points from a batch.
| [in] | async | only working with pinned memory |
Definition at line 1283 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 1397 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 1415 of file batch_ops.F90.
|
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.
| [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 1441 of file batch_ops.F90.
| 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.
| [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 1590 of file batch_ops.F90.
| 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),.
| [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 1700 of file batch_ops.F90.
|
private |
scale all functions in a batch by constant aa
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa |
Definition at line 1790 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 1828 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch
| [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 1963 of file batch_ops.F90.
|
private |
calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch
| [in] | np | number of points |
| [in,out] | yy | yy(ist) = xx(ist) + a*yy(ist) |
Definition at line 2106 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = aa*xx(ist,:) + bb*yy(ist,:) for a batch
Definition at line 2137 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch
Definition at line 2260 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch
Definition at line 2409 of file batch_ops.F90.
|
private |
copy a set of points into a mesh function
| [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 2568 of file batch_ops.F90.
|
private |
copy a set of points into a mesh function
| [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 2648 of file batch_ops.F90.
|
private |
Definition at line 2733 of file batch_ops.F90.
|
private |
Definition at line 2775 of file batch_ops.F90.
| 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)
| [in,out] | array | (psibnst_linear, submeshnp) |
Definition at line 2818 of file batch_ops.F90.
|
private |
A simple switch between specialized kernels and generic kernels.
| [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 2864 of file batch_ops.F90.
|
private |
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 2888 of file batch_ops.F90.
|
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.
| [in] | aa | (1:size(xx), 1:yynst) |
| [in] | bb | (1:yynst) |
Definition at line 2919 of file batch_ops.F90.
|
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.
| [in] | np | number of points |
| [in,out] | yy | yy(:,:) = aa*xx(:,:) + yy(:,:) |
Definition at line 3130 of file batch_ops.F90.
|
private |
Write a single state with np points into a batch at position ist.
| [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 3214 of file batch_ops.F90.
|
private |
Write a single state with np points into a batch at position defined by index.
| [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 3322 of file batch_ops.F90.
|
private |
Write a set of state with np points into a batch.
| [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 3340 of file batch_ops.F90.
|
private |
Write a get of state with np points from a batch.
| [in] | async | only working with pinned memory |
Definition at line 3360 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 3487 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 3505 of file batch_ops.F90.
|
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.
| [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 3531 of file batch_ops.F90.
| 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.
| [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 3663 of file batch_ops.F90.
| 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),.
| [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 3773 of file batch_ops.F90.
|
private |
scale all functions in a batch by constant aa
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa |
Definition at line 3863 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 3901 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch
| [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 4019 of file batch_ops.F90.
|
private |
calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch
| [in] | np | number of points |
| [in,out] | yy | yy(ist) = xx(ist) + a*yy(ist) |
Definition at line 4137 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = aa*xx(ist,:) + bb*yy(ist,:) for a batch
Definition at line 4168 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch
Definition at line 4258 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch
Definition at line 4375 of file batch_ops.F90.
|
private |
copy a set of points into a mesh function
| [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 4500 of file batch_ops.F90.
|
private |
copy a set of points into a mesh function
| [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 4592 of file batch_ops.F90.
|
private |
Definition at line 4666 of file batch_ops.F90.
|
private |
Definition at line 4708 of file batch_ops.F90.
| 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)
| [in,out] | array | (psibnst_linear, submeshnp) |
Definition at line 4751 of file batch_ops.F90.
|
private |
A simple switch between specialized kernels and generic kernels.
| [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 4797 of file batch_ops.F90.
|
private |
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 4821 of file batch_ops.F90.
|
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.
| [in] | aa | (1:size(xx), 1:yynst) |
| [in] | bb | (1:yynst) |
Definition at line 4852 of file batch_ops.F90.
|
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.
| [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 5060 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 5206 of file batch_ops.F90.
|
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.
| [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 5418 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 5547 of file batch_ops.F90.
|
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.
| [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 5745 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 5891 of file batch_ops.F90.
|
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.
| [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 6103 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 6232 of file batch_ops.F90.
|
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.
| [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 6430 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 6576 of file batch_ops.F90.
|
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.
| [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 6788 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 6917 of file batch_ops.F90.
|
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.
| [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 7115 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 7261 of file batch_ops.F90.
|
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.
| [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 7473 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 7602 of file batch_ops.F90.
|
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.
| [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 7800 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 7946 of file batch_ops.F90.
|
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.
| [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 8158 of file batch_ops.F90.
|
private |
scale all functions in a batch by state dependent constant
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 8287 of file batch_ops.F90.
|
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.
| [in] | np | number of points |
| [in,out] | yy | yy(:,:) = aa*xx(:,:) + yy(:,:) |
Definition at line 8494 of file batch_ops.F90.
|
private |
Write a single state with np points into a batch at position ist.
| [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 8605 of file batch_ops.F90.
|
private |
Write a single state with np points into a batch at position defined by index.
| [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 8726 of file batch_ops.F90.
|
private |
Write a set of state with np points into a batch.
| [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 8744 of file batch_ops.F90.
|
private |
Write a get of state with np points from a batch.
| [in] | async | only working with pinned memory |
Definition at line 8764 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 8878 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 8896 of file batch_ops.F90.
|
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.
| [in] | np | number of points |
| [in,out] | yy | yy(:,:) = aa*xx(:,:) + yy(:,:) |
Definition at line 9008 of file batch_ops.F90.
|
private |
Write a single state with np points into a batch at position ist.
| [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 9099 of file batch_ops.F90.
|
private |
Write a single state with np points into a batch at position defined by index.
| [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 9207 of file batch_ops.F90.
|
private |
Write a set of state with np points into a batch.
| [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 9225 of file batch_ops.F90.
|
private |
Write a get of state with np points from a batch.
| [in] | async | only working with pinned memory |
Definition at line 9245 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 9372 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 9390 of file batch_ops.F90.