mom_restart::query_initialized Interface Reference

Detailed Description

Definition at line 143 of file MOM_restart.F90.

Private functions
logical function	query_initialized_name (name, CS)
logical function	query_initialized_0d (f_ptr, CS)
logical function	query_initialized_0d_name (f_ptr, name, CS)
logical function	query_initialized_1d (f_ptr, CS)
logical function	query_initialized_1d_name (f_ptr, name, CS)
logical function	query_initialized_2d (f_ptr, CS)
logical function	query_initialized_2d_name (f_ptr, name, CS)
logical function	query_initialized_3d (f_ptr, CS)
logical function	query_initialized_3d_name (f_ptr, name, CS)
logical function	query_initialized_4d (f_ptr, CS)
logical function	query_initialized_4d_name (f_ptr, name, CS)

Functions and subroutines

query_initialized_0d()

logical function mom_restart::query_initialized::query_initialized_0d ( real, target  f_ptr, type(mom_restart_cs), pointer  CS  )

private

Definition at line 381 of file MOM_restart.F90.

  real,                 target  :: f_ptr
  type(mom_restart_cs), pointer :: cs
  logical :: query_initialized
!   This subroutine tests whether the field pointed to by f_ptr has
! been initialized from a restart file.
!
! Arguments: f_ptr - A pointer to the field that is being queried.
!  (in)      CS - The control structure returned by a previous call to
!                 restart_init.
  integer :: m,n
  if (.not.associated(cs)) call mom_error(fatal, "MOM_restart " // &
      "query_initialized: Module must be initialized before it is used.")
  if (cs%novars > cs%max_fields) call restart_error(cs)

  query_initialized = .false.
  n = cs%novars+1
  do m=1,cs%novars
    if (ASSOCIATED(cs%var_ptr0d(m)%p,f_ptr)) then
      if (cs%restart_field(m)%initialized) query_initialized = .true.
      n = m ; exit
    endif
  enddo
! Assume that you are going to initialize it now, so set flag to initialized if
! queried again.
  if (n<=cs%novars) cs%restart_field(n)%initialized = .true.

query_initialized_0d_name()

logical function mom_restart::query_initialized::query_initialized_0d_name ( real, target  f_ptr, character(len=*)  name, type(mom_restart_cs), pointer  CS  )

private

Definition at line 526 of file MOM_restart.F90.

  real,                 target  :: f_ptr
  character(len=*)              :: name
  type(mom_restart_cs), pointer :: cs
  logical :: query_initialized
!   This subroutine tests whether the field pointed to by f_ptr or with the
! specified variable name has been initialized from a restart file.
!
! Arguments: f_ptr - A pointer to the field that is being queried.
!  (in)      name - The name of the field that is being queried.
!  (in)      CS - The control structure returned by a previous call to
!                 restart_init.
  integer :: m,n
  if (.not.associated(cs)) call mom_error(fatal, "MOM_restart " // &
      "query_initialized: Module must be initialized before it is used.")
  if (cs%novars > cs%max_fields) call restart_error(cs)

  query_initialized = .false.
  n = cs%novars+1
  do m=1,cs%novars
    if (ASSOCIATED(cs%var_ptr0d(m)%p,f_ptr)) then
      if (cs%restart_field(m)%initialized) query_initialized = .true.
      n = m ; exit
    endif
  enddo
! Assume that you are going to initialize it now, so set flag to initialized if
! queried again.
  if (n<=cs%novars) cs%restart_field(n)%initialized = .true.
  if (n==cs%novars+1) then
    if (is_root_pe()) &
      call mom_error(note,"MOM_restart: Unable to find "//name//" queried by pointer, "//&
        "probably because of the suspect comparison of pointers by ASSOCIATED.")
    query_initialized = query_initialized_name(name, cs)
  endif

query_initialized_1d()

logical function mom_restart::query_initialized::query_initialized_1d ( real, dimension(:), target  f_ptr, type(mom_restart_cs), pointer  CS  )

private

Definition at line 410 of file MOM_restart.F90.

  real, dimension(:),   target  :: f_ptr
  type(mom_restart_cs), pointer :: cs
  logical :: query_initialized
!   This subroutine tests whether the field pointed to by f_ptr has
! been initialized from a restart file.
!
! Arguments: f_ptr - A pointer to the field that is being queried.
!  (in)      CS - The control structure returned by a previous call to
!                 restart_init.
  integer :: m,n
  if (.not.associated(cs)) call mom_error(fatal, "MOM_restart " // &
      "query_initialized: Module must be initialized before it is used.")
  if (cs%novars > cs%max_fields) call restart_error(cs)

  query_initialized = .false.
  n = cs%novars+1
  do m=1,cs%novars
    if (ASSOCIATED(cs%var_ptr1d(m)%p,f_ptr)) then
      if (cs%restart_field(m)%initialized) query_initialized = .true.
      n = m ; exit
    endif
  enddo
! Assume that you are going to initialize it now, so set flag to initialized if
! queried again.
  if (n<=cs%novars) cs%restart_field(n)%initialized = .true.

query_initialized_1d_name()

logical function mom_restart::query_initialized::query_initialized_1d_name ( real, dimension(:), target  f_ptr, character(len=*)  name, type(mom_restart_cs), pointer  CS  )

private

Definition at line 563 of file MOM_restart.F90.

  real, dimension(:),   target  :: f_ptr
  character(len=*)              :: name
  type(mom_restart_cs), pointer :: cs
  logical :: query_initialized
!   This subroutine tests whether the field pointed to by f_ptr or with the
! specified variable name has been initialized from a restart file.
!
! Arguments: f_ptr - A pointer to the field that is being queried.
!  (in)      name - The name of the field that is being queried.
!  (in)      CS - The control structure returned by a previous call to
!                 restart_init.
  integer :: m,n
  if (.not.associated(cs)) call mom_error(fatal, "MOM_restart " // &
      "query_initialized: Module must be initialized before it is used.")
  if (cs%novars > cs%max_fields) call restart_error(cs)

  query_initialized = .false.
  n = cs%novars+1
  do m=1,cs%novars
    if (ASSOCIATED(cs%var_ptr1d(m)%p,f_ptr)) then
      if (cs%restart_field(m)%initialized) query_initialized = .true.
      n = m ; exit
    endif
  enddo
! Assume that you are going to initialize it now, so set flag to initialized if
! queried again.
  if (n<=cs%novars) cs%restart_field(n)%initialized = .true.
  if (n==cs%novars+1) then
    if (is_root_pe()) &
      call mom_error(note,"MOM_restart: Unable to find "//name//" queried by pointer, "//&
        "probably because of the suspect comparison of pointers by ASSOCIATED.")
    query_initialized = query_initialized_name(name, cs)
  endif

query_initialized_2d()

logical function mom_restart::query_initialized::query_initialized_2d ( real, dimension(:,:), target  f_ptr, type(mom_restart_cs), pointer  CS  )

private

Definition at line 439 of file MOM_restart.F90.

  real, dimension(:,:), target  :: f_ptr
  type(mom_restart_cs), pointer :: cs
  logical :: query_initialized
!   This subroutine tests whether the field pointed to by f_ptr has
! been initialized from a restart file.
!
! Arguments: f_ptr - A pointer to the field that is being queried.
!  (in)      CS - The control structure returned by a previous call to
!                 restart_init.
  integer :: m,n
  if (.not.associated(cs)) call mom_error(fatal, "MOM_restart " // &
      "query_initialized: Module must be initialized before it is used.")
  if (cs%novars > cs%max_fields) call restart_error(cs)

  query_initialized = .false.
  n = cs%novars+1
  do m=1,cs%novars
    if (ASSOCIATED(cs%var_ptr2d(m)%p,f_ptr)) then
      if (cs%restart_field(m)%initialized) query_initialized = .true.
      n = m ; exit
    endif
  enddo
! Assume that you are going to initialize it now, so set flag to initialized if
! queried again.
  if (n<=cs%novars) cs%restart_field(n)%initialized = .true.

query_initialized_2d_name()

logical function mom_restart::query_initialized::query_initialized_2d_name ( real, dimension(:,:), target  f_ptr, character(len=*)  name, type(mom_restart_cs), pointer  CS  )

private

Definition at line 600 of file MOM_restart.F90.

  real, dimension(:,:), target  :: f_ptr
  character(len=*)              :: name
  type(mom_restart_cs), pointer :: cs
  logical :: query_initialized
!   This subroutine tests whether the field pointed to by f_ptr or with the
! specified variable name has been initialized from a restart file.
!
! Arguments: f_ptr - A pointer to the field that is being queried.
!  (in)      name - The name of the field that is being queried.
!  (in)      CS - The control structure returned by a previous call to
!                 restart_init.
  integer :: m,n
  if (.not.associated(cs)) call mom_error(fatal, "MOM_restart " // &
      "query_initialized: Module must be initialized before it is used.")
  if (cs%novars > cs%max_fields) call restart_error(cs)

  query_initialized = .false.
  n = cs%novars+1
  do m=1,cs%novars
    if (ASSOCIATED(cs%var_ptr2d(m)%p,f_ptr)) then
      if (cs%restart_field(m)%initialized) query_initialized = .true.
      n = m ; exit
    endif
  enddo
! Assume that you are going to initialize it now, so set flag to initialized if
! queried again.
  if (n<=cs%novars) cs%restart_field(n)%initialized = .true.
  if (n==cs%novars+1) then
    if (is_root_pe()) &
      call mom_error(note,"MOM_restart: Unable to find "//name//" queried by pointer, "//&
        "probably because of the suspect comparison of pointers by ASSOCIATED.")
    query_initialized = query_initialized_name(name, cs)
  endif

query_initialized_3d()

logical function mom_restart::query_initialized::query_initialized_3d ( real, dimension(:,:,:), target  f_ptr, type(mom_restart_cs), pointer  CS  )

private

Definition at line 468 of file MOM_restart.F90.

  real, dimension(:,:,:), target  :: f_ptr
  type(mom_restart_cs),   pointer :: cs
  logical :: query_initialized
!   This subroutine tests whether the field pointed to by f_ptr has
! been initialized from a restart file.
!
! Arguments: f_ptr - A pointer to the field that is being queried.
!  (in)      CS - The control structure returned by a previous call to
!                 restart_init.
  integer :: m,n
  if (.not.associated(cs)) call mom_error(fatal, "MOM_restart " // &
      "query_initialized: Module must be initialized before it is used.")
  if (cs%novars > cs%max_fields) call restart_error(cs)

  query_initialized = .false.
  n = cs%novars+1
  do m=1,cs%novars
    if (ASSOCIATED(cs%var_ptr3d(m)%p,f_ptr)) then
      if (cs%restart_field(m)%initialized) query_initialized = .true.
      n = m ; exit
    endif
  enddo
! Assume that you are going to initialize it now, so set flag to initialized if
! queried again.
  if (n<=cs%novars) cs%restart_field(n)%initialized = .true.

query_initialized_3d_name()

logical function mom_restart::query_initialized::query_initialized_3d_name ( real, dimension(:,:,:), target  f_ptr, character(len=*)  name, type(mom_restart_cs), pointer  CS  )

private

Definition at line 637 of file MOM_restart.F90.

  real, dimension(:,:,:), target  :: f_ptr
  character(len=*)                :: name
  type(mom_restart_cs),   pointer :: cs
  logical :: query_initialized
!   This subroutine tests whether the field pointed to by f_ptr or with the
! specified variable name has been initialized from a restart file.
!
! Arguments: f_ptr - A pointer to the field that is being queried.
!  (in)      name - The name of the field that is being queried.
!  (in)      CS - The control structure returned by a previous call to
!                 restart_init.
  integer :: m, n
  if (.not.associated(cs)) call mom_error(fatal, "MOM_restart " // &
      "query_initialized: Module must be initialized before it is used.")
  if (cs%novars > cs%max_fields) call restart_error(cs)

  query_initialized = .false.
  n = cs%novars+1
  do m=1,cs%novars
    if (ASSOCIATED(cs%var_ptr3d(m)%p,f_ptr)) then
      if (cs%restart_field(m)%initialized) query_initialized = .true.
      n = m ; exit
    endif
  enddo
! Assume that you are going to initialize it now, so set flag to initialized if
! queried again.
  if (n<=cs%novars) cs%restart_field(n)%initialized = .true.
  if (n==cs%novars+1) then
    if (is_root_pe()) &
      call mom_error(note, "MOM_restart: Unable to find "//name//" queried by pointer, "//&
        "possibly because of the suspect comparison of pointers by ASSOCIATED.")
    query_initialized = query_initialized_name(name, cs)
  endif

query_initialized_4d()

logical function mom_restart::query_initialized::query_initialized_4d ( real, dimension(:,:,:,:), target  f_ptr, type(mom_restart_cs), pointer  CS  )

private

Definition at line 497 of file MOM_restart.F90.

  real, dimension(:,:,:,:), target  :: f_ptr
  type(mom_restart_cs),     pointer :: cs
  logical :: query_initialized
!   This subroutine tests whether the field pointed to by f_ptr has
! been initialized from a restart file.
!
! Arguments: f_ptr - A pointer to the field that is being queried.
!  (in)      CS - The control structure returned by a previous call to
!                 restart_init.
  integer :: m,n
  if (.not.associated(cs)) call mom_error(fatal, "MOM_restart " // &
      "query_initialized: Module must be initialized before it is used.")
  if (cs%novars > cs%max_fields) call restart_error(cs)

  query_initialized = .false.
  n = cs%novars+1
  do m=1,cs%novars
    if (ASSOCIATED(cs%var_ptr4d(m)%p,f_ptr)) then
      if (cs%restart_field(m)%initialized) query_initialized = .true.
      n = m ; exit
    endif
  enddo
! Assume that you are going to initialize it now, so set flag to initialized if
! queried again.
  if (n<=cs%novars) cs%restart_field(n)%initialized = .true.

query_initialized_4d_name()

logical function mom_restart::query_initialized::query_initialized_4d_name ( real, dimension(:,:,:,:), target  f_ptr, character(len=*)  name, type(mom_restart_cs), pointer  CS  )

private

Definition at line 674 of file MOM_restart.F90.

  real, dimension(:,:,:,:), target  :: f_ptr
  character(len=*)                  :: name
  type(mom_restart_cs),     pointer :: cs
  logical :: query_initialized
!   This subroutine tests whether the field pointed to by f_ptr or with the
! specified variable name has been initialized from a restart file.
!
! Arguments: f_ptr - A pointer to the field that is being queried.
!  (in)      name - The name of the field that is being queried.
!  (in)      CS - The control structure returned by a previous call to
!                 restart_init.
  integer :: m, n
  if (.not.associated(cs)) call mom_error(fatal, "MOM_restart " // &
      "query_initialized: Module must be initialized before it is used.")
  if (cs%novars > cs%max_fields) call restart_error(cs)

  query_initialized = .false.
  n = cs%novars+1
  do m=1,cs%novars
    if (ASSOCIATED(cs%var_ptr4d(m)%p,f_ptr)) then
      if (cs%restart_field(m)%initialized) query_initialized = .true.
      n = m ; exit
    endif
  enddo
! Assume that you are going to initialize it now, so set flag to initialized if
! queried again.
  if (n<=cs%novars) cs%restart_field(n)%initialized = .true.
  if (n==cs%novars+1) then
    if (is_root_pe()) &
      call mom_error(note, "MOM_restart: Unable to find "//name//" queried by pointer, "//&
        "possibly because of the suspect comparison of pointers by ASSOCIATED.")
    query_initialized = query_initialized_name(name, cs)
  endif

query_initialized_name()

logical function mom_restart::query_initialized::query_initialized_name ( character(len=*)  name, type(mom_restart_cs), pointer  CS  )

private

Definition at line 345 of file MOM_restart.F90.

  character(len=*) :: name
  type(mom_restart_cs), pointer :: cs
  logical :: query_initialized
!   This subroutine returns .true. if the field referred to by name has
! initialized from a restart file, and .false. otherwise.
!
! Arguments: name - A pointer to the field that is being queried.
!  (in)      CS - The control structure returned by a previous call to
!                 restart_init.
  integer :: m,n
  if (.not.associated(cs)) call mom_error(fatal, "MOM_restart " // &
      "query_initialized: Module must be initialized before it is used.")
  if (cs%novars > cs%max_fields) call restart_error(cs)

  query_initialized = .false.
  n = cs%novars+1
  do m=1,cs%novars
    if (trim(name) == cs%restart_field(m)%var_name) then
      if (cs%restart_field(m)%initialized) query_initialized = .true.
      n = m ; exit
    endif
  enddo
! Assume that you are going to initialize it now, so set flag to initialized if
! queried again.
  if (n<=cs%novars) cs%restart_field(n)%initialized = .true.
  if ((n==cs%novars+1) .and. (is_root_pe())) &
    call mom_error(note,"MOM_restart: Unknown restart variable "//name// &
                        " queried for initialization.")

  if ((is_root_pe()) .and. query_initialized) &
    call mom_error(note,"MOM_restart: "//name// &
                         " initialization confirmed by name.")

---

The documentation for this interface was generated from the following file:

• /home/adcroft/GitHub/workspace/Gaea-stats-MOM6-examples/MOM6-examples/src/MOM6/src/framework/MOM_restart.F90