subroutine ESMF_ArrayBundleRedistStoreNF(srcArrayBundle, dstArrayBundle, &
routehandle, keywordEnforcer, ignoreUnmatchedIndicesFlag, &
srcToDstTransposeMap, rc)
!
! !ARGUMENTS:
type(ESMF_ArrayBundle), intent(in) :: srcArrayBundle
type(ESMF_ArrayBundle), intent(inout) :: dstArrayBundle
type(ESMF_RouteHandle), intent(inout) :: routehandle
type(ESMF_KeywordEnforcer), optional:: keywordEnforcer ! must use keywords below
logical, intent(in), optional :: ignoreUnmatchedIndicesFlag(:)
integer, intent(in), optional :: srcToDstTransposeMap(:)
integer, intent(out), optional :: rc
!
! !STATUS:
! \begin{itemize}
! \item\apiStatusCompatibleVersion{5.2.0r}
! \item\apiStatusModifiedSinceVersion{5.2.0r}
! \begin{description}
! \item[8.1.0] Added argument {\tt ignoreUnmatchedIndicesFlag} to support cases
! where source and destination side do not cover the exact same index space.
! \end{description}
! \end{itemize}
!
! !DESCRIPTION:
! Store an ArrayBundle redistribution operation from
! {\tt srcArrayBundle} to {\tt dstArrayBundle}. The redistribution
! between ArrayBundles is defined as the sequence of
! individual Array redistributions over all source and
! destination Array pairs in sequence. The method requires that
! {\tt srcArrayBundle} and {\tt dstArrayBundle} reference an identical
! number of {\tt ESMF\_Array} objects.
!
! The effect of this method on ArrayBundles that contain aliased members is
! undefined.
!
! PETs that specify a {\tt factor} argument must use the
! <type><kind> overloaded interface. Other PETs call into the interface
! without {\tt factor} argument. If multiple PETs specify the {\tt factor}
! argument its type and kind as well as its value must match across all
! PETs. If none of the PETs specifies a {\tt factor} argument the default
! will be a factor of 1.
!
! See the description of method {\tt ESMF\_ArrayRedistStore()} for
! the definition of the Array based operation.
!
! The routine returns an {\tt ESMF\_RouteHandle} that can be used to call
! {\tt ESMF\_ArrayBundleRedist()} on any pair of ArrayBundles that matches
! {\tt srcArrayBundle} and {\tt dstArrayBundle} in {\em type}, {\em kind},
! and memory layout of the {\em distributed} dimensions. However, the size,
! number, and index order of {\em undistributed} dimensions may be different.
! See section \ref{RH:Reusability} for a more detailed discussion of
! RouteHandle reusability.
!
! This call is {\em collective} across the current VM.
!
! \begin{description}
! \item [srcArrayBundle]
! {\tt ESMF\_ArrayBundle} with source data.
! \item [dstArrayBundle]
! {\tt ESMF\_ArrayBundle} with destination data. The data in these Arrays
! may be destroyed by this call.
! \item [routehandle]
! Handle to the precomputed Route.
! \item [{[ignoreUnmatchedIndicesFlag]}]
! If set to {.false.}, the {\em default}, source and destination side must
! cover the identical index space, using precisely matching sequence
! indices. If set to {.true.}, mismatching sequence indices between source
! and destination side are silently ignored.
! The size of this array argument must either be 1 or equal the number of
! Arrays in the {\tt srcArrayBundle} and {\tt dstArrayBundle} arguments. In
! the latter case, the handling of unmatched indices is specified for each
! Array pair separately. If only one element is specified, it is
! used for {\em all} Array pairs.
! \item [{[srcToDstTransposeMap]}]
! List with as many entries as there are dimensions in the Arrays in
! {\tt srcArrayBundle}. Each
! entry maps the corresponding source Array dimension against the
! specified destination Array dimension. Mixing of distributed and
! undistributed dimensions is supported.
! \item [{[rc]}]
! Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
! \end{description}
!
!EOP
!------------------------------------------------------------------------------
integer :: localrc ! local return code
type(ESMF_Logical), pointer :: opt_ignoreUnmatched(:)
type(ESMF_Logical), target :: def_ignoreUnmatched(1)
integer :: len_ignoreUnmatched
type(ESMF_InterArray) :: srcToDstTransposeMapArg
! initialize return code; assume routine not implemented
localrc = ESMF_RC_NOT_IMPL
if (present(rc)) rc = ESMF_RC_NOT_IMPL
! Check init status of arguments
ESMF_INIT_CHECK_DEEP_SHORT(ESMF_ArrayBundleGetInit, srcArrayBundle, rc)
ESMF_INIT_CHECK_DEEP_SHORT(ESMF_ArrayBundleGetInit, dstArrayBundle, rc)
! Deal with ignoreUnmatchedIndicesFlag
def_ignoreUnmatched(1) = .false.
if (present(ignoreUnmatchedIndicesFlag)) then
if (size(ignoreUnmatchedIndicesFlag)==0) then
call ESMF_LogSetError(rcToCheck=ESMF_RC_ARG_SIZE, &
msg="Size of 'ignoreUnmatchedIndicesFlag' argument must not be zero.",&
ESMF_CONTEXT, rcToReturn=rc)
return ! bail out
endif
allocate(opt_ignoreUnmatched(size(ignoreUnmatchedIndicesFlag)))
opt_ignoreUnmatched(:) = ignoreUnmatchedIndicesFlag(:)
else
opt_ignoreUnmatched => def_ignoreUnmatched
endif
len_ignoreUnmatched = size(opt_ignoreUnmatched)
! Deal with srcToDstTransposeMap
srcToDstTransposeMapArg = ESMF_InterArrayCreate(srcToDstTransposeMap, &
rc=localrc)
if (ESMF_LogFoundError(localrc, ESMF_ERR_PASSTHRU, &
ESMF_CONTEXT, rcToReturn=rc)) return
! Call into the C++ interface, which will sort out optional arguments
call c_ESMC_ArrayBundleRedistStoreNF(srcArrayBundle, dstArrayBundle, &
routehandle, opt_ignoreUnmatched(1), len_ignoreUnmatched, &
srcToDstTransposeMapArg, localrc)
if (ESMF_LogFoundError(localrc, ESMF_ERR_PASSTHRU, &
ESMF_CONTEXT, rcToReturn=rc)) return
! Mark routehandle object as being created
call ESMF_RouteHandleSetInitCreated(routehandle, localrc)
if (ESMF_LogFoundError(localrc, ESMF_ERR_PASSTHRU, &
ESMF_CONTEXT, rcToReturn=rc)) return
! garbage collection
call ESMF_InterArrayDestroy(srcToDstTransposeMapArg, rc=localrc)
if (ESMF_LogFoundError(localrc, ESMF_ERR_PASSTHRU, &
ESMF_CONTEXT, rcToReturn=rc)) return
if (present(ignoreUnmatchedIndicesFlag)) then
deallocate(opt_ignoreUnmatched)
endif
! return successfully
if (present(rc)) rc = ESMF_SUCCESS
end subroutine ESMF_ArrayBundleRedistStoreNF