diff --git a/lis/configs/lis.config.adoc b/lis/configs/lis.config.adoc index d740f57d3..75965f281 100644 --- a/lis/configs/lis.config.adoc +++ b/lis/configs/lis.config.adoc @@ -351,6 +351,7 @@ Acceptable values for the sources are: |"`GLDAS`" | GLDAS |"`GFS`" | GFS |"`MERRA2`" | MERRA2 +|"`GEOS-IT`" | GEOS-IT |"`CMAP`" | CMAP |"`TRMM 3B42RT`" | TRMM 3B42RT |"`TRMM 3B42RTV7`" | TRMM 3B42RTV7 @@ -5580,7 +5581,6 @@ GFS domain y-dimension size: 256 GFS number of forcing variables: 10 .... - [[sssec_forcings_MERRA2,MERRA2]] ==== MERRA2 @@ -5636,6 +5636,50 @@ MERRA2 use 2m wind fields: 0 MERRA2 use corrected total precipitation: 1 .... +[[sssec_forcings_GEOS-IT,GEOS-IT]] +==== GEOS-IT + +`GEOS-IT forcing directory:` specifies the location of +the GEOS-IT forcing files. + +Please note that GEOS-IT is currently in production and is +not complete for all calendar years. Also, it is not yet +available outside of NASA`'s NCCS computing platforms. +Also, the topographic or elevation correction option is +supported through the MERRA-2 geopotential terrain height +file. Please also see the latest LDT notes for updates on +how to use this option. + +`GEOS-IT use lowest model level forcing:` specifies whether +to use the lowest model level forcing. +Acceptable values are: + +|==== +|Value | Description + +|0 | Do not use the lowest model level forcing. +|1 | Use the lowest model level forcing. +|==== + +`GEOS-IT use 2m wind fields:` specifies whether to use the +2m diagnosed wind fields. This option will only work if +the lowest model level forcing option is turned off. +Acceptable values are: + +|==== +|Value | Description + +|0 | Do not use the 2m diagnosed wind speed fields. +|1 | Use the 2m diagnosed wind speed fields. +|==== + +.Example _lis.config_ entry +.... +GEOS-IT forcing directory: ./GEOS-IT +GEOS-IT use lowest model level forcing: 1 +GEOS-IT use 2m wind fields: 0 +.... + [[sssec_forcings_ERA5,ERA5]] ==== ERA5 diff --git a/lis/make/default.cfg b/lis/make/default.cfg index e62461e53..363a09167 100644 --- a/lis/make/default.cfg +++ b/lis/make/default.cfg @@ -282,6 +282,11 @@ enabled: True macro: MF_MERRA2 path: metforcing/merra2 +[GEOS-IT] +enabled: True +macro: MF_GEOS_IT +path: metforcing/geos_it + [ERA5] enabled: True macro: MF_ERA5 diff --git a/lis/metforcing/geos_it/0Intro_geosit.txt b/lis/metforcing/geos_it/0Intro_geosit.txt new file mode 100644 index 000000000..55b2f8f29 --- /dev/null +++ b/lis/metforcing/geos_it/0Intro_geosit.txt @@ -0,0 +1,14 @@ +!-----------------------BEGIN NOTICE -- DO NOT EDIT----------------------- +! NASA Goddard Space Flight Center +! Land Information System Framework (LISF) +! Version 7.4 +! +! Copyright (c) 2022 United States Government as represented by the +! Administrator of the National Aeronautics and Space Administration. +! All Rights Reserved. +!-------------------------END NOTICE -- DO NOT EDIT----------------------- +! +!BOP +!\section{GEOS-IT} +!This section describes the implementation of the GEOS-IT forcing data. +!EOP diff --git a/lis/metforcing/geos_it/finalize_geosit.F90 b/lis/metforcing/geos_it/finalize_geosit.F90 new file mode 100644 index 000000000..565a97409 --- /dev/null +++ b/lis/metforcing/geos_it/finalize_geosit.F90 @@ -0,0 +1,72 @@ +!-----------------------BEGIN NOTICE -- DO NOT EDIT----------------------- +! NASA Goddard Space Flight Center +! Land Information System Framework (LISF) +! Version 7.4 +! +! Copyright (c) 2022 United States Government as represented by the +! Administrator of the National Aeronautics and Space Administration. +! All Rights Reserved. +!-------------------------END NOTICE -- DO NOT EDIT----------------------- +!BOP +! !ROUTINE: finalize_geosit +! \label{finalize_geosit} +! +! !REVISION HISTORY: +! 18 Mar 2015: James Geiger, initial code (based on merra-land) +! 20 Apr 2023: David Mocko, initial code (based on merra2) +! +! !INTERFACE: + subroutine finalize_geosit(findex) + +! !USES: + use LIS_coreMod, only : LIS_rc + use geosit_forcingMod, only : geosit_struc +! +! !DESCRIPTION: +! Routine to cleanup GEOS-IT forcing related memory allocations. +! +!EOP + implicit none + + integer :: findex + integer :: n + + do n = 1,LIS_rc%nnest + select case( LIS_rc%met_interp(findex) ) + + case( "bilinear" ) + deallocate(geosit_struc(n)%n111) + deallocate(geosit_struc(n)%n121) + deallocate(geosit_struc(n)%n211) + deallocate(geosit_struc(n)%n221) + deallocate(geosit_struc(n)%w111) + deallocate(geosit_struc(n)%w121) + deallocate(geosit_struc(n)%w211) + deallocate(geosit_struc(n)%w221) + + case( "budget-bilinear" ) + deallocate(geosit_struc(n)%n111) + deallocate(geosit_struc(n)%n121) + deallocate(geosit_struc(n)%n211) + deallocate(geosit_struc(n)%n221) + deallocate(geosit_struc(n)%w111) + deallocate(geosit_struc(n)%w121) + deallocate(geosit_struc(n)%w211) + deallocate(geosit_struc(n)%w221) + deallocate(geosit_struc(n)%n112) + deallocate(geosit_struc(n)%n122) + deallocate(geosit_struc(n)%n212) + deallocate(geosit_struc(n)%n222) + deallocate(geosit_struc(n)%w112) + deallocate(geosit_struc(n)%w122) + deallocate(geosit_struc(n)%w212) + deallocate(geosit_struc(n)%w222) + + case( "neighbor" ) + deallocate(geosit_struc(n)%n113) + end select + enddo + deallocate(geosit_struc) + + end subroutine finalize_geosit + diff --git a/lis/metforcing/geos_it/geosit_forcingMod.F90 b/lis/metforcing/geos_it/geosit_forcingMod.F90 new file mode 100644 index 000000000..f271caf0c --- /dev/null +++ b/lis/metforcing/geos_it/geosit_forcingMod.F90 @@ -0,0 +1,292 @@ +!-----------------------BEGIN NOTICE -- DO NOT EDIT----------------------- +! NASA Goddard Space Flight Center +! Land Information System Framework (LISF) +! Version 7.4 +! +! Copyright (c) 2022 United States Government as represented by the +! Administrator of the National Aeronautics and Space Administration. +! All Rights Reserved. +!-------------------------END NOTICE -- DO NOT EDIT----------------------- + module geosit_forcingMod +!BOP +! !MODULE: geosit_forcingMod +! +! !DESCRIPTION: +! This module contains variables and data structures that are used +! for the implementation of the GEOS-IT forcing data. +! The data is global 0.625-degree lon. by 0.5-degree lat, in latlon +! projection, and at 1 hourly intervals. The derived data type +! {\tt geosit\_struc} +! includes the variables that specify the runtime options, and the +! weights and neighbor information to be used for spatial interpolation. +! They are described below: +! \begin{description} +! \item[ncold] +! Number of columns (along the east west dimension) for the input data +! \item[nrold] +! Number of rows (along the north south dimension) for the input data +! \item[nmif] +! Number of forcing variables in the data +! \item[geosittime1] +! The nearest, previous 1 hour instance of the incoming +! data (as a real time). +! \item[geosittime2] +! The nearest, next 1 hour instance of the incoming +! data (as a real time). +! \item[geositdir] +! Directory containing the input data +! \item[mi] +! Number of points in the input grid +! \item[n111,n121,n211,n221] +! Arrays containing the neighbor information of the input grid +! for each grid point in LIS, for bilinear interpolation. +! \item[w111,w121,w211,w221] +! Arrays containing the weights of the input grid +! for each grid point in LIS, for bilinear interpolation. +! \item[n122,n122,n212,n222] +! Arrays containing the neighbor information of the input grid +! for each grid point in LIS, for conservative interpolation. +! \item[w112,w122,w212,w222] +! Arrays containing the weights of the input grid +! for each grid point in LIS, for conservative interpolation. +! \item[n113] +! Arrays containing the neighbor information of the input grid +! for each grid point in LIS, for n. neighbor interpolation. +! \item[findtime1, findtime2] +! boolean flags to indicate which time is to be read for +! temporal interpolation. +! \end{description} +! +! !USES: + use LIS_constantsMod, only : LIS_CONST_PATH_LEN + + implicit none + + PRIVATE +!----------------------------------------------------------------------------- +! !PUBLIC MEMBER FUNCTIONS: +!----------------------------------------------------------------------------- + public :: init_geosit ! defines the native resolution of the input data +!----------------------------------------------------------------------------- +! !PUBLIC TYPES: +!----------------------------------------------------------------------------- + public :: geosit_struc + +!EOP + type, public :: geosit_type_dec + real :: ts + integer :: ncold, nrold + character(len=LIS_CONST_PATH_LEN) :: geositdir ! GEOS-IT Forcing Directory + real*8 :: geosittime1,geosittime2 + logical :: reset_flag + + integer :: mi + integer, allocatable :: n111(:) + integer, allocatable :: n121(:) + integer, allocatable :: n211(:) + integer, allocatable :: n221(:) + real, allocatable :: w111(:),w121(:) + real, allocatable :: w211(:),w221(:) + + integer, allocatable :: n112(:,:) + integer, allocatable :: n122(:,:) + integer, allocatable :: n212(:,:) + integer, allocatable :: n222(:,:) + real, allocatable :: w112(:,:),w122(:,:) + real, allocatable :: w212(:,:),w222(:,:) + integer, allocatable :: n113(:) + integer :: findtime1,findtime2 + logical :: startFlag,dayFlag + real, allocatable :: geositforc1(:,:,:),geositforc2(:,:,:) + + integer :: nvars + integer :: uselml + real*8 :: ringtime + integer :: nIter,st_iterid,en_iterid + + real, allocatable :: metdata1(:,:,:) + real, allocatable :: metdata2(:,:,:) + + integer :: use2mwind + character(len=LIS_CONST_PATH_LEN) :: scaleffile + integer, allocatable :: rseed(:,:) + end type geosit_type_dec + + type(geosit_type_dec), allocatable :: geosit_struc(:) + + contains + +!BOP +! +! !ROUTINE: init_geosit +! \label{init_geosit} +! +! !REVISION HISTORY: +! 18 Mar 2015: James Geiger, initial code (based on merra-land) +! 20 Apr 2023: David Mocko, initial code (based on merra2) +! +! !INTERFACE: + subroutine init_geosit(findex) + +! !USES: + use LIS_coreMod + use LIS_timeMgrMod + use LIS_logMod + use LIS_spatialDownscalingMod, only : LIS_init_pcpclimo_native + + implicit none +! !AGRUMENTS: + integer, intent(in) :: findex + +! !DESCRIPTION: +! Defines the native resolution of the input forcing for GEOS-IT +! data. The grid description arrays are based on the decoding +! schemes used by NCEP and followed in the LIS interpolation +! schemes (see Section~\ref{interp}). +! +! The routines invoked are: +! \begin{description} +! \item[readcrd\_geosit](\ref{readcrd_geosit}) \newline +! reads the runtime options specified for GEOS-IT data +! \item[bilinear\_interp\_input](\ref{bilinear_interp_input}) \newline +! computes the neighbor, weights for bilinear interpolation +! \item[conserv\_interp\_input](\ref{conserv_interp_input}) \newline +! computes the neighbor, weights for conservative interpolation +! \end{description} +!EOP + real :: gridDesci(LIS_rc%nnest,50) + integer :: updoy,yr1,mo1,da1,hr1,mn1,ss1 + real :: upgmt + integer :: n + + allocate(geosit_struc(LIS_rc%nnest)) + + do n = 1,LIS_rc%nnest + geosit_struc(n)%ncold = 576 + geosit_struc(n)%nrold = 361 + enddo + + call readcrd_geosit() + LIS_rc%met_nf(findex) = 14 + + geosit_struc%reset_flag = .false. + + do n = 1, LIS_rc%nnest + geosit_struc(n)%ts = 3600 !check + call LIS_update_timestep(LIS_rc,n,geosit_struc(n)%ts) + enddo + + gridDesci = 0 + + do n = 1,LIS_rc%nnest + gridDesci(n,1) = 0 + gridDesci(n,2) = geosit_struc(n)%ncold + gridDesci(n,3) = geosit_struc(n)%nrold + gridDesci(n,4) = -90.000 + gridDesci(n,5) = -180.000 + gridDesci(n,6) = 128 + gridDesci(n,7) = 90.000 + gridDesci(n,8) = 179.375 + gridDesci(n,9) = 0.625 + gridDesci(n,10) = 0.5 + gridDesci(n,20) = 0 + + geosit_struc(n)%mi = geosit_struc(n)%ncold*geosit_struc(n)%nrold + + ! Setting up weights for Interpolation + if (trim(LIS_rc%met_interp(findex)).eq."bilinear") then + allocate(geosit_struc(n)%n111(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%n121(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%n211(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%n221(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%w111(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%w121(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%w211(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%w221(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + call bilinear_interp_input(n,gridDesci(n,:), & + geosit_struc(n)%n111,geosit_struc(n)%n121, & + geosit_struc(n)%n211,geosit_struc(n)%n221, & + geosit_struc(n)%w111,geosit_struc(n)%w121, & + geosit_struc(n)%w211,geosit_struc(n)%w221) + + elseif (trim(LIS_rc%met_interp(findex)).eq."budget-bilinear") then + allocate(geosit_struc(n)%n111(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%n121(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%n211(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%n221(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%w111(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%w121(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%w211(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%w221(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + call bilinear_interp_input(n,gridDesci(n,:), & + geosit_struc(n)%n111,geosit_struc(n)%n121, & + geosit_struc(n)%n211,geosit_struc(n)%n221, & + geosit_struc(n)%w111,geosit_struc(n)%w121, & + geosit_struc(n)%w211,geosit_struc(n)%w221) + + allocate(geosit_struc(n)%n112(LIS_rc%lnc(n)*LIS_rc%lnr(n),25)) + allocate(geosit_struc(n)%n122(LIS_rc%lnc(n)*LIS_rc%lnr(n),25)) + allocate(geosit_struc(n)%n212(LIS_rc%lnc(n)*LIS_rc%lnr(n),25)) + allocate(geosit_struc(n)%n222(LIS_rc%lnc(n)*LIS_rc%lnr(n),25)) + allocate(geosit_struc(n)%w112(LIS_rc%lnc(n)*LIS_rc%lnr(n),25)) + allocate(geosit_struc(n)%w122(LIS_rc%lnc(n)*LIS_rc%lnr(n),25)) + allocate(geosit_struc(n)%w212(LIS_rc%lnc(n)*LIS_rc%lnr(n),25)) + allocate(geosit_struc(n)%w222(LIS_rc%lnc(n)*LIS_rc%lnr(n),25)) + call conserv_interp_input(n,gridDesci(n,:), & + geosit_struc(n)%n112,geosit_struc(n)%n122, & + geosit_struc(n)%n212,geosit_struc(n)%n222, & + geosit_struc(n)%w112,geosit_struc(n)%w122, & + geosit_struc(n)%w212,geosit_struc(n)%w222) + + elseif (trim(LIS_rc%met_interp(findex)).eq."neighbor") then + allocate(geosit_struc(n)%n113(LIS_rc%lnc(n)*LIS_rc%lnr(n))) + call neighbor_interp_input(n,gridDesci(n,:), & + geosit_struc(n)%n113) + + else + write(LIS_logunit,*) '[ERR] Interpolation option '// & + trim(LIS_rc%met_interp(findex))// & + ' for GEOS-IT forcing is not supported' + call LIS_endrun() + endif + + call LIS_registerAlarm("GEOS-IT forcing alarm",86400.0,86400.0) + geosit_struc(n)%startFlag = .true. + geosit_struc(n)%dayFlag = .true. + + geosit_struc(n)%nvars = 14 + + allocate(geosit_struc(n)%geositforc1(1, & + geosit_struc(n)%nvars, LIS_rc%lnc(n)*LIS_rc%lnr(n))) + allocate(geosit_struc(n)%geositforc2(1,& + geosit_struc(n)%nvars, LIS_rc%lnc(n)*LIS_rc%lnr(n))) + geosit_struc(n)%st_iterid = 1 + geosit_struc(n)%en_iterId = 1 + geosit_struc(n)%nIter = 1 + + allocate(geosit_struc(n)%metdata1(1,LIS_rc%met_nf(findex), & + LIS_rc%ngrid(n))) + allocate(geosit_struc(n)%metdata2(1,LIS_rc%met_nf(findex), & + LIS_rc%ngrid(n))) + + geosit_struc(n)%metdata1 = 0 + geosit_struc(n)%metdata2 = 0 + + geosit_struc(n)%geositforc1 = LIS_rc%udef + geosit_struc(n)%geositforc2 = LIS_rc%udef + + if ((LIS_rc%met_ecor(findex).eq."lapse-rate").or. & + (LIS_rc%met_ecor(findex).eq."lapse-rate and slope-aspect")) then + call read_geosit_elev(n,findex) + endif + +! Set up precipitation climate downscaling: + if (LIS_rc%pcp_downscale(findex).ne.0) then + call LIS_init_pcpclimo_native(n,findex,geosit_struc(n)%ncold,& + geosit_struc(n)%nrold) + endif + enddo ! End nest loop + + end subroutine init_geosit + end module geosit_forcingMod + diff --git a/lis/metforcing/geos_it/get_geosit.F90 b/lis/metforcing/geos_it/get_geosit.F90 new file mode 100644 index 000000000..bd5b1eaa2 --- /dev/null +++ b/lis/metforcing/geos_it/get_geosit.F90 @@ -0,0 +1,309 @@ +!-----------------------BEGIN NOTICE -- DO NOT EDIT----------------------- +! NASA Goddard Space Flight Center +! Land Information System Framework (LISF) +! Version 7.4 +! +! Copyright (c) 2022 United States Government as represented by the +! Administrator of the National Aeronautics and Space Administration. +! All Rights Reserved. +!-------------------------END NOTICE -- DO NOT EDIT----------------------- +!BOP +! +! !ROUTINE: get_geosit +! \label{get_geosit} +! +! !REVISION HISTORY: +! 18 Mar 2015: James Geiger, initial code (based on merra-land) +! 08 Dec 2015: James Geiger, update timing logic +! 20 Apr 2023: David Mocko, initial code (based on merra2) +! +! !INTERFACE: + subroutine get_geosit(n,findex) +! !USES: + use LIS_coreMod + use LIS_timeMgrMod + use LIS_logMod + use LIS_metforcingMod + use geosit_forcingMod + use LIS_constantsMod, only : LIS_CONST_PATH_LEN + + implicit none + +! !ARGUMENTS: + integer, intent(in) :: n + integer, intent(in) :: findex +! +! !DESCRIPTION: +! Opens, reads, and interpolates 1-hourly GEOS-IT forcing. +! +! The GEOS-IT forcing data are organized into hourly files. +! The data are considered valid at the mid-point of the hourly interval. +! +! In general, metforcing readers read the forcing data before the +! current time, referred to as bookend1, and after the current time, +! referred to as bookend2. Then the readers temporally interpolate +! between bookend1 and bookend2. +! +! Below are some examples to illustrate the timing logic of the +! GEOS-IT reader. +! +! \begin{verbatim} +! ---*---|---*---|---*---|---*---|---*---|---*---|---*---|---*--- +! hour 21 22 23 0 1 2 3 +! hr_int <---22--X--23---X--24---X---1---X---2---X---3---> +! +! where: +! hour is the hour UTC +! hr_int is the hour-interval +! * marks the valid point for the interval <--- hr_int ---> +! +! The arguments are: +! \begin{description} +! \item[n] +! index of the nest +! \item[findex] +! forcing dataset index +! \end{description} +! +! The routines invoked are: +! \begin{description} +! \item[LIS\_tick](\ref{LIS_tick}) \newline +! call to advance or retract time +! \item[geositfiles](\ref{geositfiles}) \newline +! Puts together appropriate file name for 1 hour intervals +! \item[read\_geosit](\ref{read_geosit}) \newline +! call to read the GEOS-IT data and perform spatial interpolation +! \end{description} +!EOP + integer :: order + integer :: ferror + character(len=LIS_CONST_PATH_LEN) :: slvname,flxname,lfoname,radname + integer :: c,f,r,kk + integer :: yr1,mo1,da1,hr1,mn1,ss1,doy1 + integer :: yr2,mo2,da2,hr2,mn2,ss2,doy2 + real*8 :: time1,time2,timenow + real :: gmt1,gmt2 + real :: ts1,ts2 + integer :: hr_int1,hr_int2 + integer :: movetime ! Flag to move bookend2 files to bookend1 + +! _________________________________________________________ +! + + if (LIS_rc%nts(n).gt.3600) then ! > 1-hr timestep + write(LIS_logunit,*) '[ERR] When running LIS with GEOS-IT,' + write(LIS_logunit,*) '[ERR] the clock should run with a time' + write(LIS_logunit,*) '[ERR] step less than or equal to 1 hr.' + call LIS_endrun() + endif + + geosit_struc(n)%findtime1 = 0 + geosit_struc(n)%findtime2 = 0 + movetime = 0 + +!---------------------------------------------------------- +! Determine current time +!---------------------------------------------------------- + yr1 = LIS_rc%yr + mo1 = LIS_rc%mo + da1 = LIS_rc%da + hr1 = LIS_rc%hr + mn1 = LIS_rc%mn + ss1 = 0 + ts1 = 0 + call LIS_tick(timenow,doy1,gmt1,yr1,mo1,da1,hr1,mn1,ss1,ts1) + + if (LIS_rc%ts.gt.3600.0) then + write(LIS_logunit,*) & + '[ERR] The model timestep is > forcing data timestep' + write(LIS_logunit,*) & + '[ERR] LIS does not support this mode currently' + write(LIS_logunit,*) '[ERR] Program stopping ...' + call LIS_endrun() + endif + + if (mod(nint(LIS_rc%ts),3600).eq.0) then + if (timenow.ge.geosit_struc(n)%geosittime2) then + yr1 = LIS_rc%yr + mo1 = LIS_rc%mo + da1 = LIS_rc%da + hr1 = LIS_rc%hr + mn1 = 0 + ss1 = 0 + ts1 = -60*60 + call LIS_tick(time1,doy1,gmt1,yr1,mo1,da1,hr1,mn1,ss1,ts1) + + yr2 = LIS_rc%yr !next hour + mo2 = LIS_rc%mo + da2 = LIS_rc%da + hr2 = LIS_rc%hr + mn2 = 0 + ss2 = 0 + ts2 = 0 + call LIS_tick(time2,doy2,gmt2,yr2,mo2,da2,hr2,mn2,ss2,ts2) + endif + else + if (timenow.ge.geosit_struc(n)%geosittime2) then + yr1 = LIS_rc%yr + mo1 = LIS_rc%mo + da1 = LIS_rc%da + hr1 = LIS_rc%hr + mn1 = 0 + ss1 = 0 + ts1 = 0 + call LIS_tick(time1,doy1,gmt1,yr1,mo1,da1,hr1,mn1,ss1,ts1) + geosit_struc(n)%findtime1 = 1 + + yr2 = LIS_rc%yr !next hour + mo2 = LIS_rc%mo + da2 = LIS_rc%da + hr2 = LIS_rc%hr + mn2 = 0 + ss2 = 0 + ts2 = 60*60 + call LIS_tick(time2,doy2,gmt2,yr2,mo2,da2,hr2,mn2,ss2,ts2) + geosit_struc(n)%geosittime2 = time2 + endif + endif + +! Beginning of the run + if ((LIS_rc%tscount(n).eq.1).or.(LIS_rc%rstflag(n).eq.1)) then + geosit_struc(n)%findtime1 = 1 + geosit_struc(n)%geosittime2 = time2 + LIS_rc%rstflag(n) = 0 + endif + +! Read GEOS-IT - Bookend 1 files: + if (geosit_struc(n)%findtime1.eq.1) then + order = 1 + do kk = geosit_struc(n)%st_iterid,geosit_struc(n)%en_iterid + call geositfiles(n,kk,findex,geosit_struc(n)%geositdir, & + doy1,yr1,mo1,da1,hr1, & + slvname,flxname,lfoname,radname) + call read_geosit(n,order,mo1,findex, & + slvname,flxname,lfoname,radname, & + geosit_struc(n)%geositforc1(kk,:,:),ferror) + enddo + geosit_struc(n)%geosittime1 = time1 + endif + +! Assign GEOS-IT forcing fields to two LIS time-interp placeholders: + do r = 1,LIS_rc%lnr(n) + do c = 1,LIS_rc%lnc(n) + if (LIS_domain(n)%gindex(c,r).ne.-1) then + geosit_struc(n)%metdata1(:,:,LIS_domain(n)%gindex(c,r)) = & + geosit_struc(n)%geositforc1(:,:,(c+(r-1)*LIS_rc%lnc(n))) + geosit_struc(n)%metdata2(:,:,LIS_domain(n)%gindex(c,r)) = & + geosit_struc(n)%geositforc2(:,:,(c+(r-1)*LIS_rc%lnc(n))) + endif + enddo + enddo + + end subroutine get_geosit + +!BOP +! !ROUTINE: geositfiles +! \label{geositfiles} +! +! !INTERFACE: + subroutine geositfiles(n,kk,findex,geositdir,doy,yr,mo,da,hr, & + slvname,flxname,lfoname,radname) + +! !USES: + use LIS_coreMod + use LIS_logMod + use LIS_timeMgrMod + + implicit none +! !ARGUMENTS: + integer :: n + integer :: kk + integer :: findex + character(len=*), intent(in) :: geositdir + integer, intent(in) :: doy,yr,mo,da,hr + character(len=*), intent(out) :: slvname + character(len=*), intent(out) :: flxname + character(len=*), intent(out) :: lfoname + character(len=*), intent(out) :: radname + +! !DESCRIPTION: +! This subroutine puts together GEOS-IT file names for +! hourly netCDF files. +! +! The arguments are: +! \begin{description} +! \item[geositdir] +! Name of the GEOS-IT directory +! \item[doy] +! day of year +! \item[yr] +! year +! \item[mo] +! month +! \item[da] +! day of month +! \item[hr] +! hour +! \item[slvname] +! name of the timestamped single level file +! \item[flxname] +! name of the timestamped flux file +! \item[lfoname] +! name of the timestamped land surface forcings file +! \item[radname] +! name of the timestamped radiation forcings file +! \end{description} +! +!EOP + + character*4 :: cyear + character*2 :: cyr,cmo,cdy,chr + character*16 :: prefix + character*31 :: slv_spec,flx_spec,lfo_spec,rad_spec + + write(unit=cyear,fmt='(i4.4)') yr + write(unit=cmo, fmt='(i2.2)') mo + write(unit=chr, fmt='(i2.2)') hr + write(unit=cdy, fmt='(i2.2)') da + + prefix = 'd5294_geosit_jan' + if (yr.lt.1998) then + write(LIS_logunit,*) '[ERR] GEOS-IT data starts 1 Jan 1998.' + call LIS_endrun() + else + cyr = '98' + endif + if (yr.ge.2008) then + cyr = '08' + endif + if (yr.ge.2018) then + cyr = '18' + endif + + slv_spec = '.slv_tavg_1hr_glo_L576x361_slv.' + flx_spec = '.flx_tavg_1hr_glo_L576x361_slv.' + lfo_spec = '.lfo_tavg_1hr_glo_L576x361_slv.' + rad_spec = '.rad_tavg_1hr_glo_L576x361_slv.' + +! Single level fields: + slvname = trim(geositdir)//'/'//prefix//cyr//'/diag/Y'//cyear// & + '/M'//cmo//'/'//prefix//cyr//slv_spec//cyear//'-'// & + cmo//'-'//cdy//'T'//chr//'30Z.nc4' + +! Flux fields: + flxname = trim(geositdir)//'/'//prefix//cyr//'/diag/Y'//cyear// & + '/M'//cmo//'/'//prefix//cyr//flx_spec//cyear//'-'// & + cmo//'-'//cdy//'T'//chr//'30Z.nc4' + +! Land surface forcing level: + lfoname = trim(geositdir)//'/'//prefix//cyr//'/diag/Y'//cyear// & + '/M'//cmo//'/'//prefix//cyr//lfo_spec//cyear//'-'// & + cmo//'-'//cdy//'T'//chr//'30Z.nc4' + +! Radiation fields: + radname = trim(geositdir)//'/'//prefix//cyr//'/diag/Y'//cyear// & + '/M'//cmo//'/'//prefix//cyr//rad_spec//cyear//'-'// & + cmo//'-'//cdy//'T'//chr//'30Z.nc4' + + end subroutine geositfiles + diff --git a/lis/metforcing/geos_it/read_geosit.F90 b/lis/metforcing/geos_it/read_geosit.F90 new file mode 100644 index 000000000..8e34b9381 --- /dev/null +++ b/lis/metforcing/geos_it/read_geosit.F90 @@ -0,0 +1,487 @@ +!-----------------------BEGIN NOTICE -- DO NOT EDIT----------------------- +! NASA Goddard Space Flight Center +! Land Information System Framework (LISF) +! Version 7.4 +! +! Copyright (c) 2022 United States Government as represented by the +! Administrator of the National Aeronautics and Space Administration. +! All Rights Reserved. +!-------------------------END NOTICE -- DO NOT EDIT----------------------- +#include "LIS_misc.h" +!BOP +! +! !ROUTINE: read_geosit +! \label{read_geosit} +! +! !REVISION HISTORY: +! 18 Mar 2015: James Geiger, initial code (based on merra-land) +! 20 Apr 2023: David Mocko, initial code (based on merra2) +! +! !INTERFACE: + subroutine read_geosit(n,order,month,findex, & + slvname,flxname,lfoname,radname, & + geositforc,ferror) +! !USES: + use LIS_coreMod, only : LIS_rc, LIS_domain, LIS_masterproc + use LIS_logMod + use LIS_FORC_AttributesMod + use LIS_metforcingMod, only : LIS_forc + use geosit_forcingMod, only : geosit_struc +#if (defined USE_NETCDF3 || defined USE_NETCDF4) + use netcdf +#endif + + implicit none +! !ARGUMENTS: + integer, intent(in) :: n + integer, intent(in) :: order + integer, intent(in) :: month + integer, intent(in) :: findex + character(len=*), intent(in) :: slvname + character(len=*), intent(in) :: flxname + character(len=*), intent(in) :: lfoname + character(len=*), intent(in) :: radname + real, intent(inout) :: geositforc(geosit_struc(n)%nvars,& + LIS_rc%lnc(n)*LIS_rc%lnr(n)) + integer, intent(out) :: ferror + +! !DESCRIPTION: +! For the given time, reads parameters from GEOS-IT data, transforms +! into 9 LIS forcing parameters and interpolates to the LIS domain. \newline +! +! GEOS-IT FORCING VARIABLES: \newline +! 1. tair Temperature of air at 2-m, 10-m, or LML [$K$] \newline +! 2. qair Specific humidity of air at 2-m, 10-m, or LML [$kg/kg$] \newline +! 3. swgdn Downward shortwave radiation at the ground [$W/m^2$] \newline +! 4. lwgab Downward longwave radiation at the ground [$W/m^2$] \newline +! 5. uwind Zonal wind at 2-m, 10-m, or LML [$m/s$] \newline +! 6. vwind Meridional wind at 2-m, 10-m, or LML [$m/s$] \newline +! 7. ps Instantaneous Surface Pressure [$Pa$] \newline +! 8. pretot Total precipitation [$mm/s$] \newline +! 9. precon Convective precipitation [$mm/s$] \newline +! 10. presno Precipitation falling as snow [$mm/s$] \newline +! 11. swland Net shortwave radiation at the ground [$W/m^2$] \newline +! 12. pardr Surface downward PAR beam flux [$W/m^2$] \newline +! 13. pardf Surface downward PAR diffuse flux [$W/m^2$] \newline +! 14. hlml Height of center of lowest model layer (LML) [$m$] \newline +! +! The arguments are: +! \begin{description} +! \item[order] +! flag indicating which data to be read (order=1, read the previous +! 1 hourly instance, order=2, read the next 1 hourly instance) +! \item[n] +! index of the nest +! \item[name] +! name of the 1 hour GEOS-IT analysis file +! \item[tscount] +! time step count +! \item[ferror] +! return error code (0 indicates success) +! \end{description} +! +! The routines invoked are: +! \begin{description} +! \item[bilinear\_interp](\ref{bilinear_interp}) \newline +! spatially interpolate the forcing data using bilinear interpolation +! \item[conserv\_interp](\ref{conserv_interp}) \newline +! spatially interpolate the forcing data using conservative interpolation +! \end{description} +!EOP + + integer :: ftn_slv,ftn_flx,ftn_lfo,ftn_rad + integer :: tmpId,qId,uId,vId,psId + integer :: prectotId,precconId,swgdnId,lwgabId + integer :: precsnoId,hlmlID + integer :: swlandId,pardrId,pardfId + integer :: nr_index,nc_index + logical :: file_exists,file_exists1 + integer :: c,r,t,k,iret + integer :: mo + logical :: read_lnd + + real :: tair(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: qair(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: uwind(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: vwind(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: ps(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: prectot(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: precsno(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: preccon(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: swgdn(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: lwgab(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: swland(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: pardr(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: pardf(geosit_struc(n)%ncold,geosit_struc(n)%nrold) + real :: hlml(geosit_struc(n)%ncold,geosit_struc(n)%nrold) +! __________________________________________________________________________ + +#if (defined USE_NETCDF3) + write(LIS_logunit,*) "[ERR] GEOS-IT reader requires NetCDF4" + call LIS_endrun() +#endif + +#if (defined USE_NETCDF4) + ferror = 0 + nr_index = geosit_struc(n)%nrold + nc_index = geosit_struc(n)%ncold + mo = LIS_rc%lnc(n)*LIS_rc%lnr(n) + +! Read single layer file (*slv) fields: + inquire(file=slvname,exist=file_exists) + if (file_exists) then + write(LIS_logunit,*) & + '[INFO] Reading GEOS-IT file: ',trim(slvname) + call LIS_verify(nf90_open(path=trim(slvname), & + mode=NF90_NOWRITE,ncid=ftn_slv), & + 'nf90_open failed for slvfile in read_geosit') + + call LIS_verify(nf90_inq_varid(ftn_slv,'PS',psId), & + 'nf90_inq_varid failed for ps in read_geosit') + call LIS_verify(nf90_get_var(ftn_slv,psId,ps), & + 'nf90_get_var failed for ps in read_geosit') + +! If using the GEOS-IT lowest model level forcing (*flx): + if (geosit_struc(n)%uselml.eq.1) then + inquire(file=flxname,exist=file_exists1) + if (.not.file_exists1) then + write(LIS_logunit,*) & + '[ERR] ',trim(flxname)//' does not exist' + call LIS_endrun() + endif + + write(LIS_logunit,*) & + '[INFO] Reading GEOS-IT file: ',trim(flxname) + write(LIS_logunit,*) ' (for lowest model level fields)' + call LIS_verify(nf90_open(path=trim(flxname), & + mode=NF90_NOWRITE,ncid=ftn_flx), & + 'nf90_open failed for flxfile in read_geosit') + + call LIS_verify(nf90_inq_varid(ftn_flx,'TLML',tmpId), & + 'nf90_inq_varid failed for tlml in read_geosit') + call LIS_verify(nf90_get_var(ftn_flx,tmpId,tair), & + 'nf90_get_var failed for tlml in read_geosit') + + call LIS_verify(nf90_inq_varid(ftn_flx,'QLML',qId), & + 'nf90_inq_varid failed for qlml in read_geosit') + call LIS_verify(nf90_get_var(ftn_flx,qId,qair), & + 'nf90_get_var failed for qlml in read_geosit') + + call LIS_verify(nf90_inq_varid(ftn_flx,'ULML',uId), & + 'nf90_inq_varid failed for ulml in read_geosit') + call LIS_verify(nf90_get_var(ftn_flx,uId,uwind), & + 'nf90_get_var failed for ulml in read_geosit') + + call LIS_verify(nf90_inq_varid(ftn_flx,'VLML',vId), & + 'nf90_inq_varid failed for vlml in read_geosit') + call LIS_verify(nf90_get_var(ftn_flx,vId,vwind), & + 'nf90_get_var failed for vlml in read_geosit') + + call LIS_verify(nf90_close(ftn_flx), & + '[WARN] Failed to close flxfile in read_geosit.') + +! Else use the single-layer fields (e.g., 2-m ref. height): + else + call LIS_verify(nf90_inq_varid(ftn_slv,'T2M',tmpId), & + 'nf90_inq_varid failed for t2m in read_geosit') + call LIS_verify(nf90_get_var(ftn_slv,tmpId,tair), & + 'nf90_get_var failed for t2m in read_geosit') + + call LIS_verify(nf90_inq_varid(ftn_slv,'QV2M',qId), & + 'nf90_inq_varid failed for qv2m in read_geosit') + call LIS_verify(nf90_get_var(ftn_slv,qId,qair), & + 'nf90_get_var failed for qv2m in read_geosit') + +! Use either 2-m winds or 10-m winds: + if (geosit_struc(n)%use2mwind.eq.1) then + call LIS_verify(nf90_inq_varid(ftn_slv,'U2M',uId), & + 'nf90_inq_varid failed for u2m in read_geosit') + call LIS_verify(nf90_get_var(ftn_slv,uId,uwind), & + 'nf90_get_var failed for u2m in read_geosit') + + call LIS_verify(nf90_inq_varid(ftn_slv,'V2M',vId), & + 'nf90_inq_varid failed for v2m in read_geosit') + call LIS_verify(nf90_get_var(ftn_slv,vId,vwind), & + 'nf90_get_var failed for v2m in read_geosit') + else + call LIS_verify(nf90_inq_varid(ftn_slv,'U10M',uId), & + 'nf90_inq_varid failed for u10m in read_geosit') + call LIS_verify(nf90_get_var(ftn_slv,uId,uwind), & + 'nf90_get_var failed for u10m in read_geosit') + + call LIS_verify(nf90_inq_varid(ftn_slv,'V10M',vId), & + 'nf90_inq_varid failed for v10m in read_geosit') + call LIS_verify(nf90_get_var(ftn_slv,vId,vwind), & + 'nf90_get_var failed for v10m in read_geosit') + endif + endif + + call LIS_verify(nf90_close(ftn_slv), & + '[WARN] Failed to close slvfile in read_geosit.') + + call interp_geosit_var(n,findex,month,tair, 1,.false.,geositforc) + call interp_geosit_var(n,findex,month,qair, 2,.false.,geositforc) + call interp_geosit_var(n,findex,month,uwind, 5,.false.,geositforc) + call interp_geosit_var(n,findex,month,vwind, 6,.false.,geositforc) + call interp_geosit_var(n,findex,month,ps, 7,.false.,geositforc) + else + write(LIS_logunit,*) '[ERR] ',trim(slvname)//' does not exist' + call LIS_endrun() + endif + +! Read in the flux file fields (*flx): + inquire(file=flxname,exist=file_exists) + if (file_exists) then + write(LIS_logunit,*) & + '[INFO] Reading GEOS-IT file: ',trim(flxname) + call LIS_verify(nf90_open(path=trim(flxname), & + mode=NF90_NOWRITE,ncid=ftn_flx), & + 'nf90_open failed for flxfile in read_geosit') + + call LIS_verify(nf90_inq_varid(ftn_flx,'PRECTOT',prectotId), & + 'nf90_inq_varid failed for prectot in read_geosit') + call LIS_verify(nf90_get_var(ftn_flx,prectotId,prectot), & + 'nf90_get_var failed for prectot in read_geosit') + + call interp_geosit_var(n,findex,month,prectot,8,.true.,geositforc) + +! Read in the convective precipitation, if selected in the forcing table: + if (LIS_FORC_CRainf%selectOpt.eq.1) then + call LIS_verify(nf90_inq_varid(ftn_flx,'PRECCON',precconId),& + 'nf90_inq_varid failed for preccon in read_geosit') + call LIS_verify(nf90_get_var(ftn_flx,precconId,preccon), & + 'nf90_get_var failed for preccon in read_geosit') + + call interp_geosit_var(n,findex,month,preccon,9,.true.,geositforc) + endif + +! Read in the snowfall field, if selected in the forcing input table: + if (LIS_FORC_Snowf%selectOpt.eq.1) then + call LIS_verify(nf90_inq_varid(ftn_flx,'PRECSNO',precsnoId),& + 'nf90_inq_varid failed for precsno in read_geosit') + call LIS_verify(nf90_get_var(ftn_flx,precsnoId,precsno), & + 'nf90_get_var failed for precsno in read_geosit') + + call interp_geosit_var(n,findex,month,precsno,10,.true.,geositforc) + endif + +! Read in Forcing Height, if selected in the forcing input table: + if (LIS_FORC_Forc_Hgt%selectOpt.eq.1) then + call LIS_verify(nf90_inq_varid(ftn_flx,'HLML',hlmlId), & + 'nf90_inq_varid failed for hlml in read_geosit') + call LIS_verify(nf90_get_var(ftn_flx,hlmlId,hlml), & + 'nf90_get_var failed for hlml in read_geosit') + + call interp_geosit_var(n,findex,month,hlml,14,.false.,geositforc) + endif + + call LIS_verify(nf90_close(ftn_flx), & + '[WARN] Failed to close flxfile in read_geosit.') + + else + write(LIS_logunit,*) '[ERR] ',trim(flxname)//' does not exist' + call LIS_endrun() + endif + +! Read in the radiation file fields (*rad): + inquire(file=radname,exist=file_exists) + if (file_exists) then + write(LIS_logunit,*) & + '[INFO] Reading GEOS-IT file: ',trim(radname) + call LIS_verify(nf90_open(path=trim(radname), & + mode=NF90_NOWRITE,ncid=ftn_rad), & + 'nf90_open failed for radfile in read_geosit') + + call LIS_verify(nf90_inq_varid(ftn_rad,'SWGDN',swgdnId), & + 'nf90_inq_varid failed for swgdn in read_geosit') + call LIS_verify(nf90_get_var(ftn_rad,swgdnId,swgdn), & + 'nf90_get_var failed for swgdn in read_geosit') + + call LIS_verify(nf90_inq_varid(ftn_rad,'LWGAB',lwgabId), & + 'nf90_inq_varid failed for lwgab in read_geosit') + call LIS_verify(nf90_get_var(ftn_rad,lwgabId,lwgab), & + 'nf90_get_var failed for lwgab in read_geosit') + + call interp_geosit_var(n,findex,month,swgdn,3,.false.,geositforc) + call interp_geosit_var(n,findex,month,lwgab,4,.false.,geositforc) + + call LIS_verify(nf90_close(ftn_rad), & + '[WARN] Failed to close radfile in read_geosit.') + else + write(LIS_logunit,*) '[ERR] ',trim(radname)//' does not exist' + call LIS_endrun() + endif + +! Checks: For reading in the surface layer file fields (*lfo): + read_lnd = .false. + if ((LIS_FORC_Pardr%selectOpt.eq.1).or. & + (LIS_FORC_Pardf%selectOpt.eq.1).or. & + (LIS_FORC_SWnet%selectOpt.eq.1)) then + read_lnd = .true. + endif + +! Read in the surface layer fields (*lfo): + if (read_lnd) then + inquire(file=lfoname,exist=file_exists) + if (file_exists) then + write(LIS_logunit,*) & + '[INFO] Reading GEOS-IT file: ',trim(radname) + call LIS_verify(nf90_open(path=trim(radname), & + mode=NF90_NOWRITE,ncid=ftn_rad), & + 'nf90_open failed for radfile in read_geosit') + + if (LIS_FORC_SWnet%selectOpt.eq.1) then + call LIS_verify(nf90_inq_varid(ftn_lfo,'SWLAND',swlandId),& + 'nf90_inq_varid failed for swland in read_geosit') + call LIS_verify(nf90_get_var(ftn_lfo,swlandId,swland), & + 'nf90_get_var failed for swland in read_geosit') + + call interp_geosit_var(n,findex,month,swland,11,.false.,geositforc) + endif + + if (LIS_FORC_Pardr%selectOpt.eq.1) then + call LIS_verify(nf90_inq_varid(ftn_lfo,'PARDR',pardrId),& + 'nf90_inq_varid failed for pardr in read_geosit') + call LIS_verify(nf90_get_var(ftn_lfo,pardrId,pardr), & + 'nf90_get_var failed for pardr in read_geosit') + + call interp_geosit_var(n,findex,month,pardr,12,.false.,geositforc) + endif + + if (LIS_FORC_Pardf%selectOpt.eq.1) then + call LIS_verify(nf90_inq_varid(ftn_lfo,'PARDF',pardfId),& + 'nf90_inq_varid failed for pardf in read_geosit') + call LIS_verify(nf90_get_var(ftn_lfo,pardfId,pardf), & + 'nf90_get_var failed for pardf in read_geosit') + + call interp_geosit_var(n,findex,month,pardf,13,.false.,geositforc) + endif + + call LIS_verify(nf90_close(ftn_lfo), & + '[WARN] Failed to close lfofile in read_geosit.') + + else + write(LIS_logunit,*) '[ERR] ',trim(lfoname)// & + ' does not exist' + call LIS_endrun() + endif + endif +#endif + + end subroutine read_geosit + +!BOP +! +! !ROUTINE: interp_geosit_var +! \label{interp_geosit_var} +! +! !INTERFACE: + subroutine interp_geosit_var(n,findex,month,input_var,var_index, & + pcp_flag,geositforc) + +! !USES: + use LIS_coreMod + use LIS_logMod + use LIS_spatialDownscalingMod + use geosit_forcingMod, only : geosit_struc +#if(defined USE_NETCDF3 || defined USE_NETCDF4) + use netcdf +#endif + + implicit none +! !ARGUMENTS: + integer, intent(in) :: n + integer, intent(in) :: findex + integer, intent(in) :: month + real, intent(in) :: input_var(geosit_struc(n)%ncold, & + geosit_struc(n)%nrold) + integer, intent(in) :: var_index + logical, intent(in) :: pcp_flag + real, intent(inout) :: geositforc(geosit_struc(n)%nvars, & + LIS_rc%lnc(n)*LIS_rc%lnr(n)) + +! !DESCRIPTION: +! This subroutine spatially interpolates a GEOS-IT field +! to the LIS running domain +! +!EOP + integer :: t,c,r,k,iret + integer :: doy + integer :: ftn + integer :: pcp1Id,pcp2Id,pcp3Id,pcp4Id,pcp5Id,pcp6Id + real :: f (geosit_struc(n)%ncold*geosit_struc(n)%nrold) + logical*1 :: lb(geosit_struc(n)%ncold*geosit_struc(n)%nrold) + logical*1 :: lo(LIS_rc%lnc(n)*LIS_rc%lnr(n)) + integer :: input_size + logical :: scal_read_flag +! _____________________________________________________________ + + input_size = geosit_struc(n)%ncold*geosit_struc(n)%nrold + +!----------------------------------------------------------------------- +! Apply downscaling +!----------------------------------------------------------------------- + lb = .true. + do r = 1,geosit_struc(n)%nrold + do c = 1,geosit_struc(n)%ncold + k = c+(r-1)*geosit_struc(n)%ncold + f(k) = input_var(c,r) + if (f(k).eq.1.e+15) then + f(k) = LIS_rc%udef + lb(k) = .false. + endif + enddo + enddo + + if (pcp_flag.and.(LIS_rc%pcp_downscale(findex).ne.0)) then +! input_data becomes the ratio field. + call LIS_generatePcpClimoRatioField(n,findex,"GEOS-IT", & + month,input_size,f,lb) + endif + + if (pcp_flag.and. & + (trim(LIS_rc%met_interp(findex)).eq."budget-bilinear")) then + + call conserv_interp(LIS_rc%gridDesc(n,:),lb,f,lo, & + geositforc(var_index,:), & + geosit_struc(n)%mi,LIS_rc%lnc(n)*LIS_rc%lnr(n), & + LIS_domain(n)%lat,LIS_domain(n)%lon, & + geosit_struc(n)%w112,geosit_struc(n)%w122, & + geosit_struc(n)%w212,geosit_struc(n)%w222, & + geosit_struc(n)%n112,geosit_struc(n)%n122, & + geosit_struc(n)%n212,geosit_struc(n)%n222, & + LIS_rc%udef,iret) + + elseif ((trim(LIS_rc%met_interp(findex)).eq."bilinear").or. & + (trim(LIS_rc%met_interp(findex)).eq."budget-bilinear")) then + call bilinear_interp(LIS_rc%gridDesc(n,:),lb,f,lo, & + geositforc(var_index,:), & + geosit_struc(n)%mi,LIS_rc%lnc(n)*LIS_rc%lnr(n), & + LIS_domain(n)%lat,LIS_domain(n)%lon, & + geosit_struc(n)%w111,geosit_struc(n)%w121, & + geosit_struc(n)%w211,geosit_struc(n)%w221, & + geosit_struc(n)%n111,geosit_struc(n)%n121, & + geosit_struc(n)%n211,geosit_struc(n)%n221, & + LIS_rc%udef,iret) + + elseif (trim(LIS_rc%met_interp(findex)).eq."neighbor") then + call neighbor_interp(LIS_rc%gridDesc(n,:),lb,f,lo, & + geositforc(var_index,:), & + geosit_struc(n)%mi,LIS_rc%lnc(n)*LIS_rc%lnr(n), & + LIS_domain(n)%lat,LIS_domain(n)%lon, & + geosit_struc(n)%n113,LIS_rc%udef,iret) + + else + write(LIS_logunit,*) '[ERR] Spatial interpolation option '// & + trim(LIS_rc%met_interp(findex))// & + ' not supported for GEOS-IT.' + call LIS_endrun() + endif + + if (pcp_flag.and.(LIS_rc%pcp_downscale(findex).ne.0)) then + call LIS_pcpClimoDownscaling(n,findex,month, & + LIS_rc%lnc(n)*LIS_rc%lnr(n),geositforc(var_index,:),lo) + endif + + end subroutine interp_geosit_var + diff --git a/lis/metforcing/geos_it/read_geosit_elev.F90 b/lis/metforcing/geos_it/read_geosit_elev.F90 new file mode 100644 index 000000000..8660048f7 --- /dev/null +++ b/lis/metforcing/geos_it/read_geosit_elev.F90 @@ -0,0 +1,78 @@ +!-----------------------BEGIN NOTICE -- DO NOT EDIT----------------------- +! NASA Goddard Space Flight Center +! Land Information System Framework (LISF) +! Version 7.4 +! +! Copyright (c) 2022 United States Government as represented by the +! Administrator of the National Aeronautics and Space Administration. +! All Rights Reserved. +!-------------------------END NOTICE -- DO NOT EDIT----------------------- +!BOP +! !ROUTINE: read_geosit_elev +! \label{read_geosit_elev} +! +! !REVISION HISTORY: +! +! 22 Sep 2016: James Geiger; Initial Specification +! 20 Apr 2023: David Mocko, initial code (based on merra2) +! +! !INTERFACE: + subroutine read_geosit_elev(n,findex) +! !USES: + use LIS_coreMod, only : LIS_rc, LIS_domain + use LIS_metforcingMod, only : LIS_forc + use LIS_fileIOMod, only : LIS_read_param + use LIS_logMod, only : LIS_logunit + + implicit none + +! !ARGUMENTS: + integer, intent(in) :: n + integer, intent(in) :: findex + +! !DESCRIPTION: +! +! Opens and reads MERRA-2 model elevation to the LIS grid. +! The MERRA-2 elevation is the same as the GEOS-IT elevation. +! The data will be used to perform any topographical adjustments +! to the forcing. +! +! The elevation file needs to be preprocessed to fit the running +! resolution and domain. +! +! The arguments are: +! \begin{description} +! \item[n] +! index of the nest +! \item[findex] +! index of the forcing source +! \end{description} +! +! The routines invoked are: +! \begin{description} +! \item[LIS\_readData](\ref{LIS_readData}) \newline +! Abstract method to read the elevation of the forcing +! data in the same map projection used in LIS. +! \end{description} +!EOP + + integer :: c,r + real :: go(LIS_rc%lnc(n),LIS_rc%lnr(n)) + + if (trim(LIS_rc%met_ecor(findex)).ne."none") then + write(LIS_logunit,*) & + 'Reading the GEOS-IT/MERRA-2 elevation map ...' + + call LIS_read_param(n,"ELEV_MERRA2",go) + + do r = 1,LIS_rc%lnr(n) + do c = 1,LIS_rc%lnc(n) + if (LIS_domain(n)%gindex(c,r).ne.-1) then + LIS_forc(n,findex)%modelelev(LIS_domain(n)%gindex(c,r)) = go(c,r) + endif + enddo + enddo + endif + + end subroutine read_geosit_elev + diff --git a/lis/metforcing/geos_it/readcrd_geosit.F90 b/lis/metforcing/geos_it/readcrd_geosit.F90 new file mode 100644 index 000000000..6aba34e62 --- /dev/null +++ b/lis/metforcing/geos_it/readcrd_geosit.F90 @@ -0,0 +1,77 @@ +!-----------------------BEGIN NOTICE -- DO NOT EDIT----------------------- +! NASA Goddard Space Flight Center +! Land Information System Framework (LISF) +! Version 7.4 +! +! Copyright (c) 2022 United States Government as represented by the +! Administrator of the National Aeronautics and Space Administration. +! All Rights Reserved. +!-------------------------END NOTICE -- DO NOT EDIT----------------------- +!BOP +! +! !ROUTINE: readcrd_geosit +! \label{readcrd_geosit} +! +! !REVISION HISTORY: +! 18 Mar 2015: James Geiger, initial code (based on merra-land) +! 20 Apr 2023: David Mocko, initial code (based on merra2) +! +! !INTERFACE: + subroutine readcrd_geosit() +! !USES: + use ESMF + use LIS_logMod + use LIS_coreMod, only : LIS_rc,LIS_config + use geosit_forcingMod, only : geosit_struc +! +! !DESCRIPTION: +! +! This routine reads the options specific to GEOS-IT forcing +! from the LIS configuration file. +! +!EOP + implicit none + + integer :: n,t,rc,m + + call ESMF_ConfigFindLabel(LIS_config, & + "GEOS-IT forcing directory:",rc=rc) + do n = 1,LIS_rc%nnest + call ESMF_ConfigGetAttribute(LIS_config, & + geosit_struc(n)%geositdir,rc=rc) + call LIS_verify(rc,'GEOS-IT forcing directory: not defined') + enddo + + call ESMF_ConfigFindLabel(LIS_config, & + "GEOS-IT use lowest model level forcing:",rc=rc) + do n = 1,LIS_rc%nnest + call ESMF_ConfigGetAttribute(LIS_config, & + geosit_struc(n)%uselml,rc=rc) + call LIS_verify(rc, & + 'GEOS-IT use lowest model level forcing: not defined') + enddo + + do m = 1, LIS_rc%nnest + if (geosit_struc(m)%uselml.eq.0) then + call ESMF_ConfigFindLabel(LIS_config, & + "GEOS-IT use 2m wind fields:",rc=rc) + do n = 1,LIS_rc%nnest + call ESMF_ConfigGetAttribute(LIS_config, & + geosit_struc(n)%use2mwind,rc=rc) + call LIS_verify(rc, & + 'GEOS-IT use 2m wind fields: not defined') + enddo + endif + enddo + + do n = 1,LIS_rc%nnest + write(LIS_logunit,*) '[INFO] Using GEOS-IT forcing' + write(LIS_logunit,*) '[INFO] GEOS-IT forcing directory: ', & + trim(geosit_struc(n)%geositdir) + + geosit_struc(n)%geosittime1 = 3000.0 + geosit_struc(n)%geosittime2 = 0.0 + enddo + + end subroutine readcrd_geosit + diff --git a/lis/metforcing/geos_it/reset_geosit.F90 b/lis/metforcing/geos_it/reset_geosit.F90 new file mode 100644 index 000000000..e1032bc2a --- /dev/null +++ b/lis/metforcing/geos_it/reset_geosit.F90 @@ -0,0 +1,43 @@ +!-----------------------BEGIN NOTICE -- DO NOT EDIT----------------------- +! NASA Goddard Space Flight Center +! Land Information System Framework (LISF) +! Version 7.4 +! +! Copyright (c) 2022 United States Government as represented by the +! Administrator of the National Aeronautics and Space Administration. +! All Rights Reserved. +!-------------------------END NOTICE -- DO NOT EDIT----------------------- +!BOP +! !MODULE: reset_geosit +! \label{reset_geosit} +! +! !REVISION HISTORY: +! 18 Mar 2015: James Geiger, initial code (based on merra-land) +! 20 Apr 2023: David Mocko, initial code (based on merra2) +! +! !INTERFACE: + subroutine reset_geosit +! !USES: + use LIS_coreMod, only : LIS_rc + use LIS_timeMgrMod, only : LIS_date2time + use geosit_forcingMod +! +! !DESCRIPTION: +! Routine to cleanup allocated structures for GEOS-IT forcing. +! +!EOP + implicit none + + integer :: n + + do n = 1,LIS_rc%nnest + geosit_struc(n)%startFlag = .true. + geosit_struc(n)%dayFlag = .true. + geosit_struc(n)%geosittime1 = 3000.0 + geosit_struc(n)%geosittime2 = 0.0 + geosit_struc(n)%ringtime = 0.0 + geosit_struc(n)%reset_flag = .true. + enddo + + end subroutine reset_geosit + diff --git a/lis/metforcing/geos_it/timeinterp_geosit.F90 b/lis/metforcing/geos_it/timeinterp_geosit.F90 new file mode 100644 index 000000000..d62624b60 --- /dev/null +++ b/lis/metforcing/geos_it/timeinterp_geosit.F90 @@ -0,0 +1,294 @@ +!-----------------------BEGIN NOTICE -- DO NOT EDIT----------------------- +! NASA Goddard Space Flight Center +! Land Information System Framework (LISF) +! Version 7.4 +! +! Copyright (c) 2022 United States Government as represented by the +! Administrator of the National Aeronautics and Space Administration. +! All Rights Reserved. +!-------------------------END NOTICE -- DO NOT EDIT----------------------- +!BOP +! !ROUTINE: timeinterp_geosit +! \label{timeinterp_geosit} +! +! !REVISION HISTORY: +! 18 Mar 2015: James Geiger, initial code (based on merra-land) +! 20 Apr 2023: David Mocko, initial code (based on merra2) +! +! !INTERFACE: + subroutine timeinterp_geosit(n,findex) + +! !USES: + use ESMF + use LIS_FORC_AttributesMod + use LIS_coreMod, only : LIS_rc,LIS_domain,LIS_localPet + use LIS_metforcingMod, only : LIS_forc,LIS_FORC_Base_State + use LIS_constantsMod, only : LIS_CONST_SOLAR + use LIS_timeMgrMod, only : LIS_tick + use LIS_logMod, only : LIS_logunit,LIS_verify,LIS_endrun + use geosit_forcingMod, only : geosit_struc + use LIS_forecastMod, only : LIS_get_iteration_index + use LIS_ran2_gasdev + + implicit none + +! !ARGUMENTS: + integer, intent(in):: n + integer, intent(in):: findex +! +! !DESCRIPTION: +! Temporally interpolates the forcing data to the current model +! timestep. Because all variables are a 1-hourly time average, +! no interpolation in time is actually performed. The identical +! data is used for all timesteps within the hourly input file. +! +! The routines invoked are: +! \begin{description} +! \item[LIS\_time2date](\ref{LIS_time2date}) \newline +! converts the time to a date format +! \item[zterp](\ref{zterp}) \newline +! zenith-angle based interpolation +! \end{description} +!EOP + integer :: t,zdoy,k,kk + integer :: index1 + integer :: bdoy,byr,bmo + integer :: bda,bhr,bmn + integer :: bss + real*8 :: btime + real :: wt1,wt2,czb,cze,czm,gmt1,gmt2 + real :: zw1,zw2,bts + integer :: status + integer :: mfactor,m + type(ESMF_Field) :: tairField,qairField,swgdnField,lwgabField + type(ESMF_Field) :: uwindField,vwindField,psField + type(ESMF_Field) :: prectotField,precconField,precsnoField + type(ESMF_Field) :: swlandField,pardrField,pardfField,hlmlField + real,pointer :: tair(:),qair(:),swgdn(:),lwgab(:) + real,pointer :: uwind(:),vwind(:),ps(:) + real,pointer :: prectot(:),preccon(:),precsno(:) + real,pointer :: swland(:),pardr(:),pardf(:),hlml(:) + + btime = geosit_struc(n)%geosittime1 + byr = LIS_rc%yr + bmo = LIS_rc%mo + bda = LIS_rc%da + bhr = LIS_rc%hr + bmn = 30 + bss = 0 + if (LIS_rc%mn.lt.30) then + bts = -(60*60) + else + bts = 0 + endif + call LIS_tick(btime,bdoy,gmt1,byr,bmo,bda,bhr,bmn,bss,bts) + + btime = geosit_struc(n)%geosittime2 + byr = LIS_rc%yr !next hour + bmo = LIS_rc%mo + bda = LIS_rc%da + bhr = LIS_rc%hr + bmn = 30 + bss = 0 + if (LIS_rc%mn.lt.30) then + bts = 0 + else + bts = 60*60 + endif + call LIS_tick(btime,bdoy,gmt2,byr,bmo,bda,bhr,bmn,bss,bts) + + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_Tair%varname(1),tairField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable Tair in the forcing variables list') + + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_Qair%varname(1),QairField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable Qair in the forcing variables list') + + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_SWdown%varname(1),swgdnField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable SWdown in the forcing variables list') + + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_LWdown%varname(1),lwgabField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable LWdown in the forcing variables list') + + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_Wind_E%varname(1),uwindField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable Wind_E in the forcing variables list') + + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_Wind_N%varname(1),vwindField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable Wind_N in the forcing variables list') + + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_Psurf%varname(1),psField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable Psurf in the forcing variables list') + + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_Rainf%varname(1),prectotField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable Rainf in the forcing variables list') + + if (LIS_FORC_CRainf%selectOpt.eq.1) then + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_CRainf%varname(1),precconField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable CRainf in the forcing variables list') + endif + + if (LIS_FORC_Snowf%selectOpt.eq.1) then + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_Snowf%varname(1),precsnoField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable Snowf in the forcing variables list') + endif + + if (LIS_FORC_Swnet%selectOpt.eq.1) then + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_Swnet%varname(1),swlandField,& + rc=status) + call LIS_verify(status, & + 'Error: Enable SWnet in the forcing variables list') + endif + + if (LIS_FORC_Pardr%selectOpt.eq.1) then + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_Pardr%varname(1),pardrField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable PARDR in the forcing variables list') + endif + + if (LIS_FORC_Pardf%selectOpt.eq.1) then + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_Pardf%varname(1),pardfField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable PARDF in the forcing variables list') + endif + + if (LIS_FORC_Forc_Hgt%selectOpt.eq.1) then + call ESMF_StateGet(LIS_FORC_Base_State(n,findex), & + LIS_FORC_Forc_Hgt%varname(1),hlmlField, & + rc=status) + call LIS_verify(status, & + 'Error: Enable Forc_Hgt in the forcing variables list') + endif + + call ESMF_FieldGet(tairField,localDE=0,farrayPtr=tair,rc=status) + call LIS_verify(status) + + call ESMF_FieldGet(qairField,localDE=0,farrayPtr=qair,rc=status) + call LIS_verify(status) + + call ESMF_FieldGet(swgdnField,localDE=0,farrayPtr=swgdn,rc=status) + call LIS_verify(status) + + call ESMF_FieldGet(lwgabField,localDE=0,farrayPtr=lwgab,rc=status) + call LIS_verify(status) + + call ESMF_FieldGet(uwindField,localDE=0,farrayPtr=uwind,rc=status) + call LIS_verify(status) + + call ESMF_FieldGet(vwindField,localDE=0,farrayPtr=vwind,rc=status) + call LIS_verify(status) + + call ESMF_FieldGet(psField,localDE=0,farrayPtr=ps,rc=status) + call LIS_verify(status) + + call ESMF_FieldGet(prectotField,localDE=0,farrayPtr=prectot,rc=status) + call LIS_verify(status) + + if (LIS_FORC_CRainf%selectOpt.eq.1) then + call ESMF_FieldGet(precconField,localDE=0,farrayPtr=preccon,rc=status) + call LIS_verify(status) + endif + + if (LIS_FORC_Snowf%selectOpt.eq.1) then + call ESMF_FieldGet(precsnoField,localDE=0,farrayPtr=precsno,rc=status) + call LIS_verify(status) + endif + + if (LIS_FORC_Swnet%selectOpt.eq.1) then + call ESMF_FieldGet(swlandField,localDE=0,farrayPtr=swland,rc=status) + call LIS_verify(status) + endif + + if (LIS_FORC_Pardr%selectOpt.eq.1) then + call ESMF_FieldGet(pardrField,localDE=0,farrayPtr=pardr,rc=status) + call LIS_verify(status) + endif + + if (LIS_FORC_Pardf%selectOpt.eq.1) then + call ESMF_FieldGet(pardfField,localDE=0,farrayPtr=pardf,rc=status) + call LIS_verify(status) + endif + + if (LIS_FORC_Forc_Hgt%selectOpt.eq.1) then + call ESMF_FieldGet(hlmlField,localDE=0,farrayPtr=hlml,rc=status) + call LIS_verify(status) + endif + + mfactor = LIS_rc%nensem(n)/geosit_struc(n)%nIter + + do k = 1,LIS_rc%ntiles(n)/mfactor + do m = 1,mfactor + t = m + (k-1)*mfactor + index1 = LIS_domain(n)%tile(t)%index + kk = LIS_get_iteration_index(n,k,index1,mfactor) + + tair(t) = geosit_struc(n)%metdata1(kk,1,index1) + qair(t) = geosit_struc(n)%metdata1(kk,2,index1) + swgdn(t) = geosit_struc(n)%metdata1(kk,3,index1) + if (swgdn(t).gt.LIS_CONST_SOLAR) then + swgdn(t) = LIS_CONST_SOLAR + endif + lwgab(t) = geosit_struc(n)%metdata1(kk,4,index1) + uwind(t) = geosit_struc(n)%metdata1(kk,5,index1) + vwind(t) = geosit_struc(n)%metdata1(kk,6,index1) + ps(t) = geosit_struc(n)%metdata1(kk,7,index1) + prectot(t) = geosit_struc(n)%metdata1(kk,8,index1) + if (prectot(t).lt.0.0) then + prectot(t) = 0.0 + endif + if (LIS_FORC_CRainf%selectOpt.eq.1) then + preccon(t) = geosit_struc(n)%metdata1(kk,9,index1) + endif + if (LIS_FORC_Snowf%selectOpt.eq.1) then + precsno(t) = geosit_struc(n)%metdata1(kk,10,index1) + endif + if (LIS_FORC_Swnet%selectOpt.eq.1) then + swland(t) = geosit_struc(n)%metdata1(kk,11,index1) + endif + if (LIS_FORC_Pardr%selectOpt.eq.1) then + pardr(t) = geosit_struc(n)%metdata1(kk,12,index1) + endif + if (LIS_FORC_Pardf%selectOpt.eq.1) then + pardf(t) = geosit_struc(n)%metdata1(kk,13,index1) + endif + if (LIS_FORC_Forc_Hgt%selectOpt.eq.1) then + hlml(t) = geosit_struc(n)%metdata1(kk,14,index1) + endif + enddo + enddo + + end subroutine timeinterp_geosit + diff --git a/lis/plugins/LIS_metforcing_pluginMod.F90 b/lis/plugins/LIS_metforcing_pluginMod.F90 index 0d2c148d3..a4f06a4cd 100644 --- a/lis/plugins/LIS_metforcing_pluginMod.F90 +++ b/lis/plugins/LIS_metforcing_pluginMod.F90 @@ -136,6 +136,10 @@ subroutine LIS_metforcing_plugin use merra2_forcingMod #endif +#if ( defined MF_GEOS_IT ) + use geosit_forcingMod +#endif + #if ( defined MF_ERA5 ) use era5_forcingMod #endif @@ -380,6 +384,13 @@ subroutine LIS_metforcing_plugin external reset_merra2 #endif +#if ( defined MF_GEOS_IT ) + external get_geosit + external timeinterp_geosit + external finalize_geosit + external reset_geosit +#endif + #if ( defined MF_ERA5 ) external get_era5 external timeinterp_era5 @@ -778,6 +789,16 @@ subroutine LIS_metforcing_plugin call registerfinalmetforc(trim(LIS_merra2Id)//char(0),finalize_merra2) #endif +#if ( defined MF_GEOS_IT ) +! - GEOS-IT Forcing: + call registerinitmetforc(trim(LIS_geositId)//char(0),init_geosit) + call registerretrievemetforc(trim(LIS_geositId)//char(0),get_geosit) + call registertimeinterpmetforc(trim(LIS_geositId)//char(0), & + timeinterp_geosit) + call registerresetmetforc(trim(LIS_geositId)//char(0),reset_geosit) + call registerfinalmetforc(trim(LIS_geositId)//char(0),finalize_geosit) +#endif + #if ( defined MF_ERA5) ! - ERA5 Reanalysis Forcing: call registerinitmetforc(trim(LIS_era5Id)//char(0),init_ERA5) diff --git a/lis/plugins/LIS_pluginIndices.F90 b/lis/plugins/LIS_pluginIndices.F90 index 8f9d57b15..352625ac3 100644 --- a/lis/plugins/LIS_pluginIndices.F90 +++ b/lis/plugins/LIS_pluginIndices.F90 @@ -135,6 +135,7 @@ module LIS_pluginIndices character*50, public, parameter :: LIS_gldasId = "GLDAS" character*50, public, parameter :: LIS_gfsId = "GFS" character*50, public, parameter :: LIS_merra2Id = "MERRA2" + character*50, public, parameter :: LIS_geositId = "GEOS-IT" character*50, public, parameter :: LIS_cmapId = "CMAP" character*50, public, parameter :: LIS_chirps2Id = "CHIRPS2"