This Pencil FFT performs 3D forward and backwards FFTs using pencil decomposition. It uses FFTW for the actual FFT kernel and this module contains all the data decomposition around this. There is no FFT required in Z, so this performs FFTs in Y and X (in that order forward and reversed backwards.) The data decomposition is the complex aspect, there is the concept of forward and backwards transformations. Forward transformations will go from pencil Z to Y to X and the backwards transformations undo these, so go from X to Y to Z. Note that we use quite a lot of buffer space here, this could be cut down if Y=X dimensions so some optimisation on memory could be done there in that case. More...

Data Types
type	pencil_transposition
	Describes a specific pencil transposition, from one pencil decomposition to another. More...

Functions/Subroutines
integer function, dimension(3), public	initialise_pencil_fft (current_state, my_y_start, my_x_start)
	Initialises the pencil FFT functionality, this will create the transposition structures needed. More...

subroutine, public	finalise_pencil_fft (monc_communicator)
	Cleans up allocated buffer memory. More...

subroutine, public	perform_forward_3dfft (current_state, source_data, target_data)
	Performs a forward 3D FFT and currently results in target data which is the X, Z, Y oriented pencil Note that the source_data here takes no account for the halo, it is up to caller to exclude this. This does no FFT in Z, but transposes to Y, does FFT in Y, then transposes to X and performs an FFT in that dimension. Pencil decomposition is used which has already been set up. More...

subroutine, public	perform_backwards_3dfft (current_state, source_data, target_data)
	Performs a backwards 3D FFT and currently results in target data which is the X, Z, Y oriented pencil Note that the source_data here takes no account for the halo, it is up to caller to exclude this. This does no FFT in Z, but transposes to Y, does FFT in Y, then transposes to X and performs an FFT in that dimension. Pencil decomposition is used which has already been set up. More...

subroutine	initialise_buffers ()
	Initialises memory for the buffers used in the FFT. More...

subroutine	initialise_transpositions (current_state, y_distinct_sizes, x_distinct_sizes)
	Initialises the pencil transpositions, from a pencil in one dimension to that in another. More...

type(pencil_transposition) function	create_transposition (global_grid, existing_transposition, new_pencil_dim, process_dim_sizes, direction, extended_dimensions)
	Creates a specific pencil transposition description. It is maybe more a decomposition description, but the main complexity comes from the transposition from existing decomposition to new decomposition so therefore it is called transposition. The new pencil decomposition depends not only on the dimension to split on, but also the existing pencil decomposition. The new decomposed dimension (i.e. the existing pencil dimension) * other local dimensions is used as the sending size, receiving though requires knowledge about the data size on the source process so others will send their pencil dimension size to this process. More...

subroutine	transpose_and_forward_fft_in_y (current_state, source_data, buffer, real_buffer)
	Performs the transposition and forward FFT in the y dimension then converts back to real numbers. The Y size is (n/2+1)*2 due to the complex to real transformation after the FFT. More...

subroutine	transpose_and_backward_fft_in_x (current_state, source_data, buffer, real_buffer)
	Performs the backwards FFT in X and then transposes to Y pencil. The FFT requires complex numbers which are converted to real, so the this real to complex operation is performed first. If n is the logical size of the FFT row, then the input size is n+2, complex number size is n/2+1 and we get n reals out. More...

subroutine	transpose_and_forward_fft_in_x (current_state, buffer1, buffer2, buffer3)
	Performs the transposition and forward FFT in the x dimension. After the FFT the complex space is converted back into real numbers. The X size is (n/2+1)*2 due to this transformation. More...

subroutine	transpose_and_backward_fft_in_y (current_state, source_data, buffer, real_buffer)
	Performs the backwards FFT in Y and then transposes to Z pencil. The FFT requires complex numbers which are converted to real, so the this real to complex operation is performed first. If n is the logical size of the FFT row, then the input size is n+2, complex number size is n/2+1 and we get n reals out. More...

subroutine	transpose_to_pencil (transposition_description, source_dims, communicator, direction, source_data, target_data)
	Transposes globally to a new pencil decomposition. This goes from the source dimensions a,b,c to b,c,a (forwards) or c,a,b (backwards.) It requires multiple steps, first the local data is transposed to c,b,a regardless of direction. then it is communicated via alltoall, each process then assembles its own b,c,a or c,a,b data via contiguising across blocks as the data layout is nonlinear. More...

subroutine	contiguise_data (transposition_description, source_dims, direction, source_real_buffer, target_real_buffer)
	Contiguises from c,b,a to b,c,a (forwards) or c,a,b (backwards) where these are defined by the source_dims argument. It is not as simple as just swapping the required dimensions, as this is after the mpi alltoall and each block lies after the previous block running sequentially in a. More...

subroutine	perform_r2c_fft (source_data, transformed_data, row_size, num_rows, plan_id)
	Actually performs a forward real to complex FFT. More...

subroutine	perform_c2r_fft (source_data, transformed_data, row_size, num_rows, plan_id)
	Performs the complex to real (backwards) FFT. More...

subroutine	rearrange_data_for_sending (real_source, real_target)
	Rearranges data for sending, transposing a,b,c into c,b,a . This is done as alltoall splits on dimension c so to go from one pencil to another we assume here that a is the existing pencil as it is contiguous. More...

subroutine	determine_my_process_sizes_per_dim (existing_pencil_dim, existing_pencil_size, new_pencil_procs_per_dim, global_grid, extended_dimensions, specific_sizes_per_dim)
	Determines the number of elements to on my process per dimension which either need to be sent to (forwards transformation) or received from (backwards) each target process (in the row or column) This depends on the existing pencil decomposition, as effectively we are breaking that contigulity and decomposing it into n blocks in that dimension now (provided by new_pencil_procs_per_dim) More...

subroutine	determine_offsets_from_size (source_sizes, determined_offsets)
	Simple helper function to deduce send or receive offsets from the sizes. More...

integer function, dimension(3)	determine_pencil_process_dimensions (new_pencil_dim, existing_pencil_dim, existing_pencil_procs)
	Determines the number of processes in each dimension for the target decomposition. This depends heavily on the existing decomposition, as we basically contiguise our pencil dimension and decompose the existing pencil dimension. The third dimension remains unchanged. More...

integer function, dimension(3)	determine_my_pencil_location (new_pencil_dim, existing_pencil_dim, existing_locations)
	Determines my location for each dimension in the new pencil decomposition. I.e. which block I am operating on. More...

subroutine	concatenate_dimension_sizes (dims, concatenated_dim_sizes)
	Concatenates sizes in multiple dimensions for each target process (in a row or column) into a product of that. This represents all the dimension sizes per process. More...

subroutine	determine_matching_process_dimensions (new_pencil_dim, existing_pencil_dim, proc_sizes, my_pencil_size, pencil_processes_per_dim, specific_sizes_per_dim)
	Determines the sizes per dimension on the matching process either to receive from (forward transposition) or send to (backwards transposition) each source process. Not only does this depend on the my pencil sizes, but it also depends on the amount of data that the source process has to send over. More...

type(pencil_transposition) function	create_initial_transposition_description (current_state)
	Creates an initial transposition representation of the Z pencil that MONC is normally decomposed in. This is then fed into the create transposition procedure which will generate transpositions to other pencils. More...

integer function, dimension(3)	determine_pencil_size (new_pencil_dim, pencil_process_layout, my_pencil_location, existing_transposition, global_grid, extended_dimensions)
	Deduces the size of my (local) pencil based upon the new decomposition. This depends heavily on the current pencil decomposition, the new pencil dimension is the global size, the existing pencil dimension becomes decomposed based on the number of processes in that dimension. The third dimension remains unchanged. More...

logical function	is_extended_dimension (dimension, extended_dimensions)
	Determines whether or not the specific dimension is in the list of extended dimensions. More...

integer function, dimension(size(process_dim_sizes))	normal_to_extended_process_dim_sizes (process_dim_sizes)
	Transforms real process dimension sizes into their real after FFT complex->real transformation. The way this works is that it goes from n to (n/2+1)*2 numbers which is distributed amongst the processes deterministically. More...

subroutine	convert_complex_to_real (complex_data, real_data)
	Converts complex representation to its real data counterpart and is called after each forward FFT. After a r2c FFT, there are n/2+1 complex numbers - which means that there will be more real numbers in Fourier space than are provided into the forward FFT call (due to the extra +1). Note that the real size n will always be complex size * 2 This always unpacks the complex dimension in the first dimension. More...

subroutine	convert_real_to_complex (real_data, complex_data)
	Converts reals into their complex representation, this is called for backwards FFTs as we need to feed in complex numbers to force FFTW to do a backwards. It is a relatively simple transformation, as n goes into n/2 complex numbers and as this is the result of the `convert_complex_to_real` procedure, n always divides evenly. This is always applied to the first dimension of the real data. More...

integer function	deduce_my_global_start (current_state, dimension)
	Determines my global start coordinate in Fourier space. This is required for cos y and cos x calculation which is fed into the tridiagonal solver. After the forward FFTs, each process has ((n/2+1)/p+r) * 2 elements, where p is the number of processes and r is the uneven process remainder (1 or 0 depending on p). Therefore some processes will have t elements, and some t-2 elements to feed into the solver. More...

Variables
integer, parameter	forward =1

integer, parameter	backward =2
	Transposition directions. More...

integer	dim_y_comm

integer	dim_x_comm
	Communicators for each dimension. More...

type(pencil_transposition)	y_from_z_transposition

type(pencil_transposition)	x_from_y_transposition

type(pencil_transposition)	y_from_x_transposition

type(pencil_transposition)	z_from_y_transposition

type(pencil_transposition)	y_from_z_2_transposition

type(pencil_transposition)	x_from_y_2_transposition

type(pencil_transposition)	y_from_x_2_transposition

type(pencil_transposition)	z_from_y_2_transposition

real(kind=default_precision), dimension(:,:,:), pointer, contiguous	real_buffer1

real(kind=default_precision), dimension(:,:,:), pointer, contiguous	real_buffer2

real(kind=default_precision), dimension(:,:,:), pointer, contiguous	real_buffer3

real(kind=default_precision), dimension(:,:,:), pointer, contiguous	fft_in_y_buffer

real(kind=default_precision), dimension(:,:,:), pointer, contiguous	fft_in_x_buffer

complex(c_double_complex), dimension(:,:,:), pointer, contiguous	buffer1

complex(c_double_complex), dimension(:,:,:), pointer, contiguous	buffer2

type(c_ptr), dimension(4)	fftw_plan

logical, dimension(4)	fftw_plan_initialised =.false.

Detailed Description

This Pencil FFT performs 3D forward and backwards FFTs using pencil decomposition. It uses FFTW for the actual FFT kernel and this module contains all the data decomposition around this. There is no FFT required in Z, so this performs FFTs in Y and X (in that order forward and reversed backwards.) The data decomposition is the complex aspect, there is the concept of forward and backwards transformations. Forward transformations will go from pencil Z to Y to X and the backwards transformations undo these, so go from X to Y to Z. Note that we use quite a lot of buffer space here, this could be cut down if Y=X dimensions so some optimisation on memory could be done there in that case.

Function/Subroutine Documentation

◆ concatenate_dimension_sizes()

subroutine pencil_fft_mod::concatenate_dimension_sizes	(	integer, dimension(:,:), intent(in)	dims,
		integer, dimension(:), intent(inout)	concatenated_dim_sizes
	)

private

Concatenates sizes in multiple dimensions for each target process (in a row or column) into a product of that. This represents all the dimension sizes per process.

Parameters

dims	The sizes, per dimension and per process that we will fold into target process

Definition at line 574 of file pencilfft.F90.

     integer, dimension(:,:), intent(in) :: dims
     integer, dimension(:), intent(inout) :: concatenated_dim_sizes
 
     integer :: i
 
     do i=1,size(dims, 2)
       concatenated_dim_sizes(i)=product(dims(:,i))
     end do    

Here is the caller graph for this function:

◆ contiguise_data()

subroutine pencil_fft_mod::contiguise_data	(	type(pencil_transposition), intent(in)	transposition_description,
		integer, dimension(3), intent(in)	source_dims,
		integer, intent(in)	direction,
		real(kind=default_precision), dimension(:), intent(in)	source_real_buffer,
		real(kind=default_precision), dimension(:,:,:), intent(out)	target_real_buffer
	)

private

Contiguises from c,b,a to b,c,a (forwards) or c,a,b (backwards) where these are defined by the source_dims argument. It is not as simple as just swapping the required dimensions, as this is after the mpi alltoall and each block lies after the previous block running sequentially in a.

Parameters

transposition_description	Transposition descriptor
source_dims	Representation a,b,c of source data, will contiguise to b,a,c
direction	Whether we wish to contiguise forwards or backwards
source_real_buffer	Source real data to transform
target_real_buffer	Target real data which is the result of the operation

Definition at line 390 of file pencilfft.F90.

     integer, intent(in) :: source_dims(3), direction
     type(pencil_transposition), intent(in) :: transposition_description
     real(kind=DEFAULT_PRECISION), dimension(:), intent(in) :: source_real_buffer
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(out) :: target_real_buffer
     
     integer :: number_blocks, i, j, k, n, index_prefix, index_prefix_dim, block_offset, source_index
 
     number_blocks=size(transposition_description%recv_sizes)
     index_prefix=0
     block_offset=0
     index_prefix_dim=merge(2,1, direction == forward)
     do i=1,number_blocks
       if (i .ge. 2) then
         index_prefix=index_prefix+transposition_description%recv_dims(source_dims(index_prefix_dim), i-1)
         block_offset=block_offset+transposition_description%recv_sizes(i-1)
       end if
       !Transformation is either cba -> bca (forward) or cab (backwards)       
       do j=1, transposition_description%recv_dims(source_dims(3), i) ! a
         do k=1, transposition_description%recv_dims(source_dims(1), i) ! c
           do n=1, transposition_description%recv_dims(source_dims(2), i) ! b
             source_index=block_offset+(j-1)* transposition_description%recv_dims(source_dims(1), i)* &
                  transposition_description%recv_dims(source_dims(2), i)+ (n-1)* &
                  transposition_description%recv_dims(source_dims(1), i)+k            
             if (direction == forward) then
               target_real_buffer(index_prefix+n, k, j)=source_real_buffer(source_index) ! bca
             else
               target_real_buffer(index_prefix+k, j, n)=source_real_buffer(source_index) ! cab
             end if
           end do
         end do
       end do      
     end do    

Here is the caller graph for this function:

◆ convert_complex_to_real()

subroutine pencil_fft_mod::convert_complex_to_real	(	complex(c_double_complex), dimension(:,:,:), intent(in)	complex_data,
		real(kind=default_precision), dimension(:,:,:), intent(out)	real_data
	)

private

Converts complex representation to its real data counterpart and is called after each forward FFT. After a r2c FFT, there are n/2+1 complex numbers - which means that there will be more real numbers in Fourier space than are provided into the forward FFT call (due to the extra +1). Note that the real size n will always be complex size * 2 This always unpacks the complex dimension in the first dimension.

Parameters

complex_data	Complex data in Z,Y,X orientation to be unpacked into its real representation
real_data	The real representation is written into here

Definition at line 705 of file pencilfft.F90.

     complex(C_DOUBLE_COMPLEX), dimension(:,:,:), intent(in) :: complex_data
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(out) :: real_data
 
     integer :: i, j, k
 
     do i=1,size(real_data,3)
       do j=1,size(real_data,2)
         do k=1,size(real_data,1),2
           real_data(k,j,i)=real(real(complex_data((k+1)/2,j,i)), kind=default_precision)
           real_data(k+1,j,i)=real(aimag(complex_data((k+1)/2,j,i)), kind=default_precision)
         end do
       end do
     end do

Here is the caller graph for this function:

◆ convert_real_to_complex()

subroutine pencil_fft_mod::convert_real_to_complex	(	real(kind=default_precision), dimension(:,:,:), intent(in)	real_data,
		complex(c_double_complex), dimension(:,:,:), intent(out), pointer, contiguous	complex_data
	)

private

Converts reals into their complex representation, this is called for backwards FFTs as we need to feed in complex numbers to force FFTW to do a backwards. It is a relatively simple transformation, as n goes into n/2 complex numbers and as this is the result of the convert_complex_to_real procedure, n always divides evenly. This is always applied to the first dimension of the real data.

Parameters

real_data	The source real data to pack into the complex data, it is oriented Z,Y,X
complex_data	Target complex data which the real data is packaged into

Definition at line 727 of file pencilfft.F90.

     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(in) :: real_data
     complex(C_DOUBLE_COMPLEX), dimension(:,:,:), contiguous, pointer, intent(out) :: complex_data
     
     integer :: i, j, k
 
     complex_data=cmplx(0.0d0, 0.0d0, kind=c_double_complex)
 
     do i=1,size(real_data,3)
       do j=1,size(real_data,2)
         do k=1,size(real_data,1),2
           complex_data((k+1)/2,j,i)=cmplx(real_data(k,j,i), real_data(k+1,j,i), kind=c_double_complex)
         end do
       end do
     end do

Here is the caller graph for this function:

◆ create_initial_transposition_description()

type(pencil_transposition) function pencil_fft_mod::create_initial_transposition_description ( type(model_state_type), intent(inout) current_state )

private

Creates an initial transposition representation of the Z pencil that MONC is normally decomposed in. This is then fed into the create transposition procedure which will generate transpositions to other pencils.

Parameters

current_state The current model state

Definition at line 614 of file pencilfft.F90.

     type(model_state_type), intent(inout) :: current_state
 
     create_initial_transposition_description%dim=z_index
     create_initial_transposition_description%process_decomposition_layout=current_state%parallel%dim_sizes
     create_initial_transposition_description%my_process_location=current_state%parallel%my_coords
     create_initial_transposition_description%my_pencil_size=current_state%local_grid%size

Here is the caller graph for this function:

◆ create_transposition()

type(pencil_transposition) function pencil_fft_mod::create_transposition	(	type(global_grid_type), intent(inout)	global_grid,
		type(pencil_transposition), intent(in)	existing_transposition,
		integer, intent(in)	new_pencil_dim,
		integer, dimension(:), intent(in)	process_dim_sizes,
		integer, intent(in)	direction,
		integer, dimension(:), intent(in)	extended_dimensions
	)

private

Creates a specific pencil transposition description. It is maybe more a decomposition description, but the main complexity comes from the transposition from existing decomposition to new decomposition so therefore it is called transposition. The new pencil decomposition depends not only on the dimension to split on, but also the existing pencil decomposition. The new decomposed dimension (i.e. the existing pencil dimension) * other local dimensions is used as the sending size, receiving though requires knowledge about the data size on the source process so others will send their pencil dimension size to this process.

Parameters

new_pencil_dim	The dimension to use as the new pencil decomposition
existing_pencil_dim	The dimension used in the current decomposition
existing_pencil_process_layout	Number of processes per dimension for the current decomposition
existing_my_location	The current processes block location per dimension for the current decomposition
existing_pencil_size	Pencil size per dimension for the current decomposition
process_dim_sizes	Sizes of the pencil dimension from other processes that is used to calculate receive count
direction	Whether we are transposing forwards or backwards, backwards is just an inverse
extended_dimensions	The dimensions that this process extends from n to (n/2+1)*2 (i.e. result of fft complex->real)

Definition at line 217 of file pencilfft.F90.

     type(global_grid_type), intent(inout) :: global_grid
     type(pencil_transposition), intent(in) :: existing_transposition
     integer, dimension(:), intent(in) :: process_dim_sizes
     integer, intent(in) :: new_pencil_dim, direction, extended_dimensions(:)
 
     create_transposition%process_decomposition_layout=determine_pencil_process_dimensions(&
          new_pencil_dim, existing_transposition%dim, existing_transposition%process_decomposition_layout)
 
     create_transposition%my_process_location=determine_my_pencil_location(new_pencil_dim, &
          existing_transposition%dim, existing_transposition%my_process_location)
 
     create_transposition%my_pencil_size=determine_pencil_size(new_pencil_dim, create_transposition%process_decomposition_layout,&
          create_transposition%my_process_location, existing_transposition, global_grid, extended_dimensions)
 
     allocate(create_transposition%send_dims(3, create_transposition%process_decomposition_layout(existing_transposition%dim)), &
            create_transposition%recv_dims(3, create_transposition%process_decomposition_layout(existing_transposition%dim)))
     if (direction == forward) then            
       call determine_my_process_sizes_per_dim(existing_transposition%dim, &
            existing_transposition%my_pencil_size, create_transposition%process_decomposition_layout, &
            global_grid, extended_dimensions, create_transposition%send_dims)
       call determine_matching_process_dimensions(new_pencil_dim, existing_transposition%dim, process_dim_sizes, &
            create_transposition%my_pencil_size, create_transposition%process_decomposition_layout, create_transposition%recv_dims)
     else
       call determine_my_process_sizes_per_dim(new_pencil_dim, create_transposition%my_pencil_size, &
            existing_transposition%process_decomposition_layout, global_grid, extended_dimensions, create_transposition%recv_dims)
       call determine_matching_process_dimensions(existing_transposition%dim, new_pencil_dim, process_dim_sizes, &
            existing_transposition%my_pencil_size, existing_transposition%process_decomposition_layout, &
            create_transposition%send_dims)
     end if
 
     allocate(create_transposition%send_sizes(size(create_transposition%send_dims, 2)), &
          create_transposition%send_offsets(size(create_transposition%send_sizes)), &
          create_transposition%recv_sizes(size(create_transposition%recv_dims, 2)), &
          create_transposition%recv_offsets(size(create_transposition%recv_sizes)))
 
     call concatenate_dimension_sizes(create_transposition%send_dims, create_transposition%send_sizes)
     call determine_offsets_from_size(create_transposition%send_sizes, create_transposition%send_offsets)
 
     call concatenate_dimension_sizes(create_transposition%recv_dims, create_transposition%recv_sizes)
     call determine_offsets_from_size(create_transposition%recv_sizes, create_transposition%recv_offsets)
     create_transposition%dim=new_pencil_dim

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deduce_my_global_start()

integer function pencil_fft_mod::deduce_my_global_start	(	type(model_state_type), intent(inout)	current_state,
		integer, intent(in)	dimension
	)

private

Determines my global start coordinate in Fourier space. This is required for cos y and cos x calculation which is fed into the tridiagonal solver. After the forward FFTs, each process has ((n/2+1)/p+r) * 2 elements, where p is the number of processes and r is the uneven process remainder (1 or 0 depending on p). Therefore some processes will have t elements, and some t-2 elements to feed into the solver.

Parameters

current_state	The current model state
dimension	The dimension that we are calculating this for (Y or X)

Returns: My global start in Fourier space

Definition at line 752 of file pencilfft.F90.

     type(model_state_type), intent(inout) :: current_state
     integer, intent(in) :: dimension
 
     integer complex_size, distributed_size, remainder, larger_nums, smaller_nums
 
     complex_size=(current_state%global_grid%size(dimension)/2+1)*2
     distributed_size=complex_size / current_state%parallel%dim_sizes(dimension)
     remainder=complex_size - distributed_size * current_state%parallel%dim_sizes(dimension) 
     larger_nums=min(remainder, current_state%parallel%my_coords(dimension))
     smaller_nums=current_state%parallel%my_coords(dimension)-remainder
     deduce_my_global_start=((distributed_size+1)*larger_nums + merge(distributed_size*smaller_nums, 0, smaller_nums .gt. 0)) + 1

Here is the caller graph for this function:

◆ determine_matching_process_dimensions()

subroutine pencil_fft_mod::determine_matching_process_dimensions	(	integer, intent(in)	new_pencil_dim,
		integer, intent(in)	existing_pencil_dim,
		integer, dimension(:), intent(in)	proc_sizes,
		integer, dimension(:), intent(in)	my_pencil_size,
		integer, dimension(:), intent(in)	pencil_processes_per_dim,
		integer, dimension(:,:), intent(inout)	specific_sizes_per_dim
	)

private

Determines the sizes per dimension on the matching process either to receive from (forward transposition) or send to (backwards transposition) each source process. Not only does this depend on the my pencil sizes, but it also depends on the amount of data that the source process has to send over.

Parameters

new_pencil_dim	The dimension for the new pencil decomposition
existing_pencil_dim	Dimension for the existing pencil decomposition
proc_sizes	Size of dimension on the source processes (index in array corresponds to source PID)
my_pencil_size	My (new) pencil size per dimension
pencil_processes_per_dim	The process layout per dimension

Definition at line 594 of file pencilfft.F90.

     integer, intent(in) :: new_pencil_dim, existing_pencil_dim, proc_sizes(:), my_pencil_size(:), pencil_processes_per_dim(:)
     integer, dimension(:,:), intent(inout) :: specific_sizes_per_dim
 
     integer :: i, j
 
     do i=1,pencil_processes_per_dim(existing_pencil_dim)
       do j=1,3
         if (j==new_pencil_dim) then
           specific_sizes_per_dim(j, i)=proc_sizes(i)
         else
           specific_sizes_per_dim(j, i)=my_pencil_size(j)
         end if
       end do      
     end do    

Here is the caller graph for this function:

◆ determine_my_pencil_location()

integer function, dimension(3) pencil_fft_mod::determine_my_pencil_location	(	integer, intent(in)	new_pencil_dim,
		integer, intent(in)	existing_pencil_dim,
		integer, dimension(3), intent(in)	existing_locations
	)

private

Determines my location for each dimension in the new pencil decomposition. I.e. which block I am operating on.

Parameters

new_pencil_dim	New pencil decomposition dimension
existing_pencil_dim	Current pencil dimension
existing_locations	Location for the current decomposition

Definition at line 554 of file pencilfft.F90.

     integer, intent(in) :: new_pencil_dim, existing_pencil_dim, existing_locations(3)
     integer :: determine_my_pencil_location(3)
 
     integer :: i
 
     do i=1,3
       if (i == new_pencil_dim) then
         determine_my_pencil_location(i)=1
       else if (i == existing_pencil_dim) then
         determine_my_pencil_location(i)=existing_locations(new_pencil_dim)
       else
         determine_my_pencil_location(i)=existing_locations(i)
       end if
     end do    

Here is the caller graph for this function:

◆ determine_my_process_sizes_per_dim()

subroutine pencil_fft_mod::determine_my_process_sizes_per_dim	(	integer, intent(in)	existing_pencil_dim,
		integer, dimension(:), intent(in)	existing_pencil_size,
		integer, dimension(:), intent(in)	new_pencil_procs_per_dim,
		type(global_grid_type), intent(inout)	global_grid,
		integer, dimension(:), intent(in)	extended_dimensions,
		integer, dimension(:,:), intent(inout)	specific_sizes_per_dim
	)

private

Determines the number of elements to on my process per dimension which either need to be sent to (forwards transformation) or received from (backwards) each target process (in the row or column) This depends on the existing pencil decomposition, as effectively we are breaking that contigulity and decomposing it into n blocks in that dimension now (provided by new_pencil_procs_per_dim)

Parameters

existing_pencil_dim	The pencil dimension that we are transforming from
existing_pencil_size	Existing pencil decomposition sizes per dimension
new_pencil_procs_per_dim	For the target decomposition the number of processes per dimension
global_grid	Description of the global grid which we use for sizing information
extended_dimensions	List of dimensions where we extend from n to n+2 (i.e. result of FFT complex-> real transformation)

Definition at line 490 of file pencilfft.F90.

     integer, intent(in) :: existing_pencil_dim, existing_pencil_size(:), new_pencil_procs_per_dim(:), extended_dimensions(:)
     type(global_grid_type), intent(inout) :: global_grid
     integer, dimension(:,:), intent(inout) :: specific_sizes_per_dim
 
     integer :: i, split_size, split_remainder, j, s
 
     do i=1,3
       if (i == existing_pencil_dim) then
         s=global_grid%size(i)
         if (is_extended_dimension(i, extended_dimensions)) s=s+2
         split_size = s / new_pencil_procs_per_dim(i)
         split_remainder = s - split_size * new_pencil_procs_per_dim(i)
         do j=1,new_pencil_procs_per_dim(existing_pencil_dim)
           specific_sizes_per_dim(i,j)=merge(split_size+1, split_size, j .le. split_remainder)
         end do        
       else
         specific_sizes_per_dim(i,:) = existing_pencil_size(i)
       end if
     end do    

Here is the call graph for this function:

Here is the caller graph for this function:

◆ determine_offsets_from_size()

subroutine pencil_fft_mod::determine_offsets_from_size	(	integer, dimension(:), intent(in)	source_sizes,
		integer, dimension(:), intent(inout)	determined_offsets
	)

private

Simple helper function to deduce send or receive offsets from the sizes.

Parameters

source_sizes Sizes that we are using to build the offsets

Definition at line 514 of file pencilfft.F90.

     integer, intent(in) :: source_sizes(:)
     integer, dimension(:), intent(inout) :: determined_offsets
 
     integer :: i
 
     determined_offsets(1)=0
     do i=2,size(source_sizes)
       determined_offsets(i)=determined_offsets(i-1)+source_sizes(i-1)
     end do    

Here is the caller graph for this function:

◆ determine_pencil_process_dimensions()

integer function, dimension(3) pencil_fft_mod::determine_pencil_process_dimensions	(	integer, intent(in)	new_pencil_dim,
		integer, intent(in)	existing_pencil_dim,
		integer, dimension(3), intent(in)	existing_pencil_procs
	)

private

Determines the number of processes in each dimension for the target decomposition. This depends heavily on the existing decomposition, as we basically contiguise our pencil dimension and decompose the existing pencil dimension. The third dimension remains unchanged.

Parameters

new_pencil_dim	New pencil dimension
existing_pencil_dim	Current decomposition pencil dimension
existing_pencil_procs	Current decomposition process layout

Definition at line 532 of file pencilfft.F90.

     integer, intent(in) :: new_pencil_dim, existing_pencil_dim, existing_pencil_procs(3)
     integer :: determine_pencil_process_dimensions(3)
 
     integer :: i
 
     do i=1,3
       if (i == new_pencil_dim) then
         determine_pencil_process_dimensions(i)=1
       else if (i == existing_pencil_dim) then
         determine_pencil_process_dimensions(i)=existing_pencil_procs(new_pencil_dim)
       else
         determine_pencil_process_dimensions(i)=existing_pencil_procs(i)
       end if
     end do    

Here is the caller graph for this function:

◆ determine_pencil_size()

integer function, dimension(3) pencil_fft_mod::determine_pencil_size	(	integer, intent(in)	new_pencil_dim,
		integer, dimension(3), intent(in)	pencil_process_layout,
		integer, dimension(3), intent(in)	my_pencil_location,
		type(pencil_transposition), intent(in)	existing_transposition,
		type(global_grid_type), intent(inout)	global_grid,
		integer, dimension(:), intent(in)	extended_dimensions
	)

private

Deduces the size of my (local) pencil based upon the new decomposition. This depends heavily on the current pencil decomposition, the new pencil dimension is the global size, the existing pencil dimension becomes decomposed based on the number of processes in that dimension. The third dimension remains unchanged.

Parameters

new_pencil_dim	Dimension for the new pencil decomposition
pencil_process_layout	The processes per dimension layout for the new decomposition
my_pencil_location	My location in the block layout
existing_pencil_dim	Current decomposition dimension
existing_pencil_size	Current decomposition sizes
global_grid	Description of the global grid which we use for sizing information
extended_dimensions	List of dimensions where we extend from n to n+2 (i.e. result of FFT complex-> real transformation)

Definition at line 634 of file pencilfft.F90.

 
     type(pencil_transposition), intent(in) :: existing_transposition
     integer, intent(in) :: new_pencil_dim, pencil_process_layout(3), my_pencil_location(3), extended_dimensions(:)
     type(global_grid_type), intent(inout) :: global_grid
     integer :: determine_pencil_size(3)
 
     integer :: i, split_size, split_remainder, s
 
     do i=1,3
       if (i == new_pencil_dim) then
         if (is_extended_dimension(i, extended_dimensions)) then
           ! If complex and Y dim then /2+1 for the global size
           determine_pencil_size(i)=(global_grid%size(new_pencil_dim)/2+1)*2
         else
           determine_pencil_size(i)=global_grid%size(new_pencil_dim)
         end if
       else if (i == existing_transposition%dim) then
         s=global_grid%size(i)
         ! If complex and Y dim then use s/2+1 for the size to split
         if (is_extended_dimension(i, extended_dimensions)) s=(s/2+1)*2
         split_size=s/pencil_process_layout(i)
         split_remainder=s - split_size * pencil_process_layout(i)
         determine_pencil_size(i)=merge(split_size+1, split_size, my_pencil_location(i)+1 .le. split_remainder)        
       else        
         determine_pencil_size(i)=existing_transposition%my_pencil_size(i)       
       end if      
     end do    

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finalise_pencil_fft()

subroutine, public pencil_fft_mod::finalise_pencil_fft ( integer, intent(in) monc_communicator )

Cleans up allocated buffer memory.

Definition at line 93 of file pencilfft.F90.

     integer, intent(in) :: monc_communicator
     integer :: ierr, i
 
     do i=1,size(fftw_plan_initialised)
       if (fftw_plan_initialised(i)) then
         call fftw_destroy_plan(fftw_plan(i))
       end if      
     end do    
 
     if (dim_y_comm .ne. mpi_comm_self .and. dim_y_comm .ne. monc_communicator) call mpi_comm_free(dim_y_comm, ierr)
     if (dim_x_comm .ne. mpi_comm_self .and. dim_x_comm .ne. monc_communicator) call mpi_comm_free(dim_x_comm, ierr)
     deallocate(buffer1, buffer2, real_buffer1, real_buffer2, real_buffer3, fft_in_y_buffer , fft_in_x_buffer)

◆ initialise_buffers()

subroutine pencil_fft_mod::initialise_buffers ( )

private

Initialises memory for the buffers used in the FFT.

Definition at line 153 of file pencilfft.F90.

     allocate(buffer1(y_from_z_transposition%my_pencil_size(y_index)/2+1, y_from_z_transposition%my_pencil_size(x_index), &
          y_from_z_transposition%my_pencil_size(z_index)), &
          real_buffer1((y_from_z_transposition%my_pencil_size(y_index)/2+1)*2, y_from_z_transposition%my_pencil_size(x_index), &
          y_from_z_transposition%my_pencil_size(z_index)), &
          buffer2(x_from_y_transposition%my_pencil_size(x_index)/2+1, x_from_y_transposition%my_pencil_size(z_index), &
          x_from_y_transposition%my_pencil_size(y_index)), &
          real_buffer2((x_from_y_transposition%my_pencil_size(x_index)/2+1)*2, x_from_y_transposition%my_pencil_size(z_index), &
          x_from_y_transposition%my_pencil_size(y_index)), &
          fft_in_y_buffer(y_from_z_transposition%my_pencil_size(y_index), y_from_z_transposition%my_pencil_size(x_index), &
          y_from_z_transposition%my_pencil_size(z_index)), &
          fft_in_x_buffer(x_from_y_transposition%my_pencil_size(x_index), x_from_y_transposition%my_pencil_size(z_index), &
          x_from_y_transposition%my_pencil_size(y_index)), &
          real_buffer3(y_from_x_transposition%my_pencil_size(y_index), y_from_x_transposition%my_pencil_size(x_index), &
          y_from_x_transposition%my_pencil_size(z_index)))

Here is the caller graph for this function:

◆ initialise_pencil_fft()

integer function, dimension(3), public pencil_fft_mod::initialise_pencil_fft	(	type(model_state_type), intent(inout)	current_state,
		integer, intent(out)	my_y_start,
		integer, intent(out)	my_x_start
	)

Initialises the pencil FFT functionality, this will create the transposition structures needed.

Parameters

current_state	The current model state
my_y_start	My global start in fourier space for Y
my_x_start	My global start in fourier space for X

Returns: Size of local dimensions in fourier space for this process

Definition at line 52 of file pencilfft.F90.

     type(model_state_type), intent(inout) :: current_state
     integer, intent(out) :: my_y_start, my_x_start
     integer :: initialise_pencil_fft(3) 
 
     integer :: ierr, y_distinct_sizes(current_state%parallel%dim_sizes(y_index)), &
          x_distinct_sizes(current_state%parallel%dim_sizes(x_index))
 
     my_y_start=deduce_my_global_start(current_state, y_index)
     my_x_start=deduce_my_global_start(current_state, x_index)
 
     if (current_state%parallel%dim_sizes(y_index) .gt. 1 .and. current_state%parallel%dim_sizes(x_index) .gt. 1) then
       call mpi_cart_sub(current_state%parallel%neighbour_comm, (/1,0/), dim_y_comm, ierr)
       call mpi_cart_sub(current_state%parallel%neighbour_comm, (/0,1/), dim_x_comm, ierr)
 
       call mpi_allgather(current_state%local_grid%size(y_index), 1, mpi_int, y_distinct_sizes, 1, mpi_int, dim_y_comm, ierr)
       call mpi_allgather(current_state%local_grid%size(x_index), 1, mpi_int, x_distinct_sizes, 1, mpi_int, dim_x_comm, ierr)
     else if (current_state%parallel%dim_sizes(y_index) .gt. 1) then
       dim_y_comm=current_state%parallel%monc_communicator
       dim_x_comm=mpi_comm_self
       call mpi_allgather(current_state%local_grid%size(y_index), 1, mpi_int, y_distinct_sizes, 1, mpi_int, dim_y_comm, ierr)
       x_distinct_sizes=current_state%local_grid%size(x_index)
     else if (current_state%parallel%dim_sizes(x_index) .gt. 1) then      
       dim_y_comm=mpi_comm_self
       dim_x_comm=current_state%parallel%monc_communicator
       y_distinct_sizes=current_state%local_grid%size(y_index)
       call mpi_allgather(current_state%local_grid%size(x_index), 1, mpi_int, x_distinct_sizes, 1, mpi_int, dim_x_comm, ierr)
     else
       dim_y_comm=mpi_comm_self
       dim_x_comm=mpi_comm_self
       y_distinct_sizes=current_state%local_grid%size(y_index)
       x_distinct_sizes=current_state%local_grid%size(x_index)
     end if
 
     call initialise_transpositions(current_state, y_distinct_sizes, x_distinct_sizes)
     call initialise_buffers()
 
     initialise_pencil_fft=z_from_y_transposition%my_pencil_size    

Here is the call graph for this function:

◆ initialise_transpositions()

subroutine pencil_fft_mod::initialise_transpositions	(	type(model_state_type), intent(inout)	current_state,
		integer, dimension(:), intent(in)	y_distinct_sizes,
		integer, dimension(:), intent(in)	x_distinct_sizes
	)

private

Initialises the pencil transpositions, from a pencil in one dimension to that in another.

Parameters

current_state	The current model state
y_distinct_sizes	Y sizes per process
x_distinct_sizes	X sizes per process

Definition at line 174 of file pencilfft.F90.

     type(model_state_type), intent(inout) :: current_state
     integer, dimension(:), intent(in) :: y_distinct_sizes, x_distinct_sizes
 
     type(pencil_transposition) :: z_pencil
 
     z_pencil=create_initial_transposition_description(current_state)
 
     ! Transpositions
     y_from_z_transposition=create_transposition(current_state%global_grid, z_pencil, y_index, y_distinct_sizes, &
          forward, (/ -1 /))   
     x_from_y_transposition=create_transposition(current_state%global_grid, y_from_z_transposition, x_index, &
          x_distinct_sizes, forward, (/ y_index /))
     y_from_x_transposition=create_transposition(current_state%global_grid, x_from_y_transposition, y_index, &
          normal_to_extended_process_dim_sizes(x_distinct_sizes), backward, (/ y_index, x_index /))    
     z_from_y_transposition=create_transposition(current_state%global_grid, y_from_x_transposition, z_index, &
          normal_to_extended_process_dim_sizes(y_distinct_sizes), backward, (/ y_index, x_index /))  
 
     y_from_z_2_transposition=create_transposition(current_state%global_grid, z_from_y_transposition, y_index, &
           normal_to_extended_process_dim_sizes(y_distinct_sizes), forward, (/ y_index, x_index /))   
     x_from_y_2_transposition=create_transposition(current_state%global_grid, y_from_z_2_transposition, x_index, &
           normal_to_extended_process_dim_sizes(x_distinct_sizes), forward, (/ y_index, x_index /))
     y_from_x_2_transposition=create_transposition(current_state%global_grid, x_from_y_2_transposition, y_index, &
          x_distinct_sizes, backward, (/ y_index /))
     z_from_y_2_transposition=create_transposition(current_state%global_grid, y_from_x_2_transposition, z_index, &
           y_distinct_sizes, backward, (/ -1 /))   

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_extended_dimension()

logical function pencil_fft_mod::is_extended_dimension	(	integer, intent(in)	dimension,
		integer, dimension(:), intent(in)	extended_dimensions
	)

private

Determines whether or not the specific dimension is in the list of extended dimensions.

Parameters

dimension	The dimension to test for
extended_dimensions	Array of dimensions that will be searched

Returns: Whether the dimension is found in the array

Definition at line 668 of file pencilfft.F90.

     integer, intent(in) :: dimension, extended_dimensions(:)
 
     integer :: i
     do i=1,size(extended_dimensions)
       if (extended_dimensions(i) == dimension) then
         is_extended_dimension=.true.
         return
       end if      
     end do
     is_extended_dimension=.false.

Here is the caller graph for this function:

◆ normal_to_extended_process_dim_sizes()

integer function, dimension(size(process_dim_sizes)) pencil_fft_mod::normal_to_extended_process_dim_sizes ( integer, dimension(:), intent(in) process_dim_sizes )

private

Transforms real process dimension sizes into their real after FFT complex->real transformation. The way this works is that it goes from n to (n/2+1)*2 numbers which is distributed amongst the processes deterministically.

Parameters

process_dim_sizes Real process dimension sizes

Returns: The extended process dimension sizes

Definition at line 685 of file pencilfft.F90.

     integer, dimension(:), intent(in) :: process_dim_sizes
     integer, dimension(size(process_dim_sizes)) :: normal_to_extended_process_dim_sizes
 
     integer :: temp_total, split_size, remainder
 
     temp_total=(sum(process_dim_sizes) /2 + 1) * 2
     split_size=temp_total/size(process_dim_sizes)
     remainder=temp_total - split_size*size(process_dim_sizes)
 
     normal_to_extended_process_dim_sizes=split_size
     normal_to_extended_process_dim_sizes(1:remainder)=split_size+1    

Here is the caller graph for this function:

◆ perform_backwards_3dfft()

subroutine, public pencil_fft_mod::perform_backwards_3dfft	(	type(model_state_type), intent(inout), target	current_state,
		real(kind=default_precision), dimension(:,:,:), intent(in)	source_data,
		real(kind=default_precision), dimension(:,:,:), intent(out)	target_data
	)

Performs a backwards 3D FFT and currently results in target data which is the X, Z, Y oriented pencil Note that the source_data here takes no account for the halo, it is up to caller to exclude this. This does no FFT in Z, but transposes to Y, does FFT in Y, then transposes to X and performs an FFT in that dimension. Pencil decomposition is used which has already been set up.

Parameters

current_state	The current model state
source_data	The source real data to in the frequency domain
target_data	Time domain complex representation of the frequency domain source

Definition at line 138 of file pencilfft.F90.

     type(model_state_type), target, intent(inout) :: current_state
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(in) :: source_data
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(out) :: target_data
 
     call transpose_to_pencil(y_from_z_2_transposition, (/z_index, y_index, x_index/), dim_y_comm, forward, &
        source_data, real_buffer3)
     call transpose_to_pencil(x_from_y_2_transposition, (/y_index, x_index, z_index/), dim_x_comm, forward, &
        real_buffer3, real_buffer2)
 
     call transpose_and_backward_fft_in_x(current_state, real_buffer2, buffer2, real_buffer1)
     call transpose_and_backward_fft_in_y(current_state, real_buffer1, buffer1, target_data)

Here is the call graph for this function:

◆ perform_c2r_fft()

subroutine pencil_fft_mod::perform_c2r_fft	(	complex(c_double_complex), dimension(:,:,:), intent(inout), pointer, contiguous	source_data,
		real(kind=default_precision), dimension(:,:,:), intent(inout), pointer, contiguous	transformed_data,
		integer, intent(in)	row_size,
		integer, intent(in)	num_rows,
		integer, intent(in)	plan_id
	)

private

Performs the complex to real (backwards) FFT.

Parameters

source_data	Source (complex) data in the frequency domain
transformed_data	Resulting real data in the time domain
row_size	Number of elements for each FFT
num_rows	The number of FFTs to perform on the next data elements in the source_data
plan_id	Id number of the plan that tracks whether we need to create it or can reuse the existing one

Definition at line 450 of file pencilfft.F90.

     complex(C_DOUBLE_COMPLEX), dimension(:,:,:), contiguous, pointer, intent(inout) :: source_data
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), contiguous, pointer, intent(inout) :: transformed_data
     integer, intent(in) :: row_size, num_rows, plan_id   
 
     if (.not. fftw_plan_initialised(plan_id)) then
       ! n is the size of the FFT (in real, not complex->real coords.) There are row_size/2+1 between entries for the input
       ! (complex) data and row_size between entries for the output data
       fftw_plan(plan_id) = fftw_plan_many_dft_c2r(1, (/row_size/), num_rows, source_data, (/row_size/2+1/), 1, row_size/2+1, &
            transformed_data, (/row_size/), 1, row_size, fftw_estimate)
       fftw_plan_initialised(plan_id)=.true.
     end if
     call fftw_execute_dft_c2r(fftw_plan(plan_id), source_data, transformed_data)

Here is the caller graph for this function:

◆ perform_forward_3dfft()

subroutine, public pencil_fft_mod::perform_forward_3dfft	(	type(model_state_type), intent(inout), target	current_state,
		real(kind=default_precision), dimension(:,:,:), intent(inout)	source_data,
		real(kind=default_precision), dimension(:,:,:), intent(out)	target_data
	)

Performs a forward 3D FFT and currently results in target data which is the X, Z, Y oriented pencil Note that the source_data here takes no account for the halo, it is up to caller to exclude this. This does no FFT in Z, but transposes to Y, does FFT in Y, then transposes to X and performs an FFT in that dimension. Pencil decomposition is used which has already been set up.

Parameters

current_state	The current model state
source_data	The source real data to in the time domain
target_data	Frequency domain real representation of the time domain source which is allocated here

Definition at line 115 of file pencilfft.F90.

     type(model_state_type), target, intent(inout) :: current_state
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(inout) :: source_data
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(out) :: target_data
 
     call transpose_and_forward_fft_in_y(current_state, source_data, buffer1, real_buffer1)
     real_buffer1=real_buffer1/current_state%global_grid%size(y_index)
     call transpose_and_forward_fft_in_x(current_state, real_buffer1, buffer2, real_buffer2)
     real_buffer2=real_buffer2/current_state%global_grid%size(x_index)
 
     call transpose_to_pencil(y_from_x_transposition, (/x_index, z_index, y_index/), dim_x_comm, backward, &
          real_buffer2, real_buffer3)
     call transpose_to_pencil(z_from_y_transposition, (/y_index, x_index, z_index/), dim_y_comm, backward, &
        real_buffer3, target_data)     

Here is the call graph for this function:

◆ perform_r2c_fft()

subroutine pencil_fft_mod::perform_r2c_fft	(	real(kind=default_precision), dimension(:,:,:), intent(inout), pointer, contiguous	source_data,
		complex(c_double_complex), dimension(:,:,:), intent(inout), pointer, contiguous	transformed_data,
		integer, intent(in)	row_size,
		integer, intent(in)	num_rows,
		integer, intent(in)	plan_id
	)

private

Actually performs a forward real to complex FFT.

Parameters

source_data	Source (real) data in the time domain
transformed_data	Resulting complex data in the frequency domain
row_size	Number of elements for each FFT
num_rows	The number of FFTs to perform on the next data elements in the source_data
plan_id	Id number of the plan that tracks whether we need to create it or can reuse the existing one

Definition at line 431 of file pencilfft.F90.

     real(kind=DEFAULT_PRECISION), dimension(:,:,:), contiguous, pointer, intent(inout) :: source_data
     complex(C_DOUBLE_COMPLEX), dimension(:,:,:), contiguous, pointer, intent(inout) :: transformed_data
     integer, intent(in) :: row_size, num_rows, plan_id
     
     if (.not. fftw_plan_initialised(plan_id)) then
       fftw_plan(plan_id) = fftw_plan_many_dft_r2c(1, (/row_size/), num_rows, source_data, (/row_size/), 1, row_size, &
            transformed_data, (/row_size/), 1, row_size/2+1, fftw_estimate)
       fftw_plan_initialised(plan_id)=.true.
     end if
     call fftw_execute_dft_r2c(fftw_plan(plan_id), source_data, transformed_data)

Here is the caller graph for this function:

◆ rearrange_data_for_sending()

subroutine pencil_fft_mod::rearrange_data_for_sending	(	real(kind=default_precision), dimension(:,:,:), intent(in)	real_source,
		real(kind=default_precision), dimension(:,:,:), intent(out)	real_target
	)

private

Rearranges data for sending, transposing a,b,c into c,b,a . This is done as alltoall splits on dimension c so to go from one pencil to another we assume here that a is the existing pencil as it is contiguous.

Parameters

real_source	Source data to transpose from
real_target	Target data to transpose to

Definition at line 469 of file pencilfft.F90.

     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(in) :: real_source
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(out) :: real_target
 
     integer :: i
 
     do i=1, size(real_source,2)
       real_target(:,i,:)=transpose(real_source(:,i,:))
     end do

Here is the caller graph for this function:

◆ transpose_and_backward_fft_in_x()

subroutine pencil_fft_mod::transpose_and_backward_fft_in_x	(	type(model_state_type), intent(inout), target	current_state,
		real(kind=default_precision), dimension(:,:,:), intent(inout)	source_data,
		complex(c_double_complex), dimension(:,:,:), intent(out), pointer, contiguous	buffer,
		real(kind=default_precision), dimension(:,:,:), intent(out)	real_buffer
	)

private

Performs the backwards FFT in X and then transposes to Y pencil. The FFT requires complex numbers which are converted to real, so the this real to complex operation is performed first. If n is the logical size of the FFT row, then the input size is n+2, complex number size is n/2+1 and we get n reals out.

Parameters

current_state	The current model state
source_data	Input buffer, X pencil oriented x,z,y
buffer	Complex buffer which is fed into the FFT
real_buffer	Output buffer, Y pencil, oriented y,x,z

Definition at line 289 of file pencilfft.F90.

     type(model_state_type), target, intent(inout) :: current_state
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(inout) :: source_data
     real(kind=DEFAULT_PRECISION), dimension(:,:,:),  intent(out) :: real_buffer
     complex(C_DOUBLE_COMPLEX), dimension(:,:,:), contiguous, pointer, intent(out) :: buffer
 
     call convert_real_to_complex(source_data, buffer)
     call perform_c2r_fft(buffer, fft_in_x_buffer, x_from_y_2_transposition%my_pencil_size(x_index)-2, &
          x_from_y_2_transposition%my_pencil_size(y_index) * x_from_y_2_transposition%my_pencil_size(z_index), 2) 
 
     ! Transpose globally from X pencil to Y pencil
     call transpose_to_pencil(y_from_x_2_transposition, (/x_index, z_index, y_index/), dim_x_comm, backward, &
        fft_in_x_buffer, real_buffer)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transpose_and_backward_fft_in_y()

subroutine pencil_fft_mod::transpose_and_backward_fft_in_y	(	type(model_state_type), intent(inout), target	current_state,
		real(kind=default_precision), dimension(:,:,:), intent(inout)	source_data,
		complex(c_double_complex), dimension(:,:,:), intent(out), pointer, contiguous	buffer,
		real(kind=default_precision), dimension(:,:,:), intent(out)	real_buffer
	)

private

Performs the backwards FFT in Y and then transposes to Z pencil. The FFT requires complex numbers which are converted to real, so the this real to complex operation is performed first. If n is the logical size of the FFT row, then the input size is n+2, complex number size is n/2+1 and we get n reals out.

Parameters

current_state	The current model state
source_data	Input buffer, Y pencil oriented y,x,z
buffer	Complex buffer which is fed into the FFT
real_buffer	Output buffer, Z pencil, oriented z,y,x

Definition at line 332 of file pencilfft.F90.

     type(model_state_type), target, intent(inout) :: current_state
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(inout) :: source_data
     real(kind=DEFAULT_PRECISION), dimension(:,:,:),  intent(out) :: real_buffer
     complex(C_DOUBLE_COMPLEX), dimension(:,:,:), contiguous, pointer, intent(out) :: buffer
 
     call convert_real_to_complex(source_data, buffer)
    
     call perform_c2r_fft(buffer, fft_in_y_buffer,  y_from_x_2_transposition%my_pencil_size(y_index)-2, &
          y_from_x_2_transposition%my_pencil_size(x_index) * y_from_x_2_transposition%my_pencil_size(z_index), 4)
 
     ! Go from global Y pencil to global Z pencil
     call transpose_to_pencil(z_from_y_2_transposition, (/y_index, x_index, z_index/), dim_y_comm, backward, &
        fft_in_y_buffer, real_buffer)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transpose_and_forward_fft_in_x()

subroutine pencil_fft_mod::transpose_and_forward_fft_in_x	(	type(model_state_type), intent(inout), target	current_state,
		real(kind=default_precision), dimension(:,:,:), intent(inout)	buffer1,
		complex(c_double_complex), dimension(:,:,:), intent(out), pointer, contiguous	buffer2,
		real(kind=default_precision), dimension(:,:,:), intent(inout)	buffer3
	)

private

Performs the transposition and forward FFT in the x dimension. After the FFT the complex space is converted back into real numbers. The X size is (n/2+1)*2 due to this transformation.

Parameters

current_state	The current model state
buffer1	Input buffer, Y pencil after the Y dimension FFT oriented y,x,z
buffer	Complex buffer which results from the FFT
buffer2	Output buffer, X pencil after this X FFT, oriented x,z,y

Definition at line 310 of file pencilfft.F90.

     type(model_state_type), target, intent(inout) :: current_state
     complex(C_DOUBLE_COMPLEX), dimension(:,:,:),  contiguous, pointer, intent(out) :: buffer2
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(inout) :: buffer1, buffer3
 
     ! Go from global Y pencil to global X pencil
     call transpose_to_pencil(x_from_y_transposition, (/y_index, x_index, z_index/), dim_x_comm, forward, &
        buffer1, fft_in_x_buffer)   
 
     call perform_r2c_fft(fft_in_x_buffer, buffer2, x_from_y_transposition%my_pencil_size(x_index), &
          x_from_y_transposition%my_pencil_size(y_index) * x_from_y_transposition%my_pencil_size(z_index), 3)
 
     call convert_complex_to_real(buffer2, buffer3)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transpose_and_forward_fft_in_y()

subroutine pencil_fft_mod::transpose_and_forward_fft_in_y	(	type(model_state_type), intent(inout), target	current_state,
		real(kind=default_precision), dimension(:,:,:), intent(inout)	source_data,
		complex(c_double_complex), dimension(:,:,:), intent(out), pointer, contiguous	buffer,
		real(kind=default_precision), dimension(:,:,:), intent(out)	real_buffer
	)

private

Performs the transposition and forward FFT in the y dimension then converts back to real numbers. The Y size is (n/2+1)*2 due to the complex to real transformation after the FFT.

Parameters

current_state	The current model state
source_data	Input buffer, Z pencil oriented z,y,x
buffer	Complex buffer which the FFT writes into
real_buffer	Output buffer, Y pencil, oriented y,x,z

Definition at line 267 of file pencilfft.F90.

     type(model_state_type), target, intent(inout) :: current_state
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(inout) :: source_data
     real(kind=DEFAULT_PRECISION), dimension(:,:,:),  intent(out) :: real_buffer
     complex(C_DOUBLE_COMPLEX), dimension(:,:,:),  contiguous, pointer, intent(out) :: buffer
 
     ! Transpose globally from Z pencil to Y pencil
     call transpose_to_pencil(y_from_z_transposition, (/z_index, y_index, x_index/), dim_y_comm, forward, &
        source_data, fft_in_y_buffer)
     
     call perform_r2c_fft(fft_in_y_buffer, buffer, y_from_z_transposition%my_pencil_size(y_index), &
          y_from_z_transposition%my_pencil_size(x_index) * y_from_z_transposition%my_pencil_size(z_index), 1)
     call convert_complex_to_real(buffer, real_buffer)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transpose_to_pencil()

subroutine pencil_fft_mod::transpose_to_pencil	(	type(pencil_transposition), intent(in)	transposition_description,
		integer, dimension(3), intent(in)	source_dims,
		integer, intent(in)	communicator,
		integer, intent(in)	direction,
		real(kind=default_precision), dimension(:,:,:), intent(in)	source_data,
		real(kind=default_precision), dimension(:,:,:), intent(out)	target_data
	)

private

Transposes globally to a new pencil decomposition. This goes from the source dimensions a,b,c to b,c,a (forwards) or c,a,b (backwards.) It requires multiple steps, first the local data is transposed to c,b,a regardless of direction. then it is communicated via alltoall, each process then assembles its own b,c,a or c,a,b data via contiguising across blocks as the data layout is nonlinear.

Parameters

transposition_description	Description of the transposition
source_dims	Dimensions of the current pencil that we wish to transpose from, will go from abc to bca
communicator	The MPI communicator associated with the group of processes who will swap data
direction	Whether this is going forwards or backwards, it makes a difference to the data arrangement
source_data	Source data (abc)
target_data	Target data (bca)

Definition at line 358 of file pencilfft.F90.

     type(pencil_transposition), intent(in) :: transposition_description
     integer, intent(in) :: source_dims(3), communicator, direction
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(in) :: source_data
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), intent(out) :: target_data
 
     integer :: ierr
     real(kind=DEFAULT_PRECISION), dimension(:,:,:), allocatable :: real_temp
     real(kind=DEFAULT_PRECISION), dimension(:), allocatable :: real_temp2
     
     
     allocate(real_temp(size(source_data,3), size(source_data,2), size(source_data,1)), &
          real_temp2(product(transposition_description%my_pencil_size)+1))
 
     call rearrange_data_for_sending(real_source=source_data, real_target=real_temp)    
 
     call mpi_alltoallv(real_temp, transposition_description%send_sizes, transposition_description%send_offsets, &
          precision_type, real_temp2, transposition_description%recv_sizes, transposition_description%recv_offsets, &
          precision_type, communicator, ierr)
     call contiguise_data(transposition_description, (/source_dims(3), source_dims(2), source_dims(1)/), direction, &
          source_real_buffer=real_temp2, target_real_buffer=target_data)
     deallocate(real_temp, real_temp2)   

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ backward

integer, parameter pencil_fft_mod::backward =2

private

Transposition directions.

Definition at line 28 of file pencilfft.F90.

◆ buffer1

complex(c_double_complex), dimension(:,:,:), pointer, contiguous pencil_fft_mod::buffer1

private

Definition at line 37 of file pencilfft.F90.

37 complex(C_DOUBLE_COMPLEX), dimension(:,:,:), contiguous, pointer :: buffer1, buffer2

◆ buffer2

complex(c_double_complex), dimension(:,:,:), pointer, contiguous pencil_fft_mod::buffer2

private

Definition at line 37 of file pencilfft.F90.

◆ dim_x_comm

integer pencil_fft_mod::dim_x_comm

private

Communicators for each dimension.

Definition at line 29 of file pencilfft.F90.

◆ dim_y_comm

integer pencil_fft_mod::dim_y_comm

private

Definition at line 29 of file pencilfft.F90.

29 integer :: dim_y_comm, dim_x_comm

◆ fft_in_x_buffer

real(kind=default_precision), dimension(:,:,:), pointer, contiguous pencil_fft_mod::fft_in_x_buffer

private

Definition at line 35 of file pencilfft.F90.

◆ fft_in_y_buffer

real(kind=default_precision), dimension(:,:,:), pointer, contiguous pencil_fft_mod::fft_in_y_buffer

private

Definition at line 35 of file pencilfft.F90.

◆ fftw_plan

type(c_ptr), dimension(4) pencil_fft_mod::fftw_plan

private

Definition at line 40 of file pencilfft.F90.

40 type(c_ptr) :: fftw_plan(4)

◆ fftw_plan_initialised

logical, dimension(4) pencil_fft_mod::fftw_plan_initialised =.false.

private

Definition at line 41 of file pencilfft.F90.

41 logical :: fftw_plan_initialised(4)=.false.

◆ forward

integer, parameter pencil_fft_mod::forward =1

private

Definition at line 28 of file pencilfft.F90.

28 integer, parameter :: forward=1, backward=2

◆ real_buffer1

real(kind=default_precision), dimension(:,:,:), pointer, contiguous pencil_fft_mod::real_buffer1

private

Definition at line 35 of file pencilfft.F90.

35 real(kind=DEFAULT_PRECISION), dimension(:,:,:), contiguous, pointer :: real_buffer1, real_buffer2, real_buffer3, &

36 fft_in_y_buffer , fft_in_x_buffer

◆ real_buffer2

real(kind=default_precision), dimension(:,:,:), pointer, contiguous pencil_fft_mod::real_buffer2

private

Definition at line 35 of file pencilfft.F90.

◆ real_buffer3

real(kind=default_precision), dimension(:,:,:), pointer, contiguous pencil_fft_mod::real_buffer3

private

Definition at line 35 of file pencilfft.F90.

◆ x_from_y_2_transposition

type(pencil_transposition) pencil_fft_mod::x_from_y_2_transposition

private

Definition at line 31 of file pencilfft.F90.

◆ x_from_y_transposition

type(pencil_transposition) pencil_fft_mod::x_from_y_transposition

private

Definition at line 31 of file pencilfft.F90.

◆ y_from_x_2_transposition

type(pencil_transposition) pencil_fft_mod::y_from_x_2_transposition

private

Definition at line 31 of file pencilfft.F90.

◆ y_from_x_transposition

type(pencil_transposition) pencil_fft_mod::y_from_x_transposition

private

Definition at line 31 of file pencilfft.F90.

◆ y_from_z_2_transposition

type(pencil_transposition) pencil_fft_mod::y_from_z_2_transposition

private

Definition at line 31 of file pencilfft.F90.

◆ y_from_z_transposition

type(pencil_transposition) pencil_fft_mod::y_from_z_transposition

private

Definition at line 31 of file pencilfft.F90.

31 type(pencil_transposition) :: y_from_z_transposition, x_from_y_transposition, y_from_x_transposition, z_from_y_transposition, &

32 y_from_z_2_transposition, x_from_y_2_transposition, y_from_x_2_transposition, z_from_y_2_transposition

◆ z_from_y_2_transposition

type(pencil_transposition) pencil_fft_mod::z_from_y_2_transposition

private

Definition at line 31 of file pencilfft.F90.

◆ z_from_y_transposition

type(pencil_transposition) pencil_fft_mod::z_from_y_transposition

private

Definition at line 31 of file pencilfft.F90.

Data Types

Functions/Subroutines

Variables

Detailed Description

Function/Subroutine Documentation

◆ concatenate_dimension_sizes()

◆ contiguise_data()

◆ convert_complex_to_real()

◆ convert_real_to_complex()

◆ create_initial_transposition_description()

◆ create_transposition()

◆ deduce_my_global_start()

◆ determine_matching_process_dimensions()

◆ determine_my_pencil_location()

◆ determine_my_process_sizes_per_dim()

◆ determine_offsets_from_size()

◆ determine_pencil_process_dimensions()

◆ determine_pencil_size()

◆ finalise_pencil_fft()

◆ initialise_buffers()

◆ initialise_pencil_fft()

◆ initialise_transpositions()

◆ is_extended_dimension()

◆ normal_to_extended_process_dim_sizes()

◆ perform_backwards_3dfft()

◆ perform_c2r_fft()

◆ perform_forward_3dfft()

◆ perform_r2c_fft()

◆ rearrange_data_for_sending()

◆ transpose_and_backward_fft_in_x()

◆ transpose_and_backward_fft_in_y()

◆ transpose_and_forward_fft_in_x()

◆ transpose_and_forward_fft_in_y()

◆ transpose_to_pencil()

Variable Documentation

◆ backward

◆ buffer1

◆ buffer2

◆ dim_x_comm

◆ dim_y_comm

◆ fft_in_x_buffer

◆ fft_in_y_buffer

◆ fftw_plan

◆ fftw_plan_initialised

◆ forward

◆ real_buffer1

◆ real_buffer2

◆ real_buffer3

◆ x_from_y_2_transposition

◆ x_from_y_transposition

◆ y_from_x_2_transposition

◆ y_from_x_transposition

◆ y_from_z_2_transposition

◆ y_from_z_transposition

◆ z_from_y_2_transposition

◆ z_from_y_transposition