Data Types
type	poisson_t

Functions/Subroutines
subroutine, public	poisson_init (this, namespace, space, der, mc, stencil, qtot, label, solver, verbose, force_serial, force_cmplx, fft_batch_size)

subroutine, public	poisson_end (this)

subroutine	zpoisson_solve_real_and_imag_separately (this, namespace, pot, rho, all_nodes, kernel)

subroutine	zpoisson_solve_real_and_imag_separately_batch (this, namespace, pot, rho, kernel)
	Batched analogue of zpoisson_solve_real_and_imag_separately. More...

subroutine	zpoisson_solve_real_and_imag_separately_accel (this, namespace, pot_buffer, rho_buffer, kernel, count)
	Device variant of zpoisson_solve_real_and_imag_separately. More...

subroutine, public	zpoisson_solve (this, namespace, pot, rho, all_nodes, kernel, reset)

subroutine, public	poisson_solve_batch (this, namespace, potb, rhob, all_nodes, kernel)

logical function	poisson_is_batch_capable (this)
	Whether this solver can transform a whole batch of functions in one call. More...

logical function, public	poisson_is_device_batch_capable (this)
	Whether a batch can be solved with the densities and potentials kept on the device. More...

subroutine, public	dpoisson_solve (this, namespace, pot, rho, all_nodes, kernel, reset)
	Calculates the Poisson equation. Given the density returns the corresponding potential. More...

subroutine, public	poisson_init_sm (this, namespace, space, main, der, sm, grp, method, force_cmplx)

logical pure function	poisson_solver_is_iterative (this)

subroutine, public	poisson_async_init (this, mc)

subroutine, public	poisson_async_end (this, mc)

subroutine, public	poisson_slave_work (this, namespace)

logical pure function, public	poisson_is_async (this)

subroutine, public	poisson_build_kernel (this, namespace, space, coulb, qq, cam, singul)

real(real64) function, public	poisson_get_full_range_weight (this, cam)
	Most Poisson solvers do not implement Coulomb attenuated potentials, and can only be used for global hybrids like PBE0. For these ones, this routine returns the weight of the full-range hybrids. More...

subroutine	poisson_kernel_init (this, namespace, space, mc, stencil)

subroutine	poisson_solve_direct (this, namespace, pot, rho)

subroutine	dpoisson_solve_direct_sm (this, namespace, sm, pot, rho)

subroutine	zpoisson_solve_direct_sm (this, namespace, sm, pot, rho)

subroutine, public	dpoisson_solve_start (this, rho)

subroutine, public	dpoisson_solve_finish (this, pot)

subroutine, public	dpoisson_solve_sm (this, namespace, sm, pot, rho, all_nodes)
	Calculates the Poisson equation. Given the density returns the corresponding potential. More...

subroutine, public	dpoisson_solve_batch (this, namespace, pot, rho, kernel, all_nodes, pot_buffer, rho_buffer, count)
	Solves the Poisson equation for batched quantities, using fast Fourier transforms (FFTs). More...

subroutine, public	zpoisson_solve_start (this, rho)

subroutine, public	zpoisson_solve_finish (this, pot)

subroutine, public	zpoisson_solve_sm (this, namespace, sm, pot, rho, all_nodes)
	Calculates the Poisson equation. Given the density returns the corresponding potential. More...

subroutine, public	zpoisson_solve_batch (this, namespace, pot, rho, kernel, all_nodes, pot_buffer, rho_buffer, count)
	Solves the Poisson equation for batched quantities, using fast Fourier transforms (FFTs). More...

Variables
integer, parameter, public	poisson_direct_sum = -1

integer, parameter, public	poisson_fft = 0

integer, parameter, public	poisson_cg = 5

integer, parameter, public	poisson_cg_corrected = 6

integer, parameter, public	poisson_multigrid = 7

integer, parameter, public	poisson_isf = 8

integer, parameter, public	poisson_psolver = 10

integer, parameter, public	poisson_no = -99

integer, parameter, public	poisson_null = -999

integer, parameter	cmd_finish = 1

integer, parameter	cmd_poisson_solve = 2

Function/Subroutine Documentation

◆ poisson_init()

subroutine, public poisson_oct_m::poisson_init	(	type(poisson_t), intent(inout)	this,
		type(namespace_t), intent(in)	namespace,
		class(space_t), intent(in)	space,
		type(derivatives_t), intent(in), target	der,
		type(multicomm_t), intent(in)	mc,
		type(stencil_t), intent(in)	stencil,
		real(real64), intent(in), optional	qtot,
		character(len=*), intent(in), optional	label,
		integer, intent(in), optional	solver,
		logical, intent(in), optional	verbose,
		logical, intent(in), optional	force_serial,
		logical, intent(in), optional	force_cmplx,
		integer, intent(in), optional	fft_batch_size
	)

Parameters

[in]	qtot	total charge
[in]	fft_batch_size	Number of FFTs solved at once

Definition at line 234 of file poisson.F90.

◆ poisson_end()

subroutine, public poisson_oct_m::poisson_end ( type(poisson_t), intent(inout) this )

Definition at line 690 of file poisson.F90.

◆ zpoisson_solve_real_and_imag_separately()

subroutine poisson_oct_m::zpoisson_solve_real_and_imag_separately	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		complex(real64), dimension(:), intent(inout), contiguous	pot,
		complex(real64), dimension(:), intent(in), contiguous	rho,
		logical, intent(in), optional	all_nodes,
		type(fourier_space_op_t), intent(in), optional	kernel
	)

private

Parameters

[in,out]	pot	pot(meshnp)
[in]	rho	rho(meshnp)

Definition at line 743 of file poisson.F90.

◆ zpoisson_solve_real_and_imag_separately_batch()

subroutine poisson_oct_m::zpoisson_solve_real_and_imag_separately_batch	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		complex(real64), dimension(:, :), intent(out), contiguous	pot,
		complex(real64), dimension(:, :), intent(in), contiguous	rho,
		type(fourier_space_op_t), intent(in), optional	kernel
	)

private

Batched analogue of zpoisson_solve_real_and_imag_separately.

Solves a batch of complex codensities on a real FFT cube by transforming the real and imaginary parts independently with the real batched FFT and recombining. Used by the batched exchange path when the cube was sized for the real ground state (e.g. TD OEP/KLI exchange).

Definition at line 802 of file poisson.F90.

◆ zpoisson_solve_real_and_imag_separately_accel()

subroutine poisson_oct_m::zpoisson_solve_real_and_imag_separately_accel	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		type(accel_mem_t), intent(inout)	pot_buffer,
		type(accel_mem_t), intent(in)	rho_buffer,
		type(fourier_space_op_t), intent(in), optional	kernel,
		integer, intent(in), optional	count
	)

private

Device variant of zpoisson_solve_real_and_imag_separately.

Parameters

[in] count number of functions (default 1)

Definition at line 841 of file poisson.F90.

◆ zpoisson_solve()

subroutine, public poisson_oct_m::zpoisson_solve	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		complex(real64), dimension(:), intent(inout), contiguous	pot,
		complex(real64), dimension(:), intent(in), contiguous	rho,
		logical, intent(in), optional	all_nodes,
		type(fourier_space_op_t), intent(in), optional	kernel,
		logical, intent(in), optional	reset
	)

Parameters

[in,out]	pot	pot(meshnp)
[in]	rho	rho(meshnp)
[in]	reset	For iterative solvers, we can decide to reset or not the potential

Definition at line 910 of file poisson.F90.

◆ poisson_solve_batch()

subroutine, public poisson_oct_m::poisson_solve_batch	(	type(poisson_t), intent(inout)	this,
		type(namespace_t), intent(in)	namespace,
		type(batch_t), intent(inout)	potb,
		type(batch_t), intent(inout)	rhob,
		logical, intent(in), optional	all_nodes,
		type(fourier_space_op_t), intent(in), optional	kernel
	)

Definition at line 956 of file poisson.F90.

◆ poisson_is_batch_capable()

logical function poisson_oct_m::poisson_is_batch_capable ( type(poisson_t), intent(in) this )

private

Whether this solver can transform a whole batch of functions in one call.

Only the plain FFT solver can; the corrected kernel needs a per-function density correction. This does not check the batch capacity of the cube: a capable solver whose cube holds a single function is still solved one function at a time.

Definition at line 990 of file poisson.F90.

◆ poisson_is_device_batch_capable()

logical function, public poisson_oct_m::poisson_is_device_batch_capable ( type(poisson_t), intent(in) this )

Whether a batch can be solved with the densities and potentials kept on the device.

Definition at line 999 of file poisson.F90.

◆ dpoisson_solve()

subroutine, public poisson_oct_m::dpoisson_solve	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		real(real64), dimension(:), intent(inout), contiguous	pot,
		real(real64), dimension(:), intent(in), contiguous	rho,
		logical, intent(in), optional	all_nodes,
		type(fourier_space_op_t), intent(in), optional	kernel,
		logical, intent(in), optional	reset
	)

Calculates the Poisson equation. Given the density returns the corresponding potential.

Different solvers are available that can be chosen in the input file with the "PoissonSolver" parameter

Parameters

[in,out]	pot	Local size of the potential vector.
[in]	rho	Local size of the density (rho) vector.
[in]	all_nodes	Is the Poisson solver allowed to utilise all nodes or only the domain nodes for its calculations? (Defaults to .true.)
[in]	reset	For iterative solvers, we can decide to reset or not the potential

Definition at line 1017 of file poisson.F90.

◆ poisson_init_sm()

subroutine, public poisson_oct_m::poisson_init_sm	(	type(poisson_t), intent(inout)	this,
		type(namespace_t), intent(in)	namespace,
		class(space_t), intent(in)	space,
		type(poisson_t), intent(in)	main,
		type(derivatives_t), intent(in), target	der,
		type(submesh_t), intent(inout)	sm,
		type(mpi_grp_t), intent(in)	grp,
		integer, intent(in), optional	method,
		logical, intent(in), optional	force_cmplx
	)

Definition at line 1123 of file poisson.F90.

◆ poisson_solver_is_iterative()

logical pure function poisson_oct_m::poisson_solver_is_iterative ( type(poisson_t), intent(in) this )

private

Definition at line 1227 of file poisson.F90.

◆ poisson_async_init()

subroutine, public poisson_oct_m::poisson_async_init	(	type(poisson_t), intent(inout)	this,
		type(multicomm_t), intent(in)	mc
	)

Definition at line 1234 of file poisson.F90.

◆ poisson_async_end()

subroutine, public poisson_oct_m::poisson_async_end	(	type(poisson_t), intent(inout)	this,
		type(multicomm_t), intent(in)	mc
	)

Definition at line 1246 of file poisson.F90.

◆ poisson_slave_work()

subroutine, public poisson_oct_m::poisson_slave_work	(	type(poisson_t), intent(inout)	this,
		type(namespace_t), intent(in)	namespace
	)

Definition at line 1262 of file poisson.F90.

◆ poisson_is_async()

logical pure function, public poisson_oct_m::poisson_is_async ( type(poisson_t), intent(in) this )

Definition at line 1270 of file poisson.F90.

◆ poisson_build_kernel()

subroutine, public poisson_oct_m::poisson_build_kernel	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		class(space_t), intent(in)	space,
		type(fourier_space_op_t), intent(inout)	coulb,
		real(real64), dimension(:), intent(in)	qq,
		type(xc_cam_t), intent(in)	cam,
		real(real64), intent(in), optional	singul
	)

Definition at line 1279 of file poisson.F90.

◆ poisson_get_full_range_weight()

real(real64) function, public poisson_oct_m::poisson_get_full_range_weight	(	type(poisson_t), intent(in)	this,
		type(xc_cam_t), intent(in)	cam
	)

Most Poisson solvers do not implement Coulomb attenuated potentials, and can only be used for global hybrids like PBE0. For these ones, this routine returns the weight of the full-range hybrids.

If the Poisson solver supports CAM hybrids, the returned weight is 1.

For purely short-range, or purely long-range, the corresponding weight is also returned, such that Poisson solvers that support these cases (like ISF) can also be used correctly.

Definition at line 1343 of file poisson.F90.

◆ poisson_kernel_init()

subroutine poisson_oct_m::poisson_kernel_init	(	type(poisson_t), intent(inout)	this,
		type(namespace_t), intent(in)	namespace,
		class(space_t), intent(in)	space,
		type(multicomm_t), intent(in)	mc,
		type(stencil_t), intent(in)	stencil
	)

private

Definition at line 1383 of file poisson.F90.

◆ poisson_solve_direct()

subroutine poisson_oct_m::poisson_solve_direct	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		real(real64), dimension(:), intent(out)	pot,
		real(real64), dimension(:), intent(in)	rho
	)

private

Definition at line 1594 of file poisson.F90.

◆ dpoisson_solve_direct_sm()

subroutine poisson_oct_m::dpoisson_solve_direct_sm	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		type(submesh_t), intent(in)	sm,
		real(real64), dimension(:), intent(out)	pot,
		real(real64), dimension(:), intent(in)	rho
	)

private

Definition at line 1843 of file poisson.F90.

◆ zpoisson_solve_direct_sm()

subroutine poisson_oct_m::zpoisson_solve_direct_sm	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		type(submesh_t), intent(in)	sm,
		complex(real64), dimension(:), intent(out)	pot,
		complex(real64), dimension(:), intent(in)	rho
	)

private

Parameters

[out]	pot	pot(meshnp)
[in]	rho	rho(meshnp)

Definition at line 2042 of file poisson.F90.

◆ dpoisson_solve_start()

subroutine, public poisson_oct_m::dpoisson_solve_start	(	type(poisson_t), intent(in)	this,
		real(real64), dimension(:), intent(in), contiguous	rho
	)

Definition at line 2148 of file poisson.F90.

◆ dpoisson_solve_finish()

subroutine, public poisson_oct_m::dpoisson_solve_finish	(	type(poisson_t), intent(in)	this,
		real(real64), dimension(:), intent(inout), contiguous	pot
	)

Definition at line 2156 of file poisson.F90.

◆ dpoisson_solve_sm()

subroutine, public poisson_oct_m::dpoisson_solve_sm	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		type(submesh_t), intent(in)	sm,
		real(real64), dimension(:), intent(inout), contiguous	pot,
		real(real64), dimension(:), intent(inout), contiguous	rho,
		logical, intent(in), optional	all_nodes
	)

Calculates the Poisson equation. Given the density returns the corresponding potential.

Different solvers are available that can be chosen in the input file with the "PoissonSolver" parameter

Parameters

[in,out]	pot	Local size of the potential vector.
[in,out]	rho	Local size of the density (rho) vector.
[in]	all_nodes	Is the Poisson solver allowed to utilise all nodes or only the domain nodes for its calculations? (Defaults to .false.)

Definition at line 2168 of file poisson.F90.

◆ dpoisson_solve_batch()

subroutine, public poisson_oct_m::dpoisson_solve_batch	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		real(real64), dimension(:, :), intent(out), optional, contiguous	pot,
		real(real64), dimension(:, :), intent(in), optional, contiguous	rho,
		type(fourier_space_op_t), intent(in), optional	kernel,
		logical, intent(in), optional	all_nodes,
		type(accel_mem_t), intent(inout), optional	pot_buffer,
		type(accel_mem_t), intent(in), optional	rho_buffer,
		integer, intent(in), optional	count
	)

Solves the Poisson equation for batched quantities, using fast Fourier transforms (FFTs).

Given a batch of input densities \(\rho(\mathbf r)\), computes the corresponding electrostatic potentials \(v(\mathbf r)\) satisfying:

\[ \nabla^2 v(\mathbf r) = -4\pi \rho(\mathbf r). \]

If a Fourier-space kernel is supplied, it is used for the reciprocal-space application of the Coulomb operator.

The use of the CPU or GPU path is determined by the presence of device-resident buffers (pot_buffer/rho_buffer) or host arrays (pot/rho).

Parameters

[out]	pot	Computed potentials (host)
[in]	rho	Input densities (host)
[in]	kernel	Optional Fourier-space operator defining the Coulomb kernel to apply when the Poisson solver is an FFT.
[in]	all_nodes	Only used by the per-function fallback
[in]	count	number of functions on the device (default 1)

Definition at line 2247 of file poisson.F90.

◆ zpoisson_solve_start()

subroutine, public poisson_oct_m::zpoisson_solve_start	(	type(poisson_t), intent(in)	this,
		complex(real64), dimension(:), intent(in), contiguous	rho
	)

Definition at line 2404 of file poisson.F90.

◆ zpoisson_solve_finish()

subroutine, public poisson_oct_m::zpoisson_solve_finish	(	type(poisson_t), intent(in)	this,
		complex(real64), dimension(:), intent(inout), contiguous	pot
	)

Definition at line 2412 of file poisson.F90.

◆ zpoisson_solve_sm()

subroutine, public poisson_oct_m::zpoisson_solve_sm	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		type(submesh_t), intent(in)	sm,
		complex(real64), dimension(:), intent(inout), contiguous	pot,
		complex(real64), dimension(:), intent(inout), contiguous	rho,
		logical, intent(in), optional	all_nodes
	)

Calculates the Poisson equation. Given the density returns the corresponding potential.

Different solvers are available that can be chosen in the input file with the "PoissonSolver" parameter

Parameters

[in,out]	pot	Local size of the potential vector.
[in,out]	rho	Local size of the density (rho) vector.
[in]	all_nodes	Is the Poisson solver allowed to utilise all nodes or only the domain nodes for its calculations? (Defaults to .false.)

Definition at line 2424 of file poisson.F90.

◆ zpoisson_solve_batch()

subroutine, public poisson_oct_m::zpoisson_solve_batch	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		complex(real64), dimension(:, :), intent(out), optional, contiguous	pot,
		complex(real64), dimension(:, :), intent(in), optional, contiguous	rho,
		type(fourier_space_op_t), intent(in), optional	kernel,
		logical, intent(in), optional	all_nodes,
		type(accel_mem_t), intent(inout), optional	pot_buffer,
		type(accel_mem_t), intent(in), optional	rho_buffer,
		integer, intent(in), optional	count
	)

Solves the Poisson equation for batched quantities, using fast Fourier transforms (FFTs).

Given a batch of input densities \(\rho(\mathbf r)\), computes the corresponding electrostatic potentials \(v(\mathbf r)\) satisfying:

\[ \nabla^2 v(\mathbf r) = -4\pi \rho(\mathbf r). \]

If a Fourier-space kernel is supplied, it is used for the reciprocal-space application of the Coulomb operator.

The use of the CPU or GPU path is determined by the presence of device-resident buffers (pot_buffer/rho_buffer) or host arrays (pot/rho).

Parameters

[out]	pot	Computed potentials (host)
[in]	rho	Input densities (host)
[in]	kernel	Optional Fourier-space operator defining the Coulomb kernel to apply when the Poisson solver is an FFT.
[in]	all_nodes	Only used by the per-function fallback
[in]	count	number of functions on the device (default 1)

Definition at line 2559 of file poisson.F90.

Variable Documentation

◆ poisson_direct_sum

integer, parameter, public poisson_oct_m::poisson_direct_sum = -1

Definition at line 191 of file poisson.F90.

◆ poisson_fft

integer, parameter, public poisson_oct_m::poisson_fft = 0

Definition at line 191 of file poisson.F90.

◆ poisson_cg

integer, parameter, public poisson_oct_m::poisson_cg = 5

Definition at line 191 of file poisson.F90.

◆ poisson_cg_corrected

integer, parameter, public poisson_oct_m::poisson_cg_corrected = 6

Definition at line 191 of file poisson.F90.

◆ poisson_multigrid

integer, parameter, public poisson_oct_m::poisson_multigrid = 7

Definition at line 191 of file poisson.F90.

◆ poisson_isf

integer, parameter, public poisson_oct_m::poisson_isf = 8

Definition at line 191 of file poisson.F90.

◆ poisson_psolver

integer, parameter, public poisson_oct_m::poisson_psolver = 10

Definition at line 191 of file poisson.F90.

◆ poisson_no

integer, parameter, public poisson_oct_m::poisson_no = -99

Definition at line 191 of file poisson.F90.

◆ poisson_null

integer, parameter, public poisson_oct_m::poisson_null = -999

Definition at line 191 of file poisson.F90.

◆ cmd_finish

integer, parameter poisson_oct_m::cmd_finish = 1

private

Definition at line 227 of file poisson.F90.

◆ cmd_poisson_solve

integer, parameter poisson_oct_m::cmd_poisson_solve = 2

private

Definition at line 227 of file poisson.F90.

Data Types

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ poisson_init()

◆ poisson_end()

◆ zpoisson_solve_real_and_imag_separately()

◆ zpoisson_solve_real_and_imag_separately_batch()

◆ zpoisson_solve_real_and_imag_separately_accel()

◆ zpoisson_solve()

◆ poisson_solve_batch()

◆ poisson_is_batch_capable()

◆ poisson_is_device_batch_capable()

◆ dpoisson_solve()

◆ poisson_init_sm()

◆ poisson_solver_is_iterative()

◆ poisson_async_init()

◆ poisson_async_end()

◆ poisson_slave_work()

◆ poisson_is_async()

◆ poisson_build_kernel()

◆ poisson_get_full_range_weight()

◆ poisson_kernel_init()

◆ poisson_solve_direct()

◆ dpoisson_solve_direct_sm()

◆ zpoisson_solve_direct_sm()

◆ dpoisson_solve_start()

◆ dpoisson_solve_finish()

◆ dpoisson_solve_sm()

◆ dpoisson_solve_batch()

◆ zpoisson_solve_start()

◆ zpoisson_solve_finish()

◆ zpoisson_solve_sm()

◆ zpoisson_solve_batch()

Variable Documentation

◆ poisson_direct_sum

◆ poisson_fft

◆ poisson_cg

◆ poisson_cg_corrected

◆ poisson_multigrid

◆ poisson_isf

◆ poisson_psolver

◆ poisson_no

◆ poisson_null

◆ cmd_finish

◆ cmd_poisson_solve