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_library, fft_batch_size, single_precision)

subroutine, public	poisson_end (this)

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, public	poisson_solves_complex_natively (this)
	Whether zpoisson_solve takes a complex density in one pass. More...

logical function, public	poisson_uses_nfft (this)
	Whether the solve goes through a non-equispaced FFT. More...

logical function, public	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...

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	spoisson_solve (this, namespace, pot, rho, all_nodes, kernel, reset)
	Single-precision scalar Poisson solve (FFT method only). This is the s/c counterpart of the concrete dpoisson_solve/zpoisson_solve; it serves the per-function fallback of spoisson_solve_batch and the non-batched branch of the templated exchange. More...

subroutine, public	spoisson_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	cpoisson_solve (this, namespace, pot, rho, all_nodes, kernel, reset)
	Single-precision scalar Poisson solve (FFT method only). This is the s/c counterpart of the concrete dpoisson_solve/zpoisson_solve; it serves the per-function fallback of cpoisson_solve_batch and the non-batched branch of the templated exchange. More...

subroutine, public	cpoisson_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	cpoisson_solve_real_and_imag_separately (this, namespace, pot, rho, all_nodes, kernel)

subroutine	cpoisson_solve_real_and_imag_separately_batch (this, namespace, pot, rho, kernel)
	Batched analogue of cpoisson_solve_real_and_imag_separately. More...

subroutine	cpoisson_solve_real_and_imag_separately_accel (this, namespace, pot_buffer, rho_buffer, kernel, count)
	Device variant of cpoisson_solve_real_and_imag_separately. 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_nfft = (-1537026393_int64)

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_library,
		integer, intent(in), optional	fft_batch_size,
		logical, intent(in), optional	single_precision
	)

Parameters

[in]	qtot	total charge
[in]	fft_library	Overrides FFTLibrary for the cube
[in]	fft_batch_size	Number of FFTs solved at once
[in]	single_precision	single-precision FFT Poisson

Definition at line 244 of file poisson.F90.

◆ poisson_end()

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

Definition at line 718 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 774 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 819 of file poisson.F90.

◆ poisson_solves_complex_natively()

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

Whether zpoisson_solve takes a complex density in one pass.

Otherwise the real and the imaginary part are solved separately.

Definition at line 851 of file poisson.F90.

◆ poisson_uses_nfft()

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

Whether the solve goes through a non-equispaced FFT.

Either as the solver itself, or as the FFT library behind the cube.

Definition at line 869 of file poisson.F90.

◆ poisson_is_batch_capable()

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

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 888 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 897 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 915 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 1024 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 1128 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 1135 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 1147 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 1163 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 1171 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 1180 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 1244 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 1284 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 1501 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), contiguous	pot,
		real(real64), dimension(:), intent(in), contiguous	rho
	)

private

Definition at line 1750 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), contiguous	pot,
		complex(real64), dimension(:), intent(in), contiguous	rho
	)

private

Parameters

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

Definition at line 1949 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 2058 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 2066 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 2078 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 2158 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 2318 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 2326 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 2338 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 2474 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 2585 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 2644 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 2683 of file poisson.F90.

◆ spoisson_solve()

subroutine, public poisson_oct_m::spoisson_solve	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		real(real32), dimension(:), intent(inout), contiguous	pot,
		real(real32), 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
	)

Single-precision scalar Poisson solve (FFT method only). This is the s/c counterpart of the concrete dpoisson_solve/zpoisson_solve; it serves the per-function fallback of spoisson_solve_batch and the non-batched branch of the templated exchange.

Definition at line 2842 of file poisson.F90.

◆ spoisson_solve_batch()

subroutine, public poisson_oct_m::spoisson_solve_batch	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		real(real32), dimension(:, :), intent(out), optional, contiguous	pot,
		real(real32), 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 2889 of file poisson.F90.

◆ cpoisson_solve()

subroutine, public poisson_oct_m::cpoisson_solve	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		complex(real32), dimension(:), intent(inout), contiguous	pot,
		complex(real32), 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
	)

Single-precision scalar Poisson solve (FFT method only). This is the s/c counterpart of the concrete dpoisson_solve/zpoisson_solve; it serves the per-function fallback of cpoisson_solve_batch and the non-batched branch of the templated exchange.

Definition at line 3055 of file poisson.F90.

◆ cpoisson_solve_batch()

subroutine, public poisson_oct_m::cpoisson_solve_batch	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		complex(real32), dimension(:, :), intent(out), optional, contiguous	pot,
		complex(real32), 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 3109 of file poisson.F90.

◆ cpoisson_solve_real_and_imag_separately()

subroutine poisson_oct_m::cpoisson_solve_real_and_imag_separately	(	type(poisson_t), intent(in)	this,
		type(namespace_t), intent(in)	namespace,
		complex(real32), dimension(:), intent(inout), contiguous	pot,
		complex(real32), 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 3220 of file poisson.F90.

◆ cpoisson_solve_real_and_imag_separately_batch()

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

private

Batched analogue of cpoisson_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 3279 of file poisson.F90.

◆ cpoisson_solve_real_and_imag_separately_accel()

subroutine poisson_oct_m::cpoisson_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 cpoisson_solve_real_and_imag_separately.

Parameters

[in] count number of functions (default 1)

Definition at line 3318 of file poisson.F90.

Variable Documentation

◆ poisson_direct_sum

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

Definition at line 199 of file poisson.F90.

◆ poisson_fft

integer, parameter, public poisson_oct_m::poisson_fft = 0

Definition at line 199 of file poisson.F90.

◆ poisson_cg

integer, parameter, public poisson_oct_m::poisson_cg = 5

Definition at line 199 of file poisson.F90.

◆ poisson_cg_corrected

integer, parameter, public poisson_oct_m::poisson_cg_corrected = 6

Definition at line 199 of file poisson.F90.

◆ poisson_multigrid

integer, parameter, public poisson_oct_m::poisson_multigrid = 7

Definition at line 199 of file poisson.F90.

◆ poisson_isf

integer, parameter, public poisson_oct_m::poisson_isf = 8

Definition at line 199 of file poisson.F90.

◆ poisson_psolver

integer, parameter, public poisson_oct_m::poisson_psolver = 10

Definition at line 199 of file poisson.F90.

◆ poisson_nfft

integer, parameter, public poisson_oct_m::poisson_nfft = (-1537026393_int64)

Definition at line 199 of file poisson.F90.

◆ poisson_no

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

Definition at line 199 of file poisson.F90.

◆ poisson_null

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

Definition at line 199 of file poisson.F90.

◆ cmd_finish

integer, parameter poisson_oct_m::cmd_finish = 1

private

Definition at line 237 of file poisson.F90.

◆ cmd_poisson_solve

integer, parameter poisson_oct_m::cmd_poisson_solve = 2

private

Definition at line 237 of file poisson.F90.

Data Types

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ poisson_init()

◆ poisson_end()

◆ zpoisson_solve()

◆ poisson_solve_batch()

◆ poisson_solves_complex_natively()

◆ poisson_uses_nfft()

◆ 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()

◆ zpoisson_solve_real_and_imag_separately()

◆ zpoisson_solve_real_and_imag_separately_batch()

◆ zpoisson_solve_real_and_imag_separately_accel()

◆ spoisson_solve()

◆ spoisson_solve_batch()

◆ cpoisson_solve()

◆ cpoisson_solve_batch()

◆ cpoisson_solve_real_and_imag_separately()

◆ cpoisson_solve_real_and_imag_separately_batch()

◆ cpoisson_solve_real_and_imag_separately_accel()

Variable Documentation

◆ poisson_direct_sum

◆ poisson_fft

◆ poisson_cg

◆ poisson_cg_corrected

◆ poisson_multigrid

◆ poisson_isf

◆ poisson_psolver

◆ poisson_nfft

◆ poisson_no

◆ poisson_null

◆ cmd_finish

◆ cmd_poisson_solve