stencil_mod Module Reference

Performs the interpolation between the primal and dual grids via a stencil approach. For performance reasons, for each field we store the entirety of the y dimension and the number of x slices required by the stencil. Therefore a new interpolation is simply the calculation of one point and reuse of existing computed points (unless this is the first x or y.) The applicable interpolation stenciled data is copied out, with :,1,1 being the central point, minus and plus in each y and x dimension as determined by the stencil size. This is done so that the stencil size can easily be different for each flow field and this is the case with u (where we need u-2 in the X.) More...

Data Types
type	grid_stencil_type
	Configuration for a specific stencil interpolation to perform. More...

Functions/Subroutines
type(grid_stencil_type) function, public	create_stencil (local_grid, fields, nfields, interpolations_to_perform, sizes, xdim, ydim)
	Creates a stencil configuration which will then be used for interpolation. More...
subroutine, public	free_stencil (stencil)
	Frees up the memory allocated to a stencil. More...
subroutine, public	interpolate_to_dual (local_grid, field, stencil, x, y, interpolated_fields, interpolation_id)
	Interpolates the (vector) flow fields from the primal to dual grid based upon a specific field interpolation. More...
subroutine	calculate_interpolated_cell_value (local_grid, j, i, interpolate_in_dimension, field, column_stencil_values)
	Calculates the interpolated values for each point in a column. The exact method of interpolation depends on whether we are interpolating in the w, y or x dimension. More...
subroutine	copy_interpolated_to_prognostic (interpolated_fields, stencil, local_grid, x, y, interpolation_id)
	Copies stencil number of interpolated values from the store used by this functionality to preallocated prognostics. THe central point is always :,1,1 in the prognostic, with negative and in the x and y. More...

Detailed Description

Performs the interpolation between the primal and dual grids via a stencil approach. For performance reasons, for each field we store the entirety of the y dimension and the number of x slices required by the stencil. Therefore a new interpolation is simply the calculation of one point and reuse of existing computed points (unless this is the first x or y.) The applicable interpolation stenciled data is copied out, with :,1,1 being the central point, minus and plus in each y and x dimension as determined by the stencil size. This is done so that the stencil size can easily be different for each flow field and this is the case with u (where we need u-2 in the X.)

Function/Subroutine Documentation

calculate_interpolated_cell_value()

subroutine stencil_mod::calculate_interpolated_cell_value ( type(local_grid_type), intent(inout)  local_grid, integer, intent(in)  j, integer, intent(in)  i, logical, dimension(3)  interpolate_in_dimension, type(prognostic_field_ptr_type), intent(inout)  field, real(kind=default_precision), dimension(:), intent(inout)  column_stencil_values  )

private

Calculates the interpolated values for each point in a column. The exact method of interpolation depends on whether we are interpolating in the w, y or x dimension.

Parameters

local_grid	The local grid
j	Current local index in the y dimension
i	Current local index in the x dimension
interpolate_in_dimension	Which dimensions to interpolate in
field	The field to interpolate from
column_stencil_values	The result of the interpolation for the specific column

Definition at line 147 of file stencil.F90.

    type(local_grid_type), intent(inout) :: local_grid
    integer, intent(in) :: j,i
    logical, dimension(3) :: interpolate_in_dimension
    type(prognostic_field_ptr_type), intent(inout) :: field
    real(kind=default_precision), dimension(:), intent(inout) :: column_stencil_values
 
    integer :: k, y_interpol, x_interpol
 
    y_interpol=merge(j+1, j, interpolate_in_dimension(2))
    x_interpol=merge(i+1, i, interpolate_in_dimension(3))
 
    do k=1, local_grid%size(z_index)
      if (y_interpol .lt. 1 .or. y_interpol .gt. local_grid%local_domain_end_index(y_index)+ local_grid%halo_size(y_index) &
           .or. x_interpol .lt. 1 .or. x_interpol .gt. local_grid%local_domain_end_index(x_index)+ local_grid%halo_size(x_index) &
           .or. (interpolate_in_dimension(1) .and. k == local_grid%size(z_index))) then
        column_stencil_values(k)=field%ptr%data(k,j,i)
      else
        column_stencil_values(k)=0.5_default_precision*(&
             field%ptr%data(k,j,i) + field%ptr%data(merge(k+1, k, interpolate_in_dimension(1)), y_interpol, x_interpol))
      end if
    end do

Here is the caller graph for this function:

copy_interpolated_to_prognostic()

subroutine stencil_mod::copy_interpolated_to_prognostic ( type(prognostic_field_type), dimension(:), intent(inout), allocatable  interpolated_fields, type(grid_stencil_type), intent(inout)  stencil, type(local_grid_type), intent(inout)  local_grid, integer, intent(in)  x, integer, intent(in)  y, integer, intent(in)  interpolation_id  )

private

Copies stencil number of interpolated values from the store used by this functionality to preallocated prognostics. THe central point is always :,1,1 in the prognostic, with negative and in the x and y.

Parameters

interpolated_fields	The interpolated field prognostics that will be updated
stencil	The stencil configuration
local_grid	Local grid
x	Local x index of this column
y	Local y index of this column
interpolation_id	The ID of this interpolation which is used to retrieve information from the stencil configuration

Definition at line 179 of file stencil.F90.

    type(prognostic_field_type), dimension(:), allocatable, intent(inout) :: interpolated_fields
    type(local_grid_type), intent(inout) :: local_grid
    type(grid_stencil_type), intent(inout) :: stencil
    integer, intent(in) :: x, y, interpolation_id
 
    integer :: i, y_min_src, y_max_src, x_max_src, y_min_tgt, y_max_tgt, x_min_tgt, x_max_tgt
 
    do i=1,stencil%nfields
      y_min_src=y-stencil%sizes(i,2)
      y_min_tgt=1-stencil%sizes(i,2)
      y_max_src=y+stencil%sizes(i,2)
      y_max_tgt=1+stencil%sizes(i,2)
      x_min_tgt=1-stencil%sizes(i,1)
      x_max_src=stencil%sizes(i,1)*2+1
      x_max_tgt=1+stencil%sizes(i,1)
      if (y_min_src .lt. 1) then 
        y_min_tgt=y_min_tgt+(1-y_min_src)
        y_min_src=1
      end if      
 
      interpolated_fields(i)%data(:,y_min_tgt:y_max_tgt, x_min_tgt:x_max_tgt)=&
           stencil%interpolated_fields(interpolation_id, i)%data(:, y_min_src:y_max_src, 1:x_max_src)
    end do

Here is the caller graph for this function:

create_stencil()

type(grid_stencil_type) function, public stencil_mod::create_stencil	(	type(local_grid_type), intent(inout)	local_grid,
		type(prognostic_field_ptr_type), dimension(:), intent(inout)	fields,
		integer, intent(in)	nfields,
		integer, intent(in)	interpolations_to_perform,
		integer, dimension(:,:), intent(in)	sizes,
		logical, intent(in)	xdim,
		logical, intent(in)	ydim
	)

Creates a stencil configuration which will then be used for interpolation.

Parameters

local_grid	The local grid
fields	The fields to perform the interpolation upon
nfields	The number of fields included in a specific interpolation
interpolations_to_perform	The number of distinct interpolations that will be performed
sizes	The size of the stencil, for each field, in X and Y dimensions
xdim	Whether the X dimension is active
ydim	Whether the Y dimension is active

Definition at line 36 of file stencil.F90.

    type(local_grid_type), intent(inout) :: local_grid
    type(prognostic_field_ptr_type), dimension(:), intent(inout) :: fields
    integer, dimension(:,:), intent(in) :: sizes
    integer, intent(in) :: nfields, interpolations_to_perform
    logical, intent(in) :: xdim, ydim
 
    integer :: j,i
 
    allocate(create_stencil%fields(0:nfields), create_stencil%interpolated_fields(interpolations_to_perform,nfields))
    allocate(create_stencil%sizes(nfields,2))
    do j=1,nfields
      create_stencil%fields(j) = fields(j)
      create_stencil%sizes(j,1) = merge(sizes(j,1), 0, xdim)
      create_stencil%sizes(j,2) = merge(sizes(j,2), 0, ydim)
      do i=1,interpolations_to_perform
        allocate(create_stencil%interpolated_fields(i, j)%data(local_grid%size(z_index), &
             local_grid%size(y_index)+4, create_stencil%sizes(j,1)*2+1))
      end do
    end do
    create_stencil%nfields=nfields
    create_stencil%max_y_point=(local_grid%size(y_index)+local_grid%halo_size(y_index) * 2) - 1
    create_stencil%max_x_point=(local_grid%size(x_index)+local_grid%halo_size(x_index) * 2) - 1

Here is the caller graph for this function:

free_stencil()

subroutine, public stencil_mod::free_stencil

(

type(grid_stencil_type), intent(inout)

stencil

)

Frees up the memory allocated to a stencil.

Parameters

stencil

The stencil that we will free up

Definition at line 63 of file stencil.F90.

    type(grid_stencil_type), intent(inout) :: stencil
 
    integer :: j, i
 
    if (allocated(stencil%interpolated_fields)) then
      do i=1, size(stencil%interpolated_fields,1)
        do j=1, size(stencil%interpolated_fields,2)
          if (allocated(stencil%interpolated_fields(i,j)%data)) deallocate(stencil%interpolated_fields(i,j)%data)
        end do
      end do
      deallocate(stencil%fields, stencil%interpolated_fields)
    end if
    if (allocated(stencil%sizes)) deallocate(stencil%sizes)

interpolate_to_dual()

subroutine, public stencil_mod::interpolate_to_dual	(	type(local_grid_type), intent(inout)	local_grid,
		type(prognostic_field_type), intent(inout)	field,
		type(grid_stencil_type), intent(inout)	stencil,
		integer, intent(in)	x,
		integer, intent(in)	y,
		type(prognostic_field_type), dimension(:), intent(inout), allocatable	interpolated_fields,
		integer, intent(in)	interpolation_id
	)

Interpolates the (vector) flow fields from the primal to dual grid based upon a specific field interpolation.

Parameters

local_grid	The local grid
field	The field to base this interpolation upon
stencil	Stencil configuration
x	Local column index in X
y	Local column index in Y
interpolated_fields	Interpolated prognostics that this will write the output into, central (x,y) point is 1,1
interpolation_id	Id of the interpolation

Definition at line 87 of file stencil.F90.

    type(prognostic_field_type), intent(inout) :: field
    type(local_grid_type), intent(inout) :: local_grid
    type(grid_stencil_type), intent(inout) :: stencil
    type(prognostic_field_type), dimension(:), allocatable, intent(inout) :: interpolated_fields
    integer, intent(in) :: x, y, interpolation_id
 
    integer :: i,j,n, x_top, base_x, y_start, y_top, x_start, abs_x_top
    logical, dimension(3) :: interpolate_in_dimension
 
    interpolate_in_dimension = get_field_interpolation_index(field)
 
    do n=1,stencil%nfields
      base_x=x-(stencil%sizes(n,1)+1)
      abs_x_top=x+stencil%sizes(n,1)
      x_start=1
      if (base_x .lt. 0) x_start=x_start+(0-base_x)
      x_top=stencil%sizes(n,1)*2+1
      y_start=y-stencil%sizes(n,2)
      y_top=y+stencil%sizes(n,2)
      if (y_start .lt. 1) y_start=1
 
      if (x==2) then
        ! If this is the first x slice then compute all points on y dimension up to x top - 1
        do i=x_start,x_top-1
          do j=y_start, y_top
              call calculate_interpolated_cell_value(local_grid, j, base_x+i, interpolate_in_dimension, stencil%fields(n), &
                   stencil%interpolated_fields(interpolation_id,n)%data(:,j,i))            
          end do
        end do
      end if
 
      if (y==2) then
        ! If this is the first column in y then shift X down (as only store required data) and calculate y to y top -1
        if (x/=2) then
          do i=1, x_top-1
            stencil%interpolated_fields(interpolation_id,n)%data(:,:,i)=&
                 stencil%interpolated_fields(interpolation_id,n)%data(:,:,i+1)
          end do
        end if
        do j=y_start, y_top-1
          call calculate_interpolated_cell_value(local_grid, j, abs_x_top, interpolate_in_dimension, stencil%fields(n), &
               stencil%interpolated_fields(interpolation_id,n)%data(:,j,x_top))
        end do
      end if
      ! Calculate y top, x top which is done for each column
      call calculate_interpolated_cell_value(local_grid, y_top, abs_x_top, interpolate_in_dimension, stencil%fields(n), &
           stencil%interpolated_fields(interpolation_id,n)%data(:,y_top,x_top))
    end do
    call copy_interpolated_to_prognostic(interpolated_fields, stencil, local_grid, x, y, interpolation_id)

Here is the call graph for this function: