!------------------------------------------------------------------------------ ! Global Modeling and Assimilation Office (GMAO) ! ! Goddard Earth Observing System (GEOS) ! ! MAPL Component ! !------------------------------------------------------------------------------ ! #include "MAPL_ErrLog.h" #include "unused_dummy.H" ! !> !### MODULE: `MAPL_Base` ! ! Author: GMAO SI-Team ! ! The module `MAPL_Base` provides a collection assorted ! utilities and constants used throughout the MAPL Library. ! module MAPL_Base ! !USES: ! use ESMF, only: ESMF_MAXSTR use, intrinsic :: iso_fortran_env, only: REAL64 implicit NONE private ! !PUBLIC MEMBER FUNCTIONS: ! public MAPL_AllocateCoupling ! Atanas: please provide 1-line for each public MAPL_FieldAllocCommit !public MAPL_FieldF90Deallocate public MAPL_ClimInterpFac !public MAPL_ConnectCoupling public MAPL_DecomposeDim public MAPL_MakeDecomposition public MAPL_FieldCreate public MAPL_FieldCreateEmpty public MAPL_FieldGetTime public MAPL_FieldSetTime public MAPL_GRID_INTERIOR public MAPL_IncYMD public MAPL_Interp_Fac public MAPL_LatLonGridCreate ! Creates regular Lat/Lon ESMF Grids public MAPL_Nhmsf public MAPL_NSECF public MAPL_Nsecf2 public MAPL_PackTime public MAPL_PackDateTime public MAPL_RemapBounds public MAPL_Tick public MAPL_TimeStringGet public MAPL_UnpackTime public MAPL_UnpackDateTime public MAPL_RmQualifier public MAPL_AttributeSet public MAPL_SetPointer public MAPL_FieldCopyAttributes public MAPL_StateAdd public MAPL_FieldBundleAdd public MAPL_FieldBundleGet public MAPL_FieldBundleDestroy public MAPL_GetHorzIJIndex public MAPL_GetGlobalHorzIJIndex public MAPL_Reverse_Schmidt public MAPL_GenGridName public MAPL_GenXYOffset public MAPL_GeosNameNew public MAPL_Communicator public MAPL_BundleCreate public MAPL_FieldCopy public MAPL_Leap public MAPL_GridGetCorners public MAPL_GridGetInterior public MAPL_TrimString public MAPL_FieldSplit public MAPL_GetCorrectedPhase real, public, parameter :: MAPL_UNDEF = 1.0e15 character(len=ESMF_MAXSTR), public, parameter :: MAPL_StateItemOrderList = 'MAPL_StateItemOrderList' character(len=ESMF_MAXSTR), public, parameter :: MAPL_BundleItemOrderList = 'MAPL_BundleItemOrderList' type :: MAPL_Communicator integer :: comm integer :: rank integer :: root integer :: size !logical :: am_i_root end type MAPL_Communicator !---------------------------------------------------------------------- interface MAPL_FieldCreate module procedure MAPL_FieldCreateRename module procedure MAPL_FieldCreateNewgrid module procedure MAPL_FieldCreateR4 end interface MAPL_FieldCreate interface MAPL_FieldGetTime module procedure MAPL_GetFieldTimeFromField module procedure MAPL_GetFieldTimeFromState end interface MAPL_FieldGetTime interface MAPL_FieldSetTime module procedure MAPL_SetFieldTimeFromField module procedure MAPL_SetFieldTimeFromState end interface MAPL_FieldSetTime interface MAPL_RemapBounds module procedure MAPL_RemapBoundsFull_3dr4 module procedure MAPL_RemapBounds_3dr4 module procedure MAPL_RemapBounds_3dr8 end interface MAPL_RemapBounds interface MAPL_AttributeSet module procedure MAPL_StateAttSetI4 module procedure MAPL_BundleAttSetI4 module procedure MAPL_FieldAttSetI4 end interface MAPL_AttributeSet interface MAPL_SetPointer module procedure MAPL_SetPointer2DR4 module procedure MAPL_SetPointer3DR4 end interface MAPL_SetPointer interface MAPL_StateAdd module procedure MAPL_StateAddField module procedure MAPL_StateAddBundle end interface MAPL_StateAdd interface MAPL_FieldBundleAdd module procedure MAPL_FieldBundleAddField end interface MAPL_FieldBundleAdd interface MAPL_FieldBundleGet module procedure MAPL_FieldBundleGetByIndex end interface MAPL_FieldBundleGet interface module subroutine MAPL_AllocateCoupling(field, rc) use ESMF, only: ESMF_Field type(ESMF_Field), intent(INOUT) :: field integer, optional, intent( OUT) :: rc end subroutine MAPL_AllocateCoupling module subroutine MAPL_FieldAllocCommit(field, dims, location, typekind, & hw, ungrid, default_value, rc) use ESMF, only: ESMF_Field type(ESMF_Field), intent(INOUT) :: field integer, intent(IN ) :: dims integer, intent(IN ) :: location integer, intent(IN ) :: typekind integer, intent(IN ) :: hw !halowidth integer, optional, intent(IN ) :: ungrid(:) real, optional, intent(IN ) :: default_value integer, optional, intent( OUT) :: rc end subroutine MAPL_FieldAllocCommit module subroutine MAPL_FieldF90Deallocate(field, rc) use ESMF, only: ESMF_Field type(ESMF_Field), intent(INOUT) :: field integer, optional, intent( OUT) :: rc end subroutine MAPL_FieldF90Deallocate module subroutine MAPL_SetPointer2DR4(state, ptr, name, rc) use ESMF, only: ESMF_State type(ESMF_State), intent(INOUT) :: state real, pointer :: ptr(:,:) character(len=*), intent(IN ) :: name integer, optional, intent( OUT) :: rc end subroutine MAPL_SetPointer2DR4 module subroutine MAPL_SetPointer3DR4(state, ptr, name, rc) use ESMF, only: ESMF_State type(ESMF_State), intent(INOUT) :: state real, pointer :: ptr(:,:,:) character(len=*), intent(IN ) :: name integer, optional, intent( OUT) :: rc end subroutine MAPL_SetPointer3DR4 module subroutine MAPL_DecomposeDim ( dim_world,dim,NDEs, unusable, symmetric, min_DE_extent ) use MAPL_KeywordEnforcerMod integer, intent(in) :: dim_world, NDEs integer, intent(out) :: dim(0:NDEs-1) class (KeywordEnforcer), optional, intent(in) :: unusable logical, intent(in), optional :: symmetric integer, optional, intent(in) :: min_DE_extent end subroutine MAPL_DecomposeDim module subroutine MAPL_MakeDecomposition(nx, ny, unusable, reduceFactor, rc) use MAPL_KeywordEnforcerMod integer, intent(out) :: nx integer, intent(out) :: ny class (KeywordEnforcer), optional, intent(in) :: unusable integer, optional, intent(in) :: reduceFactor integer, optional, intent(out) :: rc end subroutine MAPL_MakeDecomposition module subroutine MAPL_Interp_Fac (TIME0, TIME1, TIME2, FAC1, FAC2, RC) use ESMF, only: ESMF_Time !------------------------------------------------------------ ! PURPOSE: ! ======== ! ! Compute interpolation factors, fac, to be used ! in the calculation of the instantaneous boundary ! conditions, ie: ! ! q(i,j) = fac1*q1(i,j) + (1.-fac1)*q2(i,j) ! ! where: ! q(i,j) => Boundary Data valid at time0 ! q1(i,j) => Boundary Data centered at time1 ! q2(i,j) => Boundary Data centered at time2 ! INPUT: ! ====== ! time0 : Time of current timestep ! time1 : Time of boundary data 1 ! time2 : Time of boundary data 2 ! OUTPUT: ! ======= ! fac1 : Interpolation factor for Boundary Data 1 ! ! ------------------------------------------------------------ ! GODDARD LABORATORY FOR ATMOSPHERES ! ------------------------------------------------------------ type(ESMF_Time), intent(in ) :: TIME0, TIME1, TIME2 real, intent(out) :: FAC1 real, optional, intent(out) :: FAC2 integer, optional, intent(out) :: RC end subroutine MAPL_Interp_Fac module subroutine MAPL_ClimInterpFac (CLOCK,I1,I2,FAC, RC) use ESMF, only: ESMF_Clock !------------------------------------------------------------ type(ESMF_CLOCK), intent(in ) :: CLOCK integer, intent(OUT) :: I1, I2 real, intent(out) :: FAC integer, optional, intent(out) :: RC end subroutine MAPL_ClimInterpFac module subroutine MAPL_TimeStringGet(TIMESTRING,YY,MM,DD,H,M,S) character(len=*), intent (IN ) :: TIMESTRING integer, optional, intent (OUT) :: YY integer, optional, intent (OUT) :: MM integer, optional, intent (OUT) :: DD integer, optional, intent (OUT) :: H integer, optional, intent (OUT) :: M integer, optional, intent (OUT) :: S end subroutine MAPL_TimeStringGet module subroutine MAPL_UnpackTime(TIME,IYY,IMM,IDD) integer, intent (IN ) :: TIME integer, intent (OUT) :: IYY integer, intent (OUT) :: IMM integer, intent (OUT) :: IDD end subroutine MAPL_UnpackTime module subroutine MAPL_PackTime(TIME,IYY,IMM,IDD) integer, intent (OUT) :: TIME integer, intent (IN ) :: IYY integer, intent (IN ) :: IMM integer, intent (IN ) :: IDD end subroutine MAPL_PackTime module subroutine MAPL_PackDateTime(date_time, yy, mm, dd, h, m, s) integer, intent(in) :: yy, mm, dd, h, m, s integer, intent(out) :: date_time(:) end subroutine MAPL_PackDateTime module subroutine MAPL_UnpackDateTime(date_time, yy, mm, dd, h, m, s) integer, intent(in) :: date_time(:) integer, intent(out) :: yy, mm, dd, h, m, s end subroutine MAPL_UnpackDateTime integer module function MAPL_nsecf(nhms) integer, intent(in) :: nhms end function MAPL_nsecf integer module function MAPL_nsecf2 (nhhmmss,nmmdd,nymd) integer :: nhhmmss, nmmdd, nymd end function MAPL_nsecf2 module subroutine MAPL_tick (nymd,nhms,ndt) integer nymd,nhms,ndt end subroutine MAPL_tick integer module function MAPL_nhmsf (nsec) implicit none integer nsec end function MAPL_nhmsf ! A year is a leap year if ! 1) it is divible by 4, and ! 2) it is not divisible by 100, unless ! 3) it is also divisible by 400. logical module function MAPL_LEAP(NY) integer, intent(in) :: NY end function MAPL_LEAP integer module function MAPL_incymd (NYMD,M) integer nymd,m end function MAPL_incymd module subroutine MAPL_PICKEM(II,JJ,IM,JM,COUNT) integer, intent(IN ) :: IM, JM, COUNT integer, intent(OUT) :: II(COUNT), JJ(COUNT) end subroutine MAPL_PICKEM module subroutine MAPL_GetFieldTimeFromField ( FIELD, TIME, RC ) use ESMF, only: ESMF_Field, ESMF_Time type(ESMF_Field), intent(INOUT) :: FIELD ! ALT: IN type(ESMF_Time), intent( OUT) :: TIME integer, optional, intent( OUT) :: RC end subroutine MAPL_GetFieldTimeFromField ! ------------------------------------------------------------------------------ module subroutine MAPL_SetFieldTimeFromField (FIELD, TIME, RC ) use ESMF, only: ESMF_Field, ESMF_Time type(ESMF_FIELD), intent(INOUT) :: FIELD type(ESMF_TIME), intent(INOUT) :: TIME !ALT: IN integer, optional, intent( OUT) :: RC end subroutine MAPL_SetFieldTimeFromField module subroutine MAPL_GetFieldTimeFromState ( STATE, Fieldname, TIME, RC ) use ESMF, only: ESMF_State, ESMF_Time type(ESMF_STATE), intent(IN ) :: STATE character(len=*), intent(IN ) :: Fieldname type(ESMF_Time), intent( OUT) :: TIME integer, optional, intent( OUT) :: RC end subroutine MAPL_GetFieldTimeFromState ! ------------------------------------------------------------------------------ module subroutine MAPL_SetFieldTimeFromState ( STATE, Fieldname, TIME, RC ) use ESMF, only: ESMF_State, ESMF_Time type(ESMF_STATE), intent(INOUT) :: STATE character(len=*), intent(IN ) :: Fieldname type(ESMF_Time), intent(INOUT) :: TIME !ALT: IN integer, optional, intent( OUT) :: RC end subroutine MAPL_SetFieldTimeFromState module function MAPL_FieldCreateRename(FIELD, NAME, DoCopy, RC) RESULT(F) use ESMF, only: ESMF_Field type (ESMF_Field), intent(INOUT) :: FIELD !ALT: IN character(len=*), intent(IN ) :: NAME logical, optional, intent(IN ) :: DoCopy integer, optional, intent( OUT) :: RC type (ESMF_Field) :: F end function MAPL_FieldCreateRename module function MAPL_FieldCreateNewgrid(FIELD, GRID, LM, NEWNAME, RC) RESULT(F) use ESMF, only: ESMF_Field, ESMF_Grid type (ESMF_Field), intent(INOUT) :: FIELD !ALT: intent(IN) type (ESMF_Grid), intent(INout) :: GRID integer, optional, intent(IN ) :: lm character(len=*), optional, intent(IN) :: newName integer, optional, intent( OUT) :: RC type (ESMF_Field) :: F end function MAPL_FieldCreateNewgrid module function MAPL_FieldCreateR4(FIELD, RC) RESULT(F) use ESMF, only: ESMF_Field type (ESMF_Field), intent(INOUT) :: FIELD !ALT: IN integer, optional, intent( OUT) :: RC type (ESMF_Field) :: F end function MAPL_FieldCreateR4 module function MAPL_FieldCreateEmpty(NAME, GRID, RC) RESULT(FIELD) use ESMF, only: ESMF_Field, ESMF_Grid character(len=*), intent(IN ) :: NAME type (ESMF_Grid), intent(INout) :: GRID integer, optional, intent( OUT) :: RC type (ESMF_Field) :: FIELD end function MAPL_FieldCreateEmpty module subroutine MAPL_FieldCopyAttributes(FIELD_IN, FIELD_OUT, RC) use ESMF, only: ESMF_Field type (ESMF_Field), intent(INOUT) :: FIELD_IN !ALT: intent(in) type (ESMF_Field), intent(INOUT) :: FIELD_OUT integer, optional, intent( OUT) :: RC end subroutine MAPL_FieldCopyAttributes module subroutine MAPL_FieldCopy(from, to, RC) use ESMF, only: ESMF_Field type (ESMF_Field), intent(INOUT) :: FROM !ALT: IN type (ESMF_Field), intent(INOUT) :: TO !ALT: OUT integer, optional, intent( OUT) :: RC end subroutine MAPL_FieldCopy !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ module function MAPL_RemapBounds_3dr4(A, LB1, LB2, LB3) result(ptr) integer, intent(IN) :: LB1, LB2, LB3 real, target, intent(IN) :: A(LB1:,LB2:,LB3:) real, pointer :: ptr(:,:,:) end function MAPL_RemapBounds_3dr4 !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ module function MAPL_RemapBounds_3dr8(A, LB1, LB2, LB3) result(ptr) integer, intent(IN) :: LB1, LB2, LB3 real(kind=REAL64), target, intent(IN) :: A(LB1:,LB2:,LB3:) real(kind=REAL64), pointer :: ptr(:,:,:) end function MAPL_RemapBounds_3dr8 !++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ !> ! `MAPL_LatLonGridCreate` --- Create regular Lat/Lon Grid ! ! This routine creates a distributed ESMF grid where the horizontal ! coordinates are regular longitudes and latitudes. The grid is ! created on the user specified **VM**, or on the current VM if the user ! does not specify one. The layout and the coordinate information can ! be provided with a `ESMF_Config attribute, a resource file name ! or specified through the argument list. ! !### Using resource files ! The **resource file** has a syntax similar to a GrADS ! control file. Here is an example defining a typical GEOS-5 1x1.25 ! grid with 72 layers: ! !``` ! GDEF: LatLon ! IDEF: 32 ! JDEF: 16 ! LDEF: 1 ! XDEF: 288 LINEAR -180. 1.25 ! YDEF: 181 LINEAR -90. 1. ! ZDEF: 72 LINEAR 1 1 !``` ! More generally, !``` ! GDEF: LatLon ! IDEF: Nx ! JDEF: Ny ! LDEF: Nz ! XDEF: IM_World XCoordType BegLon, DelLon ! YDEF: JM_World YCoordType BegLat, DelLat ! ZDEF: LM_World ZCoordType 1 1 !``` ! ! The attribute **GDEF** must always be `LatLon` for Lat/Lon grids. ! The remaining parameters are: !- **Nx** is the number of processors used to decompose the X dimension !- **Ny** is the number of processors used to decompose the Y dimension !- **Nz** is the number of processors used to decompose the Z dimension; ! must be 1 for now. !- **IM_World** is the number of longitudinal grid points; if `IM_World=0` then ! the grid has no zonal dimension. !- **XCoordType** must be set to LINEAR !- **BegLon** is the longitude (in degrees) of the {\em center} of the first gridbox !- **DelLon** is the constant mesh size (in degrees); if `DelLon<1` then a ! global grid is assumed. !- **JM_World** is the number of meridional grid points; if `JM_World=0` then ! the grid has no meridional dimension. !- **YCoordType** must be set to LINEAR !- **BegLat** s the latitude (in degrees) of the *center* of the first gridbox !- **DelLat** s the constant mesh size (in degrees); if `DelLat<1` then a ! global grid is assumed. !- **LM_World** is the number of vertical grid points; `LM_World=0` then the grid has no ! vertical dimension. ! ! As of this writing, only the size of the vertical grid `LM_World` needs to be specified. ! !### Passing an ESMF Config ! The `ESMF_Config` object `Config`, when specified, must ! contain the same information as the resource file above. ! !### Providing parameters explicitly through the argument list ! Alternatively, one can specify coordinate information in the argument ! list; their units and meaning is as in the resource file above. In ! this case you must specify at least `Nx, Ny, IM_World, JM_World`, and ! `LM_World`. The other parameters have default values !- **BegLon** defaults to -180. (the date line) !- **DelLon** defaults to -1. (meaning a global grid) !- **BegLat** defaults to -90. (the south pole) !- **DelLat** deaults to -1. (meaning a global grid) ! !### Restrictions ! The current implementation imposes the following restrictions: !1. Only uniform longitude/latitude grids are supported (no Gaussian grids). !2. Only 2D Lon-Lat or 3D Lon-Lat-Lev grids are currently supported ! (no Lat-Lev or Lon-Lev grids supprted yet). !3. No vertical decomposition yet (`Nz=1`). ! !### Future enhancements ! The `IDEF/JDEF/LDEF` records in the resource file should be ! extended as to allow specification of a more general distribution. ! For consistency with the `XDEF/YDEF/ZDEF` records a similar ! syntax could be adopted. For example, ! !``` ! IDEF 4 LEVELS 22 50 50 22 ! XDEF 144 LINEAR -180 2.5 !``` ! would indicate that longitudes would be decomposed in 4 PETs, ! with the first PET having 22 grid points, the second 50 gridpoints, ! and so on. ! module function MAPL_LatLonGridCreate (Name, vm, & Config, ConfigFile, & Nx, Ny, & IM_World, BegLon, DelLon, & JM_World, BegLat, DelLat, & LM_World, & rc) & result(Grid) use ESMF, only: ESMF_VM, ESMF_Config, ESMF_Grid ! !INPUT PARAMETERS: character(len=*), intent(in) :: Name type (ESMF_VM), OPTIONAL, target, & intent(in) :: VM ! There are 3 possibilities to provide the coordinate information: ! 1) Thru Config object: type(ESMF_Config), OPTIONAL, target, & intent(in) :: Config ! 2) Thru a resource file: character(len=*), OPTIONAL, intent(in) :: ConfigFile ! 3) Thru argument list: integer, OPTIONAL, intent(in) :: Nx, Ny ! Layout integer, OPTIONAL, intent(in) :: IM_World ! Zonal real, OPTIONAL, intent(in) :: BegLon, DelLon ! in degrees integer, OPTIONAL, intent(in) :: JM_World ! Meridional real, OPTIONAL, intent(in) :: BegLat, DelLat ! in degrees integer, OPTIONAL, intent(in) :: LM_World ! Vertical ! !OUTPUT PARAMETERS: type (ESMF_Grid) :: Grid ! Distributed grid integer, OPTIONAL, intent(out) :: rc ! return code end function MAPL_LatLonGridCreate !............................................................................ module subroutine MAPL_GRID_INTERIOR(GRID,I1,IN,J1,JN) use ESMF, only: ESMF_Grid type (ESMF_Grid), intent(IN) :: grid integer, intent(OUT) :: I1, IN, J1, JN end subroutine MAPL_GRID_INTERIOR module subroutine MAPL_GridGetCorners(grid,gridCornerLons, gridCornerLats, RC) use ESMF, only: ESMF_Grid, ESMF_KIND_R8 type (ESMF_Grid), intent(INOUT) :: GRID real(ESMF_KIND_R8), intent(INOUT) :: gridCornerLons(:,:) real(ESMF_KIND_R8), intent(INOUT) :: gridCornerLats(:,:) integer, optional, intent( OUT) :: RC end subroutine MAPL_GridGetCorners !............................................................................ ! ! Note: The routine below came from ESMFL; it has been moved here to ! avoid circular dependencies (Arlindo). ! module subroutine MAPL_GridGetInterior(GRID,I1,IN,J1,JN) use ESMF, only: ESMF_Grid type (ESMF_Grid), intent(IN) :: grid integer, intent(OUT) :: I1, IN, J1, JN end subroutine MAPL_GridGetInterior !....................................................................... module function MAPL_RmQualifier(str, del) result(new) character(len=*), intent(in) :: str character(len=*), optional, intent(in) :: del ! optional delimiter character(len=len(str)) :: new end function MAPL_RmQualifier module function MAPL_StrUpCase(str) result(new) character(len=*), intent(IN) :: str character(len=len(str)) :: new end function MAPL_StrUpCase module function MAPL_StrDnCase(str) result(new) character(len=*), intent(IN) :: str character(len=len(str)) :: new end function MAPL_StrDnCase ! ======================================== recursive module subroutine MAPL_StateAttSetI4(STATE, NAME, VALUE, RC) use ESMF, only: ESMF_State type(ESMF_State), intent(INOUT) :: STATE character(len=*), intent(IN ) :: NAME integer, intent(IN ) :: VALUE integer, optional, intent( OUT) :: RC end subroutine MAPL_StateAttSetI4 ! ======================================== module subroutine MAPL_BundleAttSetI4(BUNDLE, NAME, VALUE, RC) use ESMF, only: ESMF_FieldBundle type(ESMF_FieldBundle), intent(INOUT) :: BUNDLE character(len=*), intent(IN ) :: NAME integer, intent(IN ) :: VALUE integer, optional, intent( OUT) :: RC end subroutine MAPL_BundleAttSetI4 ! ======================================== module subroutine MAPL_FieldAttSetI4(FIELD, NAME, VALUE, RC) use ESMF, only: ESMF_Field type(ESMF_Field), intent(INOUT) :: FIELD character(len=*), intent(IN ) :: NAME integer, intent(IN ) :: VALUE integer, optional, intent( OUT) :: RC end subroutine MAPL_FieldAttSetI4 ! ======================================== module subroutine MAPL_FieldBundleDestroy(Bundle,RC) use ESMF, only: ESMF_FieldBundle type(ESMF_FieldBundle), intent(INOUT) :: Bundle integer, optional, intent(OUT ) :: RC end subroutine MAPL_FieldBundleDestroy module subroutine MAPL_StateAddField(State, Field, RC) use ESMF, only: ESMF_State, ESMF_Field type(ESMF_State), intent(inout) :: State type(ESMF_Field), intent(in ) :: Field integer, optional, intent( out) :: rc end subroutine MAPL_StateAddField module subroutine MAPL_StateAddBundle(State, Bundle, RC) use ESMF, only: ESMF_State, ESMF_FieldBundle type(ESMF_State), intent(inout) :: State type(ESMF_FieldBundle), intent(in ) :: Bundle integer, optional, intent( out) :: rc end subroutine MAPL_StateAddBundle module subroutine MAPL_FieldBundleAddField(Bundle, Field, multiflag, RC) use ESMF, only: ESMF_Field, ESMF_FieldBundle type(ESMF_FieldBundle), intent(inout) :: Bundle type(ESMF_Field), intent(in ) :: Field logical, optional, intent(in ) :: multiflag integer, optional, intent( out) :: rc end subroutine MAPL_FieldBundleAddField module subroutine MAPL_FieldBundleGetByIndex(Bundle, fieldIndex, Field, RC) use ESMF, only: ESMF_Field, ESMF_FieldBundle type(ESMF_FieldBundle), intent(INout) :: Bundle integer, intent(in ) :: fieldIndex type(ESMF_Field), intent(INout ) :: Field integer, optional, intent( out) :: rc end subroutine MAPL_FieldBundleGetByIndex !BOPI ! !IROUTINE: MAPL_GetHorzIJIndex -- Get indexes on destributed ESMF grid for an arbitary lat and lon ! !INTERFACE: module subroutine MAPL_GetHorzIJIndex(npts,II,JJ,lon,lat,lonR8,latR8,Grid, rc) use ESMF, only: ESMF_KIND_R8, ESMF_GRid implicit none !ARGUMENTS: integer, intent(in ) :: npts ! number of points in lat and lon arrays integer, intent(inout) :: II(npts) ! array of the first index for each lat and lon integer, intent(inout) :: JJ(npts) ! array of the second index for each lat and lon real, optional, intent(in ) :: lon(npts) ! array of longitudes in radians real, optional, intent(in ) :: lat(npts) ! array of latitudes in radians real(ESMF_KIND_R8), optional, intent(in ) :: lonR8(npts) ! array of longitudes in radians real(ESMF_KIND_R8), optional, intent(in ) :: latR8(npts) ! array of latitudes in radians type(ESMF_Grid), optional, intent(inout) :: Grid ! ESMF grid integer, optional, intent(out ) :: rc ! return code end subroutine MAPL_GetHorzIJIndex module subroutine MAPL_GetGlobalHorzIJIndex(npts,II,JJ,lon,lat,lonR8,latR8,Grid, rc) use ESMF, only: ESMF_KIND_R8, ESMF_GRid implicit none !ARGUMENTS: integer, intent(in ) :: npts ! number of points in lat and lon arrays integer, intent(inout) :: II(npts) ! array of the first index for each lat and lon integer, intent(inout) :: JJ(npts) ! array of the second index for each lat and lon real, optional, intent(in ) :: lon(npts) ! array of longitudes in radians real, optional, intent(in ) :: lat(npts) ! array of latitudes in radians real(ESMF_KIND_R8), optional, intent(in ) :: lonR8(npts) ! array of longitudes in radians real(ESMF_KIND_R8), optional, intent(in ) :: latR8(npts) ! array of latitudes in radians type(ESMF_Grid), optional, intent(inout) :: Grid ! ESMF grid integer, optional, intent(out ) :: rc ! return code end subroutine MAPL_GetGlobalHorzIJIndex module subroutine MAPL_Reverse_Schmidt(Grid, stretched, npts,lon,lat,lonR8,latR8, lonRe, latRe, rc) use ESMF, only: ESMF_KIND_R8, ESMF_GRid implicit none !ARGUMENTS: type(ESMF_Grid), intent(inout) :: Grid ! ESMF grid logical, intent(out ) :: stretched integer, intent(in ) :: npts ! number of points in lat and lon arrays real, optional, intent(in ) :: lon(npts) ! array of longitudes in radians real, optional, intent(in ) :: lat(npts) ! array of latitudes in radians real(ESMF_KIND_R8), optional, intent(in ) :: lonR8(npts) ! array of longitudes in radians real(ESMF_KIND_R8), optional, intent(in ) :: latR8(npts) ! array of latitudes in radians real(ESMF_KIND_R8), optional, intent(out ) :: lonRe(npts) ! array of longitudes in radians real(ESMF_KIND_R8), optional, intent(out ) :: latRe(npts) ! array of latitudes in radians integer, optional, intent(out ) :: rc ! return code end subroutine MAPL_Reverse_Schmidt module subroutine MAPL_GenGridName(im, jm, lon, lat, xyoffset, gridname, geos_style) integer :: im, jm character (len=*) :: gridname real, optional :: lon(:), lat(:) integer, optional :: xyoffset logical, optional :: geos_style end subroutine MAPL_GenGridName module function MAPL_GenXYOffset(lon, lat) result(xy) real :: lon(:), lat(:) integer :: xy end function MAPL_GenXYOffset module subroutine MAPL_GeosNameNew(name) character(len=*) :: name end subroutine MAPL_GeosNameNew ! From a grid and a list of fields create an allocated ESMF bundle with ! these fields. By Default variables will be 3D at the center location ! unless 2 optional arguements are passed in. Can also pass in a list ! of long names and units if desired module function MAPL_BundleCreate(name,grid,fieldNames,is2D,isEdge,long_names,units,rc) result(B) use ESMF, only: ESMF_Grid, ESMF_FieldBundle character(len=*), intent(in ) :: name type(ESMF_Grid), intent(inout) :: grid character(len=*), intent(in ) :: fieldNames(:) logical, optional, intent(in ) :: is2D(:) logical, optional, intent(in ) :: isEdge(:) character(len=*), optional, intent(in ) :: long_names(:) character(len=*), optional, intent(in ) :: units(:) integer, optional, intent(out ) :: rc type(ESMF_FieldBundle) :: B end function MAPL_BundleCreate module function MAPL_TrimString(istring,rc) result(ostring) character(len=*), intent(in) :: istring integer, optional, intent(out) :: rc character(len=:), allocatable :: ostring end function MAPL_TrimString module subroutine MAPL_FieldSplit(field, fields, aliasName, rc) use ESMF, only: ESMF_Field type(ESMF_Field), intent(IN ) :: field type(ESMF_Field), pointer, intent( out) :: fields(:) character(len=*), optional, intent(in ) :: aliasName integer, optional, intent( out) :: rc end subroutine MAPL_FieldSplit module function MAPL_GetCorrectedPhase(gc,rc) result(phase) use ESMF, only: ESMF_GridComp type(ESMF_GridComp), intent(inout) :: gc integer, optional, intent(out) :: rc integer :: phase end function end interface contains ! NAG and Intel need inconsistent workarounds for this function if moved ! into the submodule. So keeping it here. function MAPL_RemapBoundsFull_3dr4(A,I1,IM,J1,JM,L1,LM) integer, intent(IN) :: I1,IM,J1,JM,L1,LM real, target, intent(IN) :: A(I1:IM,J1:JM,L1:LM) real, pointer :: MAPL_RemapBoundsFull_3dr4(:,:,:) MAPL_RemapBoundsFull_3dr4 => A end function MAPL_RemapBoundsFull_3dr4 end module MAPL_Base module MAPL_BaseMod use MAPL_Base use MAPL_RangeMod, only: MAPL_Range use mapl_MaplGrid, only: MAPL_GridGet, MAPL_DistGridGet, MAPL_GetImsJms, MAPL_GridHasDE use MAPL_Constants end module MAPL_BaseMod