checkpointer_write_checkpoint_mod Module Reference

Writes out model state_mod to a checkpoint NetCDF file. More...

Functions/Subroutines
subroutine, public	write_checkpoint_file (current_state, filename)
	Will write out the current model state_mod into a NetCDF checkpoint file. More...
subroutine	write_out_global_attributes (ncid)
	Writes out global attributes into the checkpoint. More...
subroutine	write_out_q_indices (ncid, q_indices_id)
	Writes out the specific Q indicies that are active and need writing. More...
subroutine	write_out_options (current_state, ncid, options_id)
	Writes out the options that the model was run with. More...
subroutine	write_out_all_fields (current_state, ncid, u_id, v_id, w_id, zu_id, zv_id, zw_id, th_id, zth_id, q_id, zq_id, p_id)
	Will write out all prognostic model fields to the checkpoint. It will work in 1, 2 or 3D depending on the model. More...
subroutine	write_out_velocity_field (ncid, local_grid, field, variable_id, multi_process, fourth_dim_loc)
	Will write out a single velocity field to the checkpoint file. If there are multiple processes then will determine the bounds, otherwise for serial just dump data field. More...
subroutine	write_out_grid (ncid, grid)
	Will write out the grid to the checkpoint, it will work in 1, 2 or 3D depending on what is in the model. More...
subroutine	write_out_mean_fields (ncid, grid)
subroutine	write_z_grid_gimension (ncid, vertical_grid)
	Writes out the Z dimension of the grids_mod points which are explicitly calculated. More...
subroutine	define_options_variable (current_state, ncid, string_dim_id, key_value_dim_id, options_id)
	Defines the NetCDF options variable which is basically a 3D character array to form key-value pair strings for each entry. More...
logical function	define_q_indices_variable (ncid, string_dim_id, key_value_dim_id, q_indices_id)
	Defines the NetCDF Q indices variable which is, same as the options, stored as key-value pair of strings. This will only store and create these dimensions if there are any Q indicies to store. More...
subroutine	define_q_field_dimension (current_state, ncid, q_dim_id)
	Defines the Q field dimension in the NetCDF. More...
subroutine	define_grid_dimensions (current_state, ncid, z_dim_id, y_dim_id, x_dim_id)
	Will define the grid dimensions and works for 1, 2 or 3D grids_mod. More...
subroutine	define_grid_variables (current_state, ncid)
	Defines the NetCDF grid variables. This works for 1, 2 or 3D grids_mod. More...
subroutine	define_mean_fields (current_state, ncid)
subroutine	define_q_variable (ncid, multi_process, q_dim_id, z_dim_id, y_dim_id, x_dim_id, q_id, zq_id)
	Defines the Q variable in the checkpoint file. More...
subroutine	define_prognostic_variables (current_state, multi_process, ncid, z_dim_id, y_dim_id, x_dim_id, u_id, v_id, w_id, th_id, p_id, zu_id, zv_id, zw_id, zth_id)
	Defines prognostic variables in the NetCDF. This handles 1, 2 and 3D grids_mod and 1, 2 and 3D fields, which most likely have the same dimensions but this is not mandatory here. All prognostic fields are 3D, if the grid is not 3D then the empty (size 1) dimension is used in that dimension. More...
subroutine	define_misc_variables (ncid, timestep_id, time_id, ugal_id, vgal_id, number_q_fields_id, dtm_id, dtm_new_id, absolute_new_dtm_id)
	Defines misc variables in the NetCDF file. More...
subroutine	write_out_misc_variables (current_state, ncid, timestep_id, time_id, ugal_id, vgal_id, number_q_fields_id, dtm_id, dtm_new_id, absolute_new_dtm_id)
	Will dump out (write) misc model data to the checkpoint. More...
subroutine	define_velocity_variable (ncid, multi_process, dimone, dimtwo, dimthree, field_name, field_id)
	Will define a single velocity variable in the NetCDF file. More...

Variables
character(len= *), parameter	checkpoint_title = "MONC checkpoint file"
	Title of the NetCDF file. More...

Detailed Description

Writes out model state_mod to a checkpoint NetCDF file.

Function/Subroutine Documentation

define_grid_dimensions()

subroutine checkpointer_write_checkpoint_mod::define_grid_dimensions ( type(model_state_type), intent(inout)  current_state, integer, intent(in)  ncid, integer, intent(out)  z_dim_id, integer, intent(out)  y_dim_id, integer, intent(out)  x_dim_id  )

private

Will define the grid dimensions and works for 1, 2 or 3D grids_mod.

Parameters

current_state	The current model state_mod
ncid	The NetCDF file id
z_dim_id	The NetCDF z dimension id that is provided by this procedure
y_dim_id	The NetCDF y dimension id that is provided by this procedure
x_dim_id	The NetCDF x dimension id that is provided by this procedure

Definition at line 399 of file writecheckpoint.F90.

    type(model_state_type), intent(inout) :: current_state
    integer, intent(in) :: ncid
    integer, intent(out) :: z_dim_id, y_dim_id, x_dim_id

    integer :: empty_dim_id

    call check_status(nf90_def_dim(ncid, empty_dim_key, 1, empty_dim_id))

    if (current_state%global_grid%active(z_index)) then
      call check_status(nf90_def_dim(ncid, z_dim_key, current_state%global_grid%size(z_index), z_dim_id))
      call check_status(nf90_def_dim(ncid, zn_dim_key, current_state%global_grid%size(z_index), z_dim_id))
    else
      z_dim_id = empty_dim_id
    end if
    if (current_state%global_grid%active(y_index)) then
      call check_status(nf90_def_dim(ncid, y_dim_key, current_state%global_grid%size(y_index), y_dim_id))
    else
      y_dim_id = empty_dim_id
    end if
    if (current_state%global_grid%active(x_index)) then
      call check_status(nf90_def_dim(ncid, x_dim_key, current_state%global_grid%size(x_index), x_dim_id))
    else
      x_dim_id = empty_dim_id
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

define_grid_variables()

subroutine checkpointer_write_checkpoint_mod::define_grid_variables ( type(model_state_type), intent(inout)  current_state, integer, intent(in)  ncid  )

private

Defines the NetCDF grid variables. This works for 1, 2 or 3D grids_mod.

Parameters

current_state	The current model state_mod
ncid	The NetCDF file id
z_dim_id	The NetCDF z dimension id
y_dim_id	The NetCDF y dimension id
x_dim_id	The NetCDF x dimension id
x_id	The NetCDF x variable id provided by this procedure
y_id	The NetCDF y variable id provided by this procedure
z_id	The NetCDF z variable id provided by this procedure

Definition at line 435 of file writecheckpoint.F90.

    type(model_state_type), intent(inout) :: current_state
    integer, intent(in) :: ncid

    integer :: var_id, z_dim_id

    if (current_state%global_grid%active(x_index)) then
      call check_status(nf90_def_var(ncid, x_resolution, nf90_double, var_id))
      call check_status(nf90_put_att(ncid, var_id, "units", "m"))
      call check_status(nf90_def_var(ncid, x_top, nf90_double, var_id))
      call check_status(nf90_put_att(ncid, var_id, "units", "m"))
      call check_status(nf90_def_var(ncid, x_bottom, nf90_double, var_id))
      call check_status(nf90_put_att(ncid, var_id, "units", "m"))
    end if
    if (current_state%global_grid%active(y_index)) then
      call check_status(nf90_def_var(ncid, y_resolution, nf90_double, var_id))
      call check_status(nf90_put_att(ncid, var_id, "units", "m"))
      call check_status(nf90_def_var(ncid, y_top, nf90_double, var_id))
      call check_status(nf90_put_att(ncid, var_id, "units", "m"))
      call check_status(nf90_def_var(ncid, y_bottom, nf90_double, var_id))
      call check_status(nf90_put_att(ncid, var_id, "units", "m"))
    end if
    if (current_state%global_grid%active(z_index)) then
      call check_status(nf90_inq_dimid(ncid, z_dim_key, z_dim_id))
      call check_status(nf90_def_var(ncid, z_key, nf90_double, z_dim_id, var_id))
      call check_status(nf90_put_att(ncid, var_id, "units", "m"))
      call check_status(nf90_inq_dimid(ncid, zn_dim_key, z_dim_id))
      call check_status(nf90_def_var(ncid, zn_key, nf90_double, z_dim_id, var_id))
      call check_status(nf90_put_att(ncid, var_id, "units", "m"))
    end if
    call check_status(nf90_inq_dimid(ncid, z_dim_key, z_dim_id))
    call check_status(nf90_def_var(ncid, thref, nf90_double, z_dim_id, var_id))

Here is the call graph for this function:

Here is the caller graph for this function:

define_mean_fields()

subroutine checkpointer_write_checkpoint_mod::define_mean_fields ( type(model_state_type), intent(inout)  current_state, integer, intent(in)  ncid  )

private

Definition at line 469 of file writecheckpoint.F90.

    type(model_state_type), intent(inout) :: current_state
    integer, intent(in) :: ncid

    integer :: var_id, z_dim_id, q_dim_id, qdimids(2)

    call check_status(nf90_inq_dimid(ncid, z_dim_key, z_dim_id))

    if (allocated(current_state%global_grid%configuration%vertical%olubar)) then
      call check_status(nf90_def_var(ncid, olubar, nf90_double, z_dim_id, var_id))
    end if    
    if (allocated(current_state%global_grid%configuration%vertical%olzubar)) then
      call check_status(nf90_def_var(ncid, olzubar, nf90_double, z_dim_id, var_id))
    end if
    if (allocated(current_state%global_grid%configuration%vertical%olvbar)) then
      call check_status(nf90_def_var(ncid, olvbar, nf90_double, z_dim_id, var_id))
    end if
    if (allocated(current_state%global_grid%configuration%vertical%olzvbar)) then
      call check_status(nf90_def_var(ncid, olzvbar, nf90_double, z_dim_id, var_id))
    end if
    if (allocated(current_state%global_grid%configuration%vertical%olthbar)) then
      call check_status(nf90_def_var(ncid, olthbar, nf90_double, z_dim_id, var_id))
    end if    
    if (allocated(current_state%global_grid%configuration%vertical%olzthbar)) then
      call check_status(nf90_def_var(ncid, olzthbar, nf90_double, z_dim_id, var_id))
    end if
    if (allocated(current_state%global_grid%configuration%vertical%olqbar) .or. &
         allocated(current_state%global_grid%configuration%vertical%olzqbar)) then
      call check_status(nf90_inq_dimid(ncid, q_dim_key, q_dim_id))
      qdimids=(/ z_dim_id, q_dim_id /)
      if (allocated(current_state%global_grid%configuration%vertical%olqbar)) then
        call check_status(nf90_def_var(ncid, olqbar, nf90_double, qdimids, var_id))
      end if
      if (allocated(current_state%global_grid%configuration%vertical%olzqbar)) then
        call check_status(nf90_def_var(ncid, olzqbar, nf90_double, qdimids, var_id))
      end if
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

define_misc_variables()

subroutine checkpointer_write_checkpoint_mod::define_misc_variables ( integer, intent(in)  ncid, integer, intent(out)  timestep_id, integer, intent(out)  time_id, integer, intent(out)  ugal_id, integer, intent(out)  vgal_id, integer, intent(out)  number_q_fields_id, integer, intent(out)  dtm_id, integer, intent(out)  dtm_new_id, integer, intent(out)  absolute_new_dtm_id  )

private

Defines misc variables in the NetCDF file.

Parameters

ncid	The NetCDF file id
timestep_id	The NetCDF timestep variable

Definition at line 584 of file writecheckpoint.F90.

    integer, intent(in) :: ncid
    integer, intent(out) :: timestep_id, time_id, ugal_id, vgal_id, number_q_fields_id, dtm_id, dtm_new_id, absolute_new_dtm_id

    call check_status(nf90_def_var(ncid, timestep, nf90_int, timestep_id))
    call check_status(nf90_def_var(ncid, time_key, nf90_double, time_id))
    call check_status(nf90_def_var(ncid, ugal, nf90_double, ugal_id))
    call check_status(nf90_def_var(ncid, vgal, nf90_double, vgal_id))
    call check_status(nf90_def_var(ncid, nqfields, nf90_int, number_q_fields_id))
    call check_status(nf90_def_var(ncid, dtm_key, nf90_double, dtm_id))
    call check_status(nf90_def_var(ncid, dtm_new_key, nf90_double, dtm_new_id))
    call check_status(nf90_def_var(ncid, absolute_new_dtm_key, nf90_double, absolute_new_dtm_id))

Here is the call graph for this function:

Here is the caller graph for this function:

define_options_variable()

subroutine checkpointer_write_checkpoint_mod::define_options_variable ( type(model_state_type), intent(inout)  current_state, integer, intent(in)  ncid, integer, intent(out)  string_dim_id, integer, intent(out)  key_value_dim_id, integer, intent(out)  options_id  )

private

Defines the NetCDF options variable which is basically a 3D character array to form key-value pair strings for each entry.

Parameters

current_state	The current model state_mod
ncid	The NetCDF file id
options_id	The NetCDF options variable id that is created in this procedure

Definition at line 338 of file writecheckpoint.F90.

    type(model_state_type), intent(inout) :: current_state
    integer, intent(in) :: ncid
    integer, intent(out) :: string_dim_id, key_value_dim_id, options_id

    integer :: options_dim_id, command_dimensions(3)

    call check_status(nf90_def_dim(ncid, string_dim_key, string_length, string_dim_id))
    call check_status(nf90_def_dim(ncid, key_value_pair_key, 2, key_value_dim_id))
    call check_status(nf90_def_dim(ncid, options_dim_key, options_size(current_state%options_database), options_dim_id))

    command_dimensions = (/ string_dim_id, key_value_dim_id, options_dim_id /)

    call check_status(nf90_def_var(ncid, options_key, nf90_char, command_dimensions, options_id))

Here is the call graph for this function:

Here is the caller graph for this function:

define_prognostic_variables()

subroutine checkpointer_write_checkpoint_mod::define_prognostic_variables ( type(model_state_type), intent(inout)  current_state, logical, intent(in)  multi_process, integer, intent(in)  ncid, integer, intent(in)  z_dim_id, integer, intent(in)  y_dim_id, integer, intent(in)  x_dim_id, integer, intent(out)  u_id, integer, intent(out)  v_id, integer, intent(out)  w_id, integer, intent(out)  th_id, integer, intent(out)  p_id, integer, intent(out)  zu_id, integer, intent(out)  zv_id, integer, intent(out)  zw_id, integer, intent(out)  zth_id  )

private

Defines prognostic variables in the NetCDF. This handles 1, 2 and 3D grids_mod and 1, 2 and 3D fields, which most likely have the same dimensions but this is not mandatory here. All prognostic fields are 3D, if the grid is not 3D then the empty (size 1) dimension is used in that dimension.

Parameters

current_state	The current model state_mod
ncid	The NetCDF file id
z_dim_id	The NetCDF z dimension id
y_dim_id	The NetCDF y dimension id
x_dim_id	The NetCDF x dimension id
u_id	The u prognostic field id provided by this procedure
v_id	The v prognostic field id provided by this procedure
w_id	The w prognostic field id provided by this procedure
th_id	The theta prognostic field id provided by this procedure

Definition at line 553 of file writecheckpoint.F90.

    type(model_state_type), intent(inout) :: current_state
    logical, intent(in) :: multi_process
    integer, intent(in) :: ncid, z_dim_id, y_dim_id, x_dim_id
    integer, intent(out) :: u_id, v_id, w_id, th_id, p_id, zu_id, zv_id, zw_id, zth_id

#ifdef U_ACTIVE
    call define_velocity_variable(ncid, multi_process, z_dim_id, y_dim_id, x_dim_id, field_name=u_key, field_id=u_id)
    call define_velocity_variable(ncid, multi_process, z_dim_id, y_dim_id, x_dim_id, field_name=zu_key, field_id=zu_id)
#endif
#ifdef V_ACTIVE
    call define_velocity_variable(ncid, multi_process, z_dim_id, y_dim_id, x_dim_id, field_name=v_key, field_id=v_id)
    call define_velocity_variable(ncid, multi_process, z_dim_id, y_dim_id, x_dim_id, field_name=zv_key, field_id=zv_id)
#endif
#ifdef W_ACTIVE
    call define_velocity_variable(ncid, multi_process, z_dim_id, y_dim_id, x_dim_id, field_name=w_key, field_id=w_id)
    call define_velocity_variable(ncid, multi_process, z_dim_id, y_dim_id, x_dim_id, field_name=zw_key, field_id=zw_id)
#endif
    if (current_state%th%active) then
      call define_velocity_variable(ncid, multi_process, z_dim_id, y_dim_id, x_dim_id, field_name=th_key, field_id=th_id)
      call define_velocity_variable(ncid, multi_process, z_dim_id, y_dim_id, x_dim_id, field_name=zth_key, field_id=zth_id)
    end if
    if (current_state%p%active) then 
      call define_velocity_variable(ncid, multi_process, z_dim_id, y_dim_id, x_dim_id, field_name=p_key, field_id=p_id)
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

define_q_field_dimension()

subroutine checkpointer_write_checkpoint_mod::define_q_field_dimension ( type(model_state_type), intent(inout)  current_state, integer, intent(in)  ncid, integer, intent(out)  q_dim_id  )

private

Defines the Q field dimension in the NetCDF.

Parameters

current_state	The current model state_mod
ncid	The NetCDF file id
q_dim_id	Corresponding NetCDF Q dimension id

Definition at line 385 of file writecheckpoint.F90.

    type(model_state_type), intent(inout) :: current_state
    integer, intent(in) :: ncid
    integer, intent(out) :: q_dim_id

    call check_status(nf90_def_dim(ncid, q_dim_key, current_state%number_q_fields, q_dim_id))

Here is the call graph for this function:

Here is the caller graph for this function:

define_q_indices_variable()

logical function checkpointer_write_checkpoint_mod::define_q_indices_variable ( integer, intent(in)  ncid, integer, intent(in)  string_dim_id, integer, intent(in)  key_value_dim_id, integer, intent(out)  q_indices_id  )

private

Defines the NetCDF Q indices variable which is, same as the options, stored as key-value pair of strings. This will only store and create these dimensions if there are any Q indicies to store.

Parameters

ncid	The NetCDF file id
string_dim_id	The id of the string dimension
key_value_dim_id	The id of the key value pair dimension
q_indices_id	The id that represents this variable in the NetCDF

Returns

Whether or not the dimensions and variable has been declared (it won't be if there are no active Q indicies)

Definition at line 361 of file writecheckpoint.F90.

    integer, intent(in) :: ncid, string_dim_id, key_value_dim_id
    integer, intent(out) :: q_indices_id

    integer :: q_indices_dim_id, command_dimensions(3), number_active_q

    number_active_q=get_number_active_q_indices()

    if (number_active_q == 0) then
      define_q_indices_variable=.false.
    else
      call check_status(nf90_def_dim(ncid, q_indices_dim_key, number_active_q, q_indices_dim_id))

      command_dimensions = (/ string_dim_id, key_value_dim_id, q_indices_dim_id /)

      call check_status(nf90_def_var(ncid, q_indices_key, nf90_char, command_dimensions, q_indices_id))
      define_q_indices_variable=.true.
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

define_q_variable()

subroutine checkpointer_write_checkpoint_mod::define_q_variable ( integer, intent(in)  ncid, logical, intent(in)  multi_process, integer, intent(in)  q_dim_id, integer, intent(in)  z_dim_id, integer, intent(in)  y_dim_id, integer, intent(in)  x_dim_id, integer, intent(out)  q_id, integer, intent(out)  zq_id  )

private

Defines the Q variable in the checkpoint file.

Parameters

ncid	The NetCDF file id
multi_process	Whether to support parallel IO operations or not
q_dim_id	The NetCDF q dimension id
z_dim_id	The NetCDF z dimension id
y_dim_id	The NetCDF y dimension id
x_dim_id	The NetCDF x dimension id
q_id	The NetCDF q variable id provided by this procedure
zq_id	The NetCDF zq variable id provided by this procedure

Definition at line 517 of file writecheckpoint.F90.

    logical, intent(in) :: multi_process
    integer, intent(in) :: ncid, z_dim_id, y_dim_id, x_dim_id, q_dim_id
    integer, intent(out) :: q_id, zq_id

    integer, dimension(:), allocatable :: dimids

    allocate(dimids(4))
    dimids = (/ z_dim_id, y_dim_id, x_dim_id, q_dim_id /)

    call check_status(nf90_def_var(ncid, q_key, merge(nf90_double, nf90_real, &
         default_precision == double_precision), dimids, q_id))
    call check_status(nf90_def_var(ncid, zq_key, merge(nf90_double, nf90_real, &
         default_precision == double_precision), dimids, zq_id))
    
    if (multi_process) then
      call check_status(nf90_def_var_fill(ncid, q_id, 1, 1))
      call check_status(nf90_def_var_fill(ncid, zq_id, 1, 1))
      call check_status(nf90_var_par_access(ncid, q_id, nf90_collective))
      call check_status(nf90_var_par_access(ncid, zq_id, nf90_collective))
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

define_velocity_variable()

subroutine checkpointer_write_checkpoint_mod::define_velocity_variable ( integer, intent(in)  ncid, logical, intent(in)  multi_process, integer, intent(in)  dimone, integer, intent(in), optional  dimtwo, integer, intent(in), optional  dimthree, character(len=*), intent(in)  field_name, integer, intent(out)  field_id  )

private

Will define a single velocity variable in the NetCDF file.

Parameters

ncid	The NetCDF file id
dimone	Size in first dimension
dimtwo	Size in second dimension (optional)
dimthree	Size in third dimension (optional)
field_name	The NetCDF name of the variable
field_id	The NetCDF variable id produced by this procedure

Definition at line 626 of file writecheckpoint.F90.

    integer, intent(in) :: ncid, dimone
    integer, intent(in), optional :: dimtwo, dimthree
    integer, intent(out) :: field_id
    character(len=*), intent(in) :: field_name
    logical, intent(in) :: multi_process

    integer, dimension(:), allocatable :: dimids

    if (present(dimtwo) .and. present(dimthree)) then
      allocate(dimids(3))
      dimids = (/ dimone, dimtwo, dimthree /)
    else if (present(dimtwo) .or. present(dimthree)) then
      allocate(dimids(2))
      dimids = (/ dimone, merge(dimtwo, dimthree, present(dimtwo)) /)
    else
      allocate(dimids(1))
      dimids = (/ dimone /)
    end if

    call check_status(nf90_def_var(ncid, field_name, merge(nf90_double, nf90_real, default_precision == double_precision), &
         dimids, field_id))
    if (multi_process) then
      call check_status(nf90_def_var_fill(ncid, field_id, 1, 1))
      call check_status(nf90_var_par_access(ncid, field_id, nf90_collective))
    end if
    call check_status(nf90_put_att(ncid, field_id, "units", "m/s"))

Here is the call graph for this function:

Here is the caller graph for this function:

write_checkpoint_file()

subroutine, public checkpointer_write_checkpoint_mod::write_checkpoint_file	(	type(model_state_type), intent(inout)	current_state,
		character(len=*), intent(in)	filename
	)

Will write out the current model state_mod into a NetCDF checkpoint file.

Parameters

currentState	The current model state_mod
filename	The filename of the NetCDF file that will be written

Definition at line 41 of file writecheckpoint.F90.

    type(model_state_type), intent(inout) :: current_state
    character(len=*), intent(in) :: filename

    integer :: ncid, z_dim_id, y_dim_id, x_dim_id, q_dim_id, x_id, y_id, z_id, th_id, p_id, time_id,&
         u_id, v_id, w_id, q_id, zu_id, zv_id, zw_id, zth_id, zq_id, timestep_id, ugal_id, &
         vgal_id, number_q_fields_id, string_dim_id, key_value_dim_id, options_id, q_indices_id, &
         dtm_id, dtm_new_id, absolute_new_dtm_id
    logical :: q_indices_declared

#ifdef SINGLE_MONC_DO_SEQUENTIAL_NETCDF
    if (current_state%parallel%processes .gt. 1) then
      call check_status(nf90_create(filename, ior(nf90_netcdf4, nf90_mpiio), ncid, &
           comm = current_state%parallel%monc_communicator, info = mpi_info_null))
    else
      call check_status(nf90_create(filename, nf90_clobber, ncid))
    end if
#else
    call check_status(nf90_create(filename, ior(nf90_netcdf4, nf90_mpiio), ncid, &
         comm = current_state%parallel%monc_communicator, info = mpi_info_null))
#endif
    call write_out_global_attributes(ncid)
    call define_grid_dimensions(current_state, ncid, z_dim_id, y_dim_id, x_dim_id)    
    if (current_state%number_q_fields .gt. 0) call define_q_field_dimension(current_state, ncid, q_dim_id)

    call define_options_variable(current_state, ncid, string_dim_id, key_value_dim_id, options_id)
    q_indices_declared=define_q_indices_variable(ncid, string_dim_id, key_value_dim_id, q_indices_id)
    call define_grid_variables(current_state, ncid)
    call define_mean_fields(current_state, ncid)
    if (current_state%number_q_fields .gt. 0) call define_q_variable(ncid, current_state%parallel%processes .gt. 1, &
         q_dim_id, z_dim_id, y_dim_id, x_dim_id, q_id, zq_id)
    call define_prognostic_variables(current_state, current_state%parallel%processes .gt. 1, ncid, z_dim_id, y_dim_id, &
         x_dim_id, u_id, v_id, w_id, th_id, p_id, zu_id, zv_id, zw_id, zth_id)
    call define_misc_variables(ncid, timestep_id, time_id, ugal_id, vgal_id, number_q_fields_id, &
         dtm_id, dtm_new_id, absolute_new_dtm_id)

    call check_status(nf90_enddef(ncid))

    if (current_state%parallel%my_rank==0) call write_out_grid(ncid, current_state%global_grid)
    if (current_state%parallel%my_rank==0) call write_out_mean_fields(ncid, current_state%global_grid)
    call write_out_all_fields(current_state, ncid, u_id, v_id, w_id, zu_id, zv_id, zw_id, th_id, zth_id, q_id, zq_id, p_id)
    if (current_state%parallel%my_rank==0) then
      call write_out_options(current_state, ncid, options_id)
      if (q_indices_declared) call write_out_q_indices(ncid, q_indices_id)
      call write_out_misc_variables(current_state, ncid, timestep_id, time_id, &
           ugal_id, vgal_id, number_q_fields_id, dtm_id, dtm_new_id, absolute_new_dtm_id)
    end if

    call check_status(nf90_close(ncid))

Here is the call graph for this function:

write_out_all_fields()

subroutine checkpointer_write_checkpoint_mod::write_out_all_fields ( type(model_state_type), intent(inout)  current_state, integer, intent(in)  ncid, integer, intent(in)  u_id, integer, intent(in)  v_id, integer, intent(in)  w_id, integer, intent(in)  zu_id, integer, intent(in)  zv_id, integer, intent(in)  zw_id, integer, intent(in)  th_id, integer, intent(in)  zth_id, integer, intent(in)  q_id, integer, intent(in)  zq_id, integer, intent(in)  p_id  )

private

Will write out all prognostic model fields to the checkpoint. It will work in 1, 2 or 3D depending on the model.

Parameters

current_state	The current model state_mod
ncid	The NetCDF file id
u_id	The NetCDF u field dimension id
v_id	The NetCDF v field dimension id
w_id	The NetCDF w field dimension id

Definition at line 166 of file writecheckpoint.F90.

    type(model_state_type), intent(inout) :: current_state
    integer, intent(in) :: ncid, u_id, v_id, w_id, zu_id, zv_id, zw_id, th_id, zth_id, q_id, zq_id, p_id

    integer :: i
    logical :: multi_process

    multi_process = current_state%parallel%processes .gt. 1
#ifdef U_ACTIVE
    call write_out_velocity_field(ncid, current_state%local_grid, current_state%u, u_id, multi_process)
    call write_out_velocity_field(ncid, current_state%local_grid, current_state%zu, zu_id, multi_process)
#endif
#ifdef V_ACTIVE
    call write_out_velocity_field(ncid, current_state%local_grid, current_state%v, v_id, multi_process)
    call write_out_velocity_field(ncid, current_state%local_grid, current_state%zv, zv_id, multi_process)
#endif
#ifdef W_ACTIVE
    call write_out_velocity_field(ncid, current_state%local_grid, current_state%w, w_id, multi_process)
    call write_out_velocity_field(ncid, current_state%local_grid, current_state%zw, zw_id, multi_process)
#endif
    if (current_state%th%active) then
      call write_out_velocity_field(ncid, current_state%local_grid, current_state%th, th_id, multi_process)
      call write_out_velocity_field(ncid, current_state%local_grid, current_state%zth, zth_id, multi_process)
    end if
    if (current_state%p%active) call write_out_velocity_field(ncid, current_state%local_grid, current_state%p, &
         p_id, multi_process)
    do i=1,current_state%number_q_fields
      if (current_state%q(i)%active) then
        call write_out_velocity_field(ncid, current_state%local_grid, current_state%q(i), q_id, multi_process, i)
        call write_out_velocity_field(ncid, current_state%local_grid, current_state%zq(i), zq_id, multi_process, i)
      end if
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

write_out_global_attributes()

subroutine checkpointer_write_checkpoint_mod::write_out_global_attributes ( integer, intent(in)  ncid )

private

Writes out global attributes into the checkpoint.

Parameters

ncid	NetCDF file id

Definition at line 94 of file writecheckpoint.F90.

    integer, intent(in) :: ncid

    integer :: date_values(8)

    call date_and_time(values=date_values)

    call check_status(nf90_put_att(ncid, nf90_global, title_attribute_key, checkpoint_title))
    call check_status(nf90_put_att(ncid, nf90_global, created_attribute_key, trim(conv_to_string(date_values(3)))//"/"//&
         trim(conv_to_string(date_values(2)))//"/"//trim(conv_to_string(date_values(1)))//" "//trim(conv_to_string(&
         date_values(5)))// ":"//trim(conv_to_string(date_values(6)))//":"//trim(conv_to_string(date_values(7)))))

Here is the call graph for this function:

Here is the caller graph for this function:

write_out_grid()

subroutine checkpointer_write_checkpoint_mod::write_out_grid ( integer, intent(in)  ncid, type(global_grid_type), intent(in)  grid  )

private

Will write out the grid to the checkpoint, it will work in 1, 2 or 3D depending on what is in the model.

Parameters

ncid	The NetCDF file id
grid	The model grid to write out
z_id	The NetCDF z variable id
y_id	The NetCDF y variable id
x_id	The NetCDF x variable id

Definition at line 248 of file writecheckpoint.F90.

    integer, intent(in) :: ncid
    type(global_grid_type), intent(in) :: grid

    integer :: var_id

    if (grid%active(z_index)) then
      call write_z_grid_gimension(ncid, grid%configuration%vertical)
    end if
    if (grid%active(y_index)) then
      call check_status(nf90_inq_varid(ncid, y_resolution, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%resolution(y_index)))
      call check_status(nf90_inq_varid(ncid, y_top, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%top(y_index)))
      call check_status(nf90_inq_varid(ncid, y_bottom, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%bottom(y_index)))
    end if
    if (grid%active(x_index)) then
      call check_status(nf90_inq_varid(ncid, x_resolution, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%resolution(x_index)))
      call check_status(nf90_inq_varid(ncid, x_top, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%top(x_index)))
      call check_status(nf90_inq_varid(ncid, x_bottom, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%bottom(x_index)))
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

write_out_mean_fields()

subroutine checkpointer_write_checkpoint_mod::write_out_mean_fields ( integer, intent(in)  ncid, type(global_grid_type), intent(in)  grid  )

private

Definition at line 275 of file writecheckpoint.F90.

    integer, intent(in) :: ncid
    type(global_grid_type), intent(in) :: grid

    integer :: var_id

    if (allocated(grid%configuration%vertical%olubar)) then
      call check_status(nf90_inq_varid(ncid, olubar, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%configuration%vertical%olubar))
    end if
    if (allocated(grid%configuration%vertical%olzubar)) then
      call check_status(nf90_inq_varid(ncid, olzubar, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%configuration%vertical%olzubar))
    end if
    if (allocated(grid%configuration%vertical%olvbar)) then
      call check_status(nf90_inq_varid(ncid, olvbar, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%configuration%vertical%olvbar))
    end if    
    if (allocated(grid%configuration%vertical%olzvbar)) then
      call check_status(nf90_inq_varid(ncid, olzvbar, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%configuration%vertical%olzvbar))
    end if
    if (allocated(grid%configuration%vertical%olthbar)) then
      call check_status(nf90_inq_varid(ncid, olthbar, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%configuration%vertical%olthbar))
    end if
    if (allocated(grid%configuration%vertical%olzthbar)) then
      call check_status(nf90_inq_varid(ncid, olzthbar, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%configuration%vertical%olzthbar))
    end if    
    if (allocated(grid%configuration%vertical%olqbar)) then
      call check_status(nf90_inq_varid(ncid, olqbar, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%configuration%vertical%olqbar))
    end if
    if (allocated(grid%configuration%vertical%olzqbar)) then
      call check_status(nf90_inq_varid(ncid, olzqbar, var_id))
      call check_status(nf90_put_var(ncid, var_id, grid%configuration%vertical%olzqbar))
    end if    

Here is the call graph for this function:

Here is the caller graph for this function:

write_out_misc_variables()

subroutine checkpointer_write_checkpoint_mod::write_out_misc_variables ( type(model_state_type), intent(inout)  current_state, integer, intent(in)  ncid, integer, intent(in)  timestep_id, integer, intent(in)  time_id, integer, intent(in)  ugal_id, integer, intent(in)  vgal_id, integer, intent(in)  number_q_fields_id, integer, intent(in)  dtm_id, integer, intent(in)  dtm_new_id, integer, intent(in)  absolute_new_dtm_id  )

private

Will dump out (write) misc model data to the checkpoint.

Parameters

current_state	The current model state_mod
ncid	The NetCDF file id
timestep_id	The NetCDF timestep variable id

Definition at line 603 of file writecheckpoint.F90.

    type(model_state_type), intent(inout) :: current_state
    integer, intent(in) :: ncid, timestep_id, time_id, ugal_id, vgal_id, number_q_fields_id, &
         dtm_id, dtm_new_id, absolute_new_dtm_id

    call check_status(nf90_put_var(ncid, timestep_id, current_state%timestep))
    ! The time is incremented with dtm as the model was about to increment for the next step and this is needed for diagnostics
    call check_status(nf90_put_var(ncid, time_id, current_state%time+current_state%dtm))
    call check_status(nf90_put_var(ncid, ugal_id, current_state%ugal))
    call check_status(nf90_put_var(ncid, vgal_id, current_state%vgal))
    call check_status(nf90_put_var(ncid, number_q_fields_id, current_state%number_q_fields))
    call check_status(nf90_put_var(ncid, dtm_id, current_state%dtm))
    call check_status(nf90_put_var(ncid, dtm_new_id, current_state%dtm_new))
    call check_status(nf90_put_var(ncid, absolute_new_dtm_id, current_state%absolute_new_dtm))

Here is the call graph for this function:

Here is the caller graph for this function:

write_out_options()

subroutine checkpointer_write_checkpoint_mod::write_out_options ( type(model_state_type), intent(inout)  current_state, integer, intent(in)  ncid, integer, intent(in)  options_id  )

private

Writes out the options that the model was run with.

Parameters

current_state	The current model state_mod
ncid	The NetCDF file id
options_id	The options NetCDF variable id

Definition at line 131 of file writecheckpoint.F90.

    type(model_state_type), intent(inout) :: current_state
    integer, intent(in) :: ncid, options_id

    integer :: i
    character(len=STRING_LENGTH), pointer :: sized_raw_character
    class(*), pointer :: raw_data, raw_to_string

    do i=1,options_size(current_state%options_database)
      raw_data=> options_value_at(current_state%options_database, i)
      raw_to_string=>raw_data
      call check_status(nf90_put_var(ncid, options_id, trim(options_key_at(current_state%options_database, i)), (/ 1, 1, i /)))
      select type (raw_data)
      type is(integer)
        call check_status(nf90_put_var(ncid, options_id, trim(conv_to_string(raw_data)), (/ 1, 2, i /)))
      type is(real(kind=single_precision))
        call check_status(nf90_put_var(ncid, options_id, trim(conv_to_string(raw_data)), (/ 1, 2, i /)))
      type is(real(kind=double_precision))
        call check_status(nf90_put_var(ncid, options_id, trim(conv_to_string(raw_data)), (/ 1, 2, i /)))
      type is(logical)
        call check_status(nf90_put_var(ncid, options_id, trim(conv_to_string(raw_data)), (/ 1, 2, i /)))
      type is(character(len=*))
        ! Done this way to give the character size information and keep the (unsafe) cast in the conversion module
        sized_raw_character=>conv_to_string(raw_to_string, .false., string_length)
        call check_status(nf90_put_var(ncid, options_id, trim(sized_raw_character), (/ 1, 2, i /)))
      end select
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

write_out_q_indices()

subroutine checkpointer_write_checkpoint_mod::write_out_q_indices ( integer, intent(in)  ncid, integer, intent(in)  q_indices_id  )

private

Writes out the specific Q indicies that are active and need writing.

Parameters

ncid	The NetCDF file id
q_indicies_id	The Q indicies NetCDF variable id

Definition at line 110 of file writecheckpoint.F90.

    integer, intent(in) :: ncid, q_indices_id

    integer :: i, current_index
    type(q_metadata_type) :: specific_q_data

    current_index=1
    do i=1, get_max_number_q_indices()
      specific_q_data=get_indices_descriptor(i)
      if (specific_q_data%l_used) then
        call check_status(nf90_put_var(ncid, q_indices_id, trim(specific_q_data%name), (/ 1, 1, current_index /)))
        call check_status(nf90_put_var(ncid, q_indices_id, trim(conv_to_string(i)), (/ 1, 2, current_index /)))
        current_index=current_index+1
      end if
    end do    

Here is the call graph for this function:

Here is the caller graph for this function:

write_out_velocity_field()

subroutine checkpointer_write_checkpoint_mod::write_out_velocity_field ( integer, intent(in)  ncid, type(local_grid_type), intent(inout)  local_grid, type(prognostic_field_type), intent(in)  field, integer, intent(in)  variable_id, logical, intent(in)  multi_process, integer, intent(in), optional  fourth_dim_loc  )

private

Will write out a single velocity field to the checkpoint file. If there are multiple processes then will determine the bounds, otherwise for serial just dump data field.

Parameters

ncid	The NetCDF file id
field	The model prognostic field to write out
variable_id	The NetCDF variable dimension id

Definition at line 205 of file writecheckpoint.F90.

    integer, intent(in) :: ncid, variable_id
    type(prognostic_field_type), intent(in) :: field
    type(local_grid_type), intent(inout) :: local_grid
    logical, intent(in) :: multi_process
    integer, optional, intent(in) :: fourth_dim_loc

    integer :: start(4), count(4), i, map(4)

    if (multi_process .or. present(fourth_dim_loc)) then
      do i=1,3
        if (i==1) then
          map(i)=1
        else
          map(i)=map(i-1)*local_grid%size(i-1)
        end if
        start(i) = local_grid%start(i)
        count(i) = local_grid%size(i)
      end do
      if (present(fourth_dim_loc)) then
        start(4) = fourth_dim_loc
        count(4) = 1
        map(4)=map(3)*local_grid%size(3)
      end if

      call check_status(nf90_put_var(ncid, variable_id, field%data(local_grid%local_domain_start_index(z_index):&
           local_grid%local_domain_end_index(z_index),local_grid%local_domain_start_index(y_index):&
           local_grid%local_domain_end_index(y_index), local_grid%local_domain_start_index(x_index):&
           local_grid%local_domain_end_index(x_index)), start=start, count=count))
    else
      call check_status(nf90_put_var(ncid, variable_id, field%data(local_grid%local_domain_start_index(z_index):&
           local_grid%local_domain_end_index(z_index),local_grid%local_domain_start_index(y_index):&
           local_grid%local_domain_end_index(y_index), local_grid%local_domain_start_index(x_index):&
           local_grid%local_domain_end_index(x_index))))
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

write_z_grid_gimension()

subroutine checkpointer_write_checkpoint_mod::write_z_grid_gimension ( integer, intent(in)  ncid, type(vertical_grid_configuration_type), intent(in)  vertical_grid  )

private

Writes out the Z dimension of the grids_mod points which are explicitly calculated.

Parameters

ncid	The NetCDF file id
verticalGrid	The vertical grid configuration
z_id	The NetCDF id of the z field

Definition at line 319 of file writecheckpoint.F90.

    type(vertical_grid_configuration_type), intent(in) :: vertical_grid
    integer, intent(in) :: ncid

    integer :: z_var_id, zn_var_id, thref_var_id

    call check_status(nf90_inq_varid(ncid, z_key, z_var_id))
    call check_status(nf90_put_var(ncid, z_var_id, vertical_grid%z))
    call check_status(nf90_inq_varid(ncid, zn_key, zn_var_id))
    call check_status(nf90_put_var(ncid, zn_var_id, vertical_grid%zn))
    call check_status(nf90_inq_varid(ncid, thref, thref_var_id))
    call check_status(nf90_put_var(ncid, thref_var_id, vertical_grid%thref))

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

checkpoint_title

character(len=*), parameter checkpointer_write_checkpoint_mod::checkpoint_title = "MONC checkpoint file"

private

Title of the NetCDF file.

Definition at line 31 of file writecheckpoint.F90.

  character(len=*), parameter :: checkpoint_title = "MONC checkpoint file"