 |
Octopus
|
|
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_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 | 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 | 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 279 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 389 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 456 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 525 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 534 of file batch_ops.F90.
|
private |
Definition at line 661 of file batch_ops.F90.
|
private |
Definition at line 689 of file batch_ops.F90.
|
private |
Definition at line 721 of file batch_ops.F90.
|
private |
Definition at line 748 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 784 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 847 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 1049 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 1145 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 1257 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 1275 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 1295 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 1409 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 1427 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 1453 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 1602 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 1712 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 1802 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 1840 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 1975 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 2118 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = aa*xx(ist,:) + bb*yy(ist,:) for a batch
Definition at line 2149 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch
Definition at line 2272 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch
Definition at line 2421 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 2580 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 2660 of file batch_ops.F90.
|
private |
Definition at line 2745 of file batch_ops.F90.
|
private |
Definition at line 2787 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) | map, | ||
| class(batch_t), intent(in) | xx, | ||
| real(real64), dimension(:,:), intent(inout) | array | ||
| ) |
Transfer a batch from the mesh to an array on the submesh (defined by a map)
| [in,out] | array | (psibnst_linear, submeshnp) |
Definition at line 2830 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 2876 of file batch_ops.F90.
|
private |
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 2900 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 3011 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 3095 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 3203 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 3221 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 3241 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 3368 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 3386 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 3412 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 3544 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 3654 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 3744 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 3782 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 3900 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 4018 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = aa*xx(ist,:) + bb*yy(ist,:) for a batch
Definition at line 4049 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch
Definition at line 4139 of file batch_ops.F90.
|
private |
calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch
Definition at line 4256 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 4381 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 4473 of file batch_ops.F90.
|
private |
Definition at line 4547 of file batch_ops.F90.
|
private |
Definition at line 4589 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) | map, | ||
| class(batch_t), intent(in) | xx, | ||
| complex(real64), dimension(:,:), intent(inout) | array | ||
| ) |
Transfer a batch from the mesh to an array on the submesh (defined by a map)
| [in,out] | array | (psibnst_linear, submeshnp) |
Definition at line 4632 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 4678 of file batch_ops.F90.
|
private |
| [in] | np | number of points |
| [in,out] | xx | xx(ist) = xx(ist) * aa(ist) |
Definition at line 4702 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 4810 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 4956 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 5168 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 5297 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 5495 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 5641 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 5853 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 5982 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 6180 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 6326 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 6538 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 6667 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 6865 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 7011 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 7223 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 7352 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 7550 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 7696 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 7908 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 8037 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 8244 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 8355 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 8476 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 8494 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 8514 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 8628 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 8646 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 8758 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 8849 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 8957 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 8975 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 8995 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 9122 of file batch_ops.F90.
|
private |
| [in] | async | only working with pinned memory |
Definition at line 9140 of file batch_ops.F90.
1.9.4