! $Id$ ! ! Earth System Modeling Framework ! Copyright (c) 2002-2023, University Corporation for Atmospheric Research, ! Massachusetts Institute of Technology, Geophysical Fluid Dynamics ! Laboratory, University of Michigan, National Centers for Environmental ! Prediction, Los Alamos National Laboratory, Argonne National Laboratory, ! NASA Goddard Space Flight Center. ! Licensed under the University of Illinois-NCSA License. ! !============================================================================== #define ESMF_FILENAME "ESMF_DynamicMask.F90" !============================================================================== ! ! ESMF DistGrid Module module ESMF_DynamicMaskMod ! !============================================================================== ! ! This file contains the DynamicMask shallow class implementation. ! !------------------------------------------------------------------------------ ! INCLUDES #include "ESMF.h" !============================================================================== !BOPI ! !MODULE: ESMF_DynamicMaskMod ! !------------------------------------------------------------------------------ ! !USES: use ESMF_UtilTypesMod ! ESMF utility types use ESMF_InitMacrosMod ! ESMF initializer macros use ESMF_LogErrMod ! ESMF error handling use ESMF_RHandleMod use ESMF_F90InterfaceMod ! ESMF F90-C++ interface helper implicit none !------------------------------------------------------------------------------ ! !PRIVATE TYPES: private !------------------------------------------------------------------------------ ! ! ESMF_DynamicMask type ESMF_DynamicMask character(len=7) :: typeKey type(ESMF_DynamicMaskStateR8R8R8) :: dmsR8R8R8 #ifndef ESMF_NO_DYNMASKOVERLOAD type(ESMF_DynamicMaskStateR8R8R8V):: dmsR8R8R8V type(ESMF_DynamicMaskStateR4R8R4) :: dmsR4R8R4 type(ESMF_DynamicMaskStateR4R8R4V):: dmsR4R8R4V type(ESMF_DynamicMaskStateR4R4R4) :: dmsR4R4R4 type(ESMF_DynamicMaskStateR4R4R4V):: dmsR4R4R4V #endif ESMF_INIT_DECLARE end type !------------------------------------------------------------------------------ ! ! !PUBLIC MEMBER FUNCTIONS: ! - ESMF-public methods: public ESMF_DynamicMask, ESMF_DynamicMaskGet, ESMF_DynamicMaskGetInit public ESMF_DynamicMaskSetR8R8R8 #ifndef ESMF_NO_DYNMASKOVERLOAD public ESMF_DynamicMaskSetR8R8R8V public ESMF_DynamicMaskSetR4R8R4 public ESMF_DynamicMaskSetR4R8R4V public ESMF_DynamicMaskSetR4R4R4 public ESMF_DynamicMaskSetR4R4R4V #endif !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! contains !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! -------------------------- ESMF-public method ------------------------------- #undef ESMF_METHOD #define ESMF_METHOD "ESMF_DynamicMaskGet()" !BOPI ! !IROUTINE: ESMF_DynamicMaskGet - Get DynamicMask ! !INTERFACE: subroutine ESMF_DynamicMaskGet(dynamicMask, keywordEnforcer, rc) ! ! !ARGUMENTS: type(ESMF_DynamicMask), intent(in) :: dynamicMask type(ESMF_KeywordEnforcer), optional:: keywordEnforcer ! must use keywords below integer, intent(out), optional :: rc ! ! !DESCRIPTION: ! \label{api:DynamicMaskGet} ! Get information from a {\tt ESMF\_DynamicMask} object. ! ! The arguments are: ! \begin{description} ! \item[dynamicMask] ! DynamicMask object. ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !EOPI !------------------------------------------------------------------------------ integer :: localrc ! local return code integer :: localdimCount ! initialize return code; assume routine not implemented localrc = ESMF_RC_NOT_IMPL if (present(rc)) rc = ESMF_RC_NOT_IMPL ! ensure dynamicMask is valid ESMF_INIT_CHECK_SHALLOW_SHORT(ESMF_DynamicMaskGetInit, dynamicMask, rc) ! return successfully if (present(rc)) rc = ESMF_SUCCESS end subroutine ESMF_DynamicMaskGet !------------------------------------------------------------------------------ ! -------------------------- ESMF-public method ------------------------------- #undef ESMF_METHOD #define ESMF_METHOD "ESMF_DynamicMaskSetR8R8R8()" !BOP ! !IROUTINE: ESMF_DynamicMaskSetR8R8R8 - Set DynamicMask for R8R8R8 ! !INTERFACE: subroutine ESMF_DynamicMaskSetR8R8R8(dynamicMask, dynamicMaskRoutine, & keywordEnforcer, handleAllElements, dynamicSrcMaskValue, & dynamicDstMaskValue, rc) ! ! !ARGUMENTS: type(ESMF_DynamicMask), intent(out) :: dynamicMask procedure(ESMF_DynamicMaskRoutineR8R8R8) :: dynamicMaskRoutine type(ESMF_KeywordEnforcer), optional:: keywordEnforcer ! must use keywords below logical, intent(in), optional :: handleAllElements real(ESMF_KIND_R8), intent(in), optional :: dynamicSrcMaskValue real(ESMF_KIND_R8), intent(in), optional :: dynamicDstMaskValue integer, intent(out), optional :: rc ! ! !DESCRIPTION: ! \label{api:DynamicMaskSetR8R8R8} ! Set an {\tt ESMF\_DynamicMask} object suitable for ! destination element typekind {\tt ESMF\_TYPEKIND\_R8}, ! factor typekind {\tt ESMF\_TYPEKIND\_R8}, and ! source element typekind {\tt ESMF\_TYPEKIND\_R8}. ! ! All values in {\tt dynamicMask} will be reset by this call. ! ! See section \ref{RH:DynMask} for a general discussion of dynamic masking. ! ! The arguments are: ! \begin{description} ! \item[dynamicMask] ! DynamicMask object. ! \item [dynamicMaskRoutine] ! The routine responsible for handling dynamically masked source and ! destination elements. See section \ref{RH:DynMask} for the precise ! definition of the {\tt dynamicMaskRoutine} procedure interface. ! The routine is only called on PETs where {\em at least one} interpolation ! element is identified for special handling. ! \item [{[handleAllElements]}] ! If set to {\tt .true.}, all local elements, regardless of their dynamic ! masking status, are made available to {\tt dynamicMaskRoutine} for ! handling. This option can be used to implement fully customized ! interpolations based on the information provided by ESMF. ! The default is {\tt .false.}, meaning that only elements affected by ! dynamic masking will be handed to {\tt dynamicMaskRoutine}. ! \item [{[dynamicSrcMaskValue]}] ! The value for which a source element is considered dynamically ! masked. ! The default is to {\em not} consider any source elements as ! dynamically masked. ! \item [{[dynamicDstMaskValue]}] ! The value for which a destination element is considered dynamically ! masked. ! The default is to {\em not} consider any destination elements as ! dynamically masked. ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !EOP !------------------------------------------------------------------------------ integer :: localrc ! local return code integer :: dimCount ! initialize return code; assume routine not implemented localrc = ESMF_RC_NOT_IMPL if (present(rc)) rc = ESMF_RC_NOT_IMPL ! mark output as uninitialized ESMF_INIT_SET_DELETED(dynamicMask) ! set the internals dynamicMask%typeKey = "R8R8R8" dynamicMask%dmsR8R8R8%typeKey = dynamicMask%typeKey dynamicMask%dmsR8R8R8%routine => dynamicMaskRoutine dynamicMask%dmsR8R8R8%dynamicSrcMaskIsPresent = present(dynamicSrcMaskValue) if (present(dynamicSrcMaskValue)) & dynamicMask%dmsR8R8R8%dynamicSrcMaskValue = dynamicSrcMaskValue dynamicMask%dmsR8R8R8%dynamicDstMaskIsPresent = present(dynamicDstMaskValue) if (present(dynamicDstMaskValue)) & dynamicMask%dmsR8R8R8%dynamicDstMaskValue = dynamicDstMaskValue if (present(handleAllElements)) then dynamicMask%dmsR8R8R8%handleAllElements = handleAllElements else dynamicMask%dmsR8R8R8%handleAllElements = .false. ! default endif ! mark output as successfully initialized ESMF_INIT_SET_DEFINED(dynamicMask) ! return successfully if (present(rc)) rc = ESMF_SUCCESS end subroutine ESMF_DynamicMaskSetR8R8R8 !------------------------------------------------------------------------------ #ifndef ESMF_NO_DYNMASKOVERLOAD ! -------------------------- ESMF-public method ------------------------------- #undef ESMF_METHOD #define ESMF_METHOD "ESMF_DynamicMaskSetR8R8R8V()" !BOP ! !IROUTINE: ESMF_DynamicMaskSetR8R8R8V - Set DynamicMask for R8R8R8 with vectorization ! !INTERFACE: subroutine ESMF_DynamicMaskSetR8R8R8V(dynamicMask, dynamicMaskRoutine, & keywordEnforcer, handleAllElements, dynamicSrcMaskValue, & dynamicDstMaskValue, rc) ! ! !ARGUMENTS: type(ESMF_DynamicMask), intent(out) :: dynamicMask procedure(ESMF_DynamicMaskRoutineR8R8R8V) :: dynamicMaskRoutine type(ESMF_KeywordEnforcer), optional:: keywordEnforcer ! must use keywords below logical, intent(in), optional :: handleAllElements real(ESMF_KIND_R8), intent(in), optional :: dynamicSrcMaskValue real(ESMF_KIND_R8), intent(in), optional :: dynamicDstMaskValue integer, intent(out), optional :: rc ! ! !DESCRIPTION: ! \label{api:DynamicMaskSetR8R8R8V} ! Set an {\tt ESMF\_DynamicMask} object suitable for ! destination element typekind {\tt ESMF\_TYPEKIND\_R8}, ! factor typekind {\tt ESMF\_TYPEKIND\_R8}, and ! source element typekind {\tt ESMF\_TYPEKIND\_R8}. ! ! All values in {\tt dynamicMask} will be reset by this call. ! ! See section \ref{RH:DynMask} for a general discussion of dynamic masking. ! ! The arguments are: ! \begin{description} ! \item[dynamicMask] ! DynamicMask object. ! \item [dynamicMaskRoutine] ! The routine responsible for handling dynamically masked source and ! destination elements. See section \ref{RH:DynMask} for the precise ! definition of the {\tt dynamicMaskRoutine} procedure interface. ! The routine is only called on PETs where {\em at least one} interpolation ! element is identified for special handling. ! \item [{[handleAllElements]}] ! If set to {\tt .true.}, all local elements, regardless of their dynamic ! masking status, are made available to {\tt dynamicMaskRoutine} for ! handling. This option can be used to implement fully customized ! interpolations based on the information provided by ESMF. ! The default is {\tt .false.}, meaning that only elements affected by ! dynamic masking will be handed to {\tt dynamicMaskRoutine}. ! \item [{[dynamicSrcMaskValue]}] ! The value for which a source element is considered dynamically ! masked. ! The default is to {\em not} consider any source elements as ! dynamically masked. ! \item [{[dynamicDstMaskValue]}] ! The value for which a destination element is considered dynamically ! masked. ! The default is to {\em not} consider any destination elements as ! dynamically masked. ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !EOP !------------------------------------------------------------------------------ integer :: localrc ! local return code integer :: dimCount ! initialize return code; assume routine not implemented localrc = ESMF_RC_NOT_IMPL if (present(rc)) rc = ESMF_RC_NOT_IMPL ! mark output as uninitialized ESMF_INIT_SET_DELETED(dynamicMask) ! set the internals dynamicMask%typeKey = "R8R8R8V" dynamicMask%dmsR8R8R8V%typeKey = dynamicMask%typeKey dynamicMask%dmsR8R8R8V%routine => dynamicMaskRoutine dynamicMask%dmsR8R8R8V%dynamicSrcMaskIsPresent = present(dynamicSrcMaskValue) if (present(dynamicSrcMaskValue)) & dynamicMask%dmsR8R8R8V%dynamicSrcMaskValue = dynamicSrcMaskValue dynamicMask%dmsR8R8R8V%dynamicDstMaskIsPresent = present(dynamicDstMaskValue) if (present(dynamicDstMaskValue)) & dynamicMask%dmsR8R8R8V%dynamicDstMaskValue = dynamicDstMaskValue if (present(handleAllElements)) then dynamicMask%dmsR8R8R8V%handleAllElements = handleAllElements else dynamicMask%dmsR8R8R8V%handleAllElements = .false. ! default endif ! mark output as successfully initialized ESMF_INIT_SET_DEFINED(dynamicMask) ! return successfully if (present(rc)) rc = ESMF_SUCCESS end subroutine ESMF_DynamicMaskSetR8R8R8V !------------------------------------------------------------------------------ ! -------------------------- ESMF-public method ------------------------------- #undef ESMF_METHOD #define ESMF_METHOD "ESMF_DynamicMaskSetR4R8R4()" !BOP ! !IROUTINE: ESMF_DynamicMaskSetR4R8R4 - Set DynamicMask for R4R8R4 ! !INTERFACE: subroutine ESMF_DynamicMaskSetR4R8R4(dynamicMask, dynamicMaskRoutine, & keywordEnforcer, handleAllElements, dynamicSrcMaskValue, & dynamicDstMaskValue, rc) ! ! !ARGUMENTS: type(ESMF_DynamicMask), intent(out) :: dynamicMask procedure(ESMF_DynamicMaskRoutineR4R8R4) :: dynamicMaskRoutine type(ESMF_KeywordEnforcer), optional:: keywordEnforcer ! must use keywords below logical, intent(in), optional :: handleAllElements real(ESMF_KIND_R4), intent(in), optional :: dynamicSrcMaskValue real(ESMF_KIND_R4), intent(in), optional :: dynamicDstMaskValue integer, intent(out), optional :: rc ! ! !DESCRIPTION: ! \label{api:DynamicMaskSetR4R8R4} ! Set an {\tt ESMF\_DynamicMask} object suitable for ! destination element typekind {\tt ESMF\_TYPEKIND\_R4}, ! factor typekind {\tt ESMF\_TYPEKIND\_R8}, and ! source element typekind {\tt ESMF\_TYPEKIND\_R4}. ! ! All values in {\tt dynamicMask} will be reset by this call. ! ! See section \ref{RH:DynMask} for a general discussion of dynamic masking. ! ! The arguments are: ! \begin{description} ! \item[dynamicMask] ! DynamicMask object. ! \item [dynamicMaskRoutine] ! The routine responsible for handling dynamically masked source and ! destination elements. See section \ref{RH:DynMask} for the precise ! definition of the {\tt dynamicMaskRoutine} procedure interface. ! The routine is only called on PETs where {\em at least one} interpolation ! element is identified for special handling. ! \item [{[handleAllElements]}] ! If set to {\tt .true.}, all local elements, regardless of their dynamic ! masking status, are made available to {\tt dynamicMaskRoutine} for ! handling. This option can be used to implement fully customized ! interpolations based on the information provided by ESMF. ! The default is {\tt .false.}, meaning that only elements affected by ! dynamic masking will be handed to {\tt dynamicMaskRoutine}. ! \item [{[dynamicSrcMaskValue]}] ! The value for which a source element is considered dynamically ! masked. ! The default is to {\em not} consider any source elements as ! dynamically masked. ! \item [{[dynamicDstMaskValue]}] ! The value for which a destination element is considered dynamically ! masked. ! The default is to {\em not} consider any destination elements as ! dynamically masked. ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !EOP !------------------------------------------------------------------------------ integer :: localrc ! local return code integer :: dimCount ! initialize return code; assume routine not implemented localrc = ESMF_RC_NOT_IMPL if (present(rc)) rc = ESMF_RC_NOT_IMPL ! mark output as uninitialized ESMF_INIT_SET_DELETED(dynamicMask) ! set the internals dynamicMask%typeKey = "R4R8R4" dynamicMask%dmsR4R8R4%typeKey = dynamicMask%typeKey dynamicMask%dmsR4R8R4%routine => dynamicMaskRoutine dynamicMask%dmsR4R8R4%dynamicSrcMaskIsPresent = present(dynamicSrcMaskValue) if (present(dynamicSrcMaskValue)) & dynamicMask%dmsR4R8R4%dynamicSrcMaskValue = dynamicSrcMaskValue dynamicMask%dmsR4R8R4%dynamicDstMaskIsPresent = present(dynamicDstMaskValue) if (present(dynamicDstMaskValue)) & dynamicMask%dmsR4R8R4%dynamicDstMaskValue = dynamicDstMaskValue if (present(handleAllElements)) then dynamicMask%dmsR4R8R4%handleAllElements = handleAllElements else dynamicMask%dmsR4R8R4%handleAllElements = .false. ! default endif ! mark output as successfully initialized ESMF_INIT_SET_DEFINED(dynamicMask) ! return successfully if (present(rc)) rc = ESMF_SUCCESS end subroutine ESMF_DynamicMaskSetR4R8R4 !------------------------------------------------------------------------------ ! -------------------------- ESMF-public method ------------------------------- #undef ESMF_METHOD #define ESMF_METHOD "ESMF_DynamicMaskSetR4R8R4V()" !BOP ! !IROUTINE: ESMF_DynamicMaskSetR4R8R4V - Set DynamicMask for R4R8R4 with vectorization ! !INTERFACE: subroutine ESMF_DynamicMaskSetR4R8R4V(dynamicMask, dynamicMaskRoutine, & keywordEnforcer, handleAllElements, dynamicSrcMaskValue, & dynamicDstMaskValue, rc) ! ! !ARGUMENTS: type(ESMF_DynamicMask), intent(out) :: dynamicMask procedure(ESMF_DynamicMaskRoutineR4R8R4V) :: dynamicMaskRoutine type(ESMF_KeywordEnforcer), optional:: keywordEnforcer ! must use keywords below logical, intent(in), optional :: handleAllElements real(ESMF_KIND_R4), intent(in), optional :: dynamicSrcMaskValue real(ESMF_KIND_R4), intent(in), optional :: dynamicDstMaskValue integer, intent(out), optional :: rc ! ! !DESCRIPTION: ! \label{api:DynamicMaskSetR4R8R4V} ! Set an {\tt ESMF\_DynamicMask} object suitable for ! destination element typekind {\tt ESMF\_TYPEKIND\_R4}, ! factor typekind {\tt ESMF\_TYPEKIND\_R8}, and ! source element typekind {\tt ESMF\_TYPEKIND\_R4}. ! ! All values in {\tt dynamicMask} will be reset by this call. ! ! See section \ref{RH:DynMask} for a general discussion of dynamic masking. ! ! The arguments are: ! \begin{description} ! \item[dynamicMask] ! DynamicMask object. ! \item [dynamicMaskRoutine] ! The routine responsible for handling dynamically masked source and ! destination elements. See section \ref{RH:DynMask} for the precise ! definition of the {\tt dynamicMaskRoutine} procedure interface. ! The routine is only called on PETs where {\em at least one} interpolation ! element is identified for special handling. ! \item [{[handleAllElements]}] ! If set to {\tt .true.}, all local elements, regardless of their dynamic ! masking status, are made available to {\tt dynamicMaskRoutine} for ! handling. This option can be used to implement fully customized ! interpolations based on the information provided by ESMF. ! The default is {\tt .false.}, meaning that only elements affected by ! dynamic masking will be handed to {\tt dynamicMaskRoutine}. ! \item [{[dynamicSrcMaskValue]}] ! The value for which a source element is considered dynamically ! masked. ! The default is to {\em not} consider any source elements as ! dynamically masked. ! \item [{[dynamicDstMaskValue]}] ! The value for which a destination element is considered dynamically ! masked. ! The default is to {\em not} consider any destination elements as ! dynamically masked. ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !EOP !------------------------------------------------------------------------------ integer :: localrc ! local return code integer :: dimCount ! initialize return code; assume routine not implemented localrc = ESMF_RC_NOT_IMPL if (present(rc)) rc = ESMF_RC_NOT_IMPL ! mark output as uninitialized ESMF_INIT_SET_DELETED(dynamicMask) ! set the internals dynamicMask%typeKey = "R4R8R4V" dynamicMask%dmsR4R8R4V%typeKey = dynamicMask%typeKey dynamicMask%dmsR4R8R4V%routine => dynamicMaskRoutine dynamicMask%dmsR4R8R4V%dynamicSrcMaskIsPresent = present(dynamicSrcMaskValue) if (present(dynamicSrcMaskValue)) & dynamicMask%dmsR4R8R4V%dynamicSrcMaskValue = dynamicSrcMaskValue dynamicMask%dmsR4R8R4V%dynamicDstMaskIsPresent = present(dynamicDstMaskValue) if (present(dynamicDstMaskValue)) & dynamicMask%dmsR4R8R4V%dynamicDstMaskValue = dynamicDstMaskValue if (present(handleAllElements)) then dynamicMask%dmsR4R8R4V%handleAllElements = handleAllElements else dynamicMask%dmsR4R8R4V%handleAllElements = .false. ! default endif ! mark output as successfully initialized ESMF_INIT_SET_DEFINED(dynamicMask) ! return successfully if (present(rc)) rc = ESMF_SUCCESS end subroutine ESMF_DynamicMaskSetR4R8R4V !------------------------------------------------------------------------------ ! -------------------------- ESMF-public method ------------------------------- #undef ESMF_METHOD #define ESMF_METHOD "ESMF_DynamicMaskSetR4R4R4()" !BOP ! !IROUTINE: ESMF_DynamicMaskSetR4R4R4 - Set DynamicMask for R4R4R4 ! !INTERFACE: subroutine ESMF_DynamicMaskSetR4R4R4(dynamicMask, dynamicMaskRoutine, & keywordEnforcer, handleAllElements, dynamicSrcMaskValue, & dynamicDstMaskValue, rc) ! ! !ARGUMENTS: type(ESMF_DynamicMask), intent(out) :: dynamicMask procedure(ESMF_DynamicMaskRoutineR4R4R4) :: dynamicMaskRoutine type(ESMF_KeywordEnforcer), optional:: keywordEnforcer ! must use keywords below logical, intent(in), optional :: handleAllElements real(ESMF_KIND_R4), intent(in), optional :: dynamicSrcMaskValue real(ESMF_KIND_R4), intent(in), optional :: dynamicDstMaskValue integer, intent(out), optional :: rc ! ! !DESCRIPTION: ! \label{api:DynamicMaskSetR4R4R4} ! Set an {\tt ESMF\_DynamicMask} object suitable for ! destination element typekind {\tt ESMF\_TYPEKIND\_R4}, ! factor typekind {\tt ESMF\_TYPEKIND\_R4}, and ! source element typekind {\tt ESMF\_TYPEKIND\_R4}. ! ! All values in {\tt dynamicMask} will be reset by this call. ! ! See section \ref{RH:DynMask} for a general discussion of dynamic masking. ! ! The arguments are: ! \begin{description} ! \item[dynamicMask] ! DynamicMask object. ! \item [dynamicMaskRoutine] ! The routine responsible for handling dynamically masked source and ! destination elements. See section \ref{RH:DynMask} for the precise ! definition of the {\tt dynamicMaskRoutine} procedure interface. ! The routine is only called on PETs where {\em at least one} interpolation ! element is identified for special handling. ! \item [{[handleAllElements]}] ! If set to {\tt .true.}, all local elements, regardless of their dynamic ! masking status, are made available to {\tt dynamicMaskRoutine} for ! handling. This option can be used to implement fully customized ! interpolations based on the information provided by ESMF. ! The default is {\tt .false.}, meaning that only elements affected by ! dynamic masking will be handed to {\tt dynamicMaskRoutine}. ! \item [{[dynamicSrcMaskValue]}] ! The value for which a source element is considered dynamically ! masked. ! The default is to {\em not} consider any source elements as ! dynamically masked. ! \item [{[dynamicDstMaskValue]}] ! The value for which a destination element is considered dynamically ! masked. ! The default is to {\em not} consider any destination elements as ! dynamically masked. ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !EOP !------------------------------------------------------------------------------ integer :: localrc ! local return code integer :: dimCount ! initialize return code; assume routine not implemented localrc = ESMF_RC_NOT_IMPL if (present(rc)) rc = ESMF_RC_NOT_IMPL ! mark output as uninitialized ESMF_INIT_SET_DELETED(dynamicMask) ! set the internals dynamicMask%typeKey = "R4R4R4" dynamicMask%dmsR4R4R4%typeKey = dynamicMask%typeKey dynamicMask%dmsR4R4R4%routine => dynamicMaskRoutine dynamicMask%dmsR4R4R4%dynamicSrcMaskIsPresent = present(dynamicSrcMaskValue) if (present(dynamicSrcMaskValue)) & dynamicMask%dmsR4R4R4%dynamicSrcMaskValue = dynamicSrcMaskValue dynamicMask%dmsR4R4R4%dynamicDstMaskIsPresent = present(dynamicDstMaskValue) if (present(dynamicDstMaskValue)) & dynamicMask%dmsR4R4R4%dynamicDstMaskValue = dynamicDstMaskValue if (present(handleAllElements)) then dynamicMask%dmsR4R4R4%handleAllElements = handleAllElements else dynamicMask%dmsR4R4R4%handleAllElements = .false. ! default endif ! mark output as successfully initialized ESMF_INIT_SET_DEFINED(dynamicMask) ! return successfully if (present(rc)) rc = ESMF_SUCCESS end subroutine ESMF_DynamicMaskSetR4R4R4 !------------------------------------------------------------------------------ ! -------------------------- ESMF-public method ------------------------------- #undef ESMF_METHOD #define ESMF_METHOD "ESMF_DynamicMaskSetR4R4R4V()" !BOP ! !IROUTINE: ESMF_DynamicMaskSetR4R4R4V - Set DynamicMask for R4R4R4 with vectorization ! !INTERFACE: subroutine ESMF_DynamicMaskSetR4R4R4V(dynamicMask, dynamicMaskRoutine, & keywordEnforcer, handleAllElements, dynamicSrcMaskValue, & dynamicDstMaskValue, rc) ! ! !ARGUMENTS: type(ESMF_DynamicMask), intent(out) :: dynamicMask procedure(ESMF_DynamicMaskRoutineR4R4R4V) :: dynamicMaskRoutine type(ESMF_KeywordEnforcer), optional:: keywordEnforcer ! must use keywords below logical, intent(in), optional :: handleAllElements real(ESMF_KIND_R4), intent(in), optional :: dynamicSrcMaskValue real(ESMF_KIND_R4), intent(in), optional :: dynamicDstMaskValue integer, intent(out), optional :: rc ! ! !DESCRIPTION: ! \label{api:DynamicMaskSetR4R4R4V} ! Set an {\tt ESMF\_DynamicMask} object suitable for ! destination element typekind {\tt ESMF\_TYPEKIND\_R4}, ! factor typekind {\tt ESMF\_TYPEKIND\_R4}, and ! source element typekind {\tt ESMF\_TYPEKIND\_R4}. ! ! All values in {\tt dynamicMask} will be reset by this call. ! ! See section \ref{RH:DynMask} for a general discussion of dynamic masking. ! ! The arguments are: ! \begin{description} ! \item[dynamicMask] ! DynamicMask object. ! \item [dynamicMaskRoutine] ! The routine responsible for handling dynamically masked source and ! destination elements. See section \ref{RH:DynMask} for the precise ! definition of the {\tt dynamicMaskRoutine} procedure interface. ! The routine is only called on PETs where {\em at least one} interpolation ! element is identified for special handling. ! \item [{[handleAllElements]}] ! If set to {\tt .true.}, all local elements, regardless of their dynamic ! masking status, are made available to {\tt dynamicMaskRoutine} for ! handling. This option can be used to implement fully customized ! interpolations based on the information provided by ESMF. ! The default is {\tt .false.}, meaning that only elements affected by ! dynamic masking will be handed to {\tt dynamicMaskRoutine}. ! \item [{[dynamicSrcMaskValue]}] ! The value for which a source element is considered dynamically ! masked. ! The default is to {\em not} consider any source elements as ! dynamically masked. ! \item [{[dynamicDstMaskValue]}] ! The value for which a destination element is considered dynamically ! masked. ! The default is to {\em not} consider any destination elements as ! dynamically masked. ! \item[{[rc]}] ! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors. ! \end{description} ! !EOP !------------------------------------------------------------------------------ integer :: localrc ! local return code integer :: dimCount ! initialize return code; assume routine not implemented localrc = ESMF_RC_NOT_IMPL if (present(rc)) rc = ESMF_RC_NOT_IMPL ! mark output as uninitialized ESMF_INIT_SET_DELETED(dynamicMask) ! set the internals dynamicMask%typeKey = "R4R4R4V" dynamicMask%dmsR4R4R4V%typeKey = dynamicMask%typeKey dynamicMask%dmsR4R4R4V%routine => dynamicMaskRoutine dynamicMask%dmsR4R4R4V%dynamicSrcMaskIsPresent = present(dynamicSrcMaskValue) if (present(dynamicSrcMaskValue)) & dynamicMask%dmsR4R4R4V%dynamicSrcMaskValue = dynamicSrcMaskValue dynamicMask%dmsR4R4R4V%dynamicDstMaskIsPresent = present(dynamicDstMaskValue) if (present(dynamicDstMaskValue)) & dynamicMask%dmsR4R4R4V%dynamicDstMaskValue = dynamicDstMaskValue if (present(handleAllElements)) then dynamicMask%dmsR4R4R4V%handleAllElements = handleAllElements else dynamicMask%dmsR4R4R4V%handleAllElements = .false. ! default endif ! mark output as successfully initialized ESMF_INIT_SET_DEFINED(dynamicMask) ! return successfully if (present(rc)) rc = ESMF_SUCCESS end subroutine ESMF_DynamicMaskSetR4R4R4V !------------------------------------------------------------------------------ #endif ! -------------------------- ESMF-internal method ----------------------------- #undef ESMF_METHOD #define ESMF_METHOD "ESMF_DynamicMaskGetInit" !BOPI ! !IROUTINE: ESMF_DynamicMaskGetInit - Internal access routine for init code ! ! !INTERFACE: function ESMF_DynamicMaskGetInit(dynamicMask) ! ! !RETURN VALUE: ESMF_INIT_TYPE :: ESMF_DynamicMaskGetInit ! ! !ARGUMENTS: type(ESMF_DynamicMask), intent(in), optional :: dynamicMask ! ! !DESCRIPTION: ! Access init code. ! ! The arguments are: ! \begin{description} ! \item [dynamicMask] ! DynamicMask object. ! \end{description} ! !EOPI !------------------------------------------------------------------------------ if (present(dynamicMask)) then ESMF_DynamicMaskGetInit = ESMF_INIT_GET(dynamicMask) else ESMF_DynamicMaskGetInit = ESMF_INIT_DEFINED endif end function ESMF_DynamicMaskGetInit !------------------------------------------------------------------------------ end module ESMF_DynamicMaskMod