#!/bin/ksh

##########################################################################
####  UNIX Script Documentation Block                                    #
#                                                                        #
# Script name:         rtma_getguess.sh                                  #
# Script description:  Read in first guess in grib1 as created by the RUC#
#                      post and reformat to conform to GSI requirements. #
#                      Read also the prepbufr file that contains the obs #                      
#                                                                        #
# Author:      Manuel Pondeca        Org: NP22         Date: 2005-10-30  #
#                                                                        #
# Script history log:                                                    #
# 2005-10-30  Manuel Pondeca                                             #
#                                                                        #
##########################################################################
set -x

cd $DATA
                                                                                    
msg="HAS BEGUN on `hostname`"
postmsg "$jlogfile" "$msg"
                                                                                    
CDATE=$PDY$cyc
##########################################################################
##########################################################################
   function cyclefinder {

   set -x

   ADATE=$1

   echo "*******entering fnt cyclefinder for "${ADATE}"*******"

   ADATE00=`echo ${ADATE} | cut -c 1-8`00
   ADATE00minus12=`/nwprod/util/exec/ndate -12 $ADATE00`
   ADATE00minus06=`/nwprod/util/exec/ndate -06 $ADATE00`
   ADATE00plus06=`/nwprod/util/exec/ndate +06 $ADATE00`
   ADATE00plus12=`/nwprod/util/exec/ndate +12 $ADATE00`
   ADATE00plus18=`/nwprod/util/exec/ndate +18 $ADATE00`

   UU=`echo $ADATE | cut -c 9-10`

   if [[(${UU} -eq 00)]]  ; then
      CYCLEbest=$ADATE00minus06
      CYCLEbckup=$ADATE00minus12
   fi

   if [[(${UU} -ge 01) && (${UU} -le 06)]] ; then
      CYCLEbest=$ADATE00
      CYCLEbckup=$ADATE00minus06
   fi

   if [[(${UU} -ge 07) && (${UU} -le 12)]] ; then
      CYCLEbest=$ADATE00plus06
      CYCLEbckup=$ADATE00
   fi

   if [[(${UU} -ge 13) && (${UU} -le 18)]] ; then
      CYCLEbest=$ADATE00plus12
      CYCLEbckup=$ADATE00plus06
   fi

   if [[(${UU} -ge 19)]]  ; then
      CYCLEbest=$ADATE00plus18
      CYCLEbckup=$ADATE00plus12
   fi

   
   YYYYMMDDbest=`echo ${CYCLEbest} | cut -c 1-8`
   HHbest=`echo ${CYCLEbest} | cut -c 9-10`

   if [ ${UU} = 00 ] ; then
     let "FHHbest=24-${HHbest}"
    else
     let "FHHbest=${UU}-${HHbest}"
   fi


   YYYYMMDDbckup=`echo ${CYCLEbckup} | cut -c 1-8`
   HHbckup=`echo ${CYCLEbckup} | cut -c 9-10`
   let FHHbckup="${FHHbest}+6"


   echo "*******exiting fnt cyclefinder for "${ADATE}"*******"
}
##########################################################################
##########################################################################
   icgespath=${icgespath:-$COM}   # path for the initial guess files

   CYCLEm1=`/nwprod/util/exec/ndate -01 $CDATE`
   YYYYMMDDm1=`echo ${CYCLEm1} | cut -c 1-8`
   HHm1=`echo ${CYCLEm1} | cut -c 9-10`
   GESDIRm1=$icgespath/gurtma.${YYYYMMDDm1}

   CYCLEm2=`/nwprod/util/exec/ndate -02 $CDATE`
   YYYYMMDDm2=`echo ${CYCLEm2} | cut -c 1-8`
   HHm2=`echo ${CYCLEm2} | cut -c 9-10`
   GESDIRm2=$icgespath/gurtma.${YYYYMMDDm2}

   CYCLEm3=`/nwprod/util/exec/ndate -03 $CDATE`
   YYYYMMDDm3=`echo ${CYCLEm3} | cut -c 1-8`
   HHm3=`echo ${CYCLEm3} | cut -c 9-10`
   GESDIRm3=$icgespath/gurtma.${YYYYMMDDm3}

   CYCLEm4=`/nwprod/util/exec/ndate -04 $CDATE`
   YYYYMMDDm4=`echo ${CYCLEm4} | cut -c 1-8`
   HHm4=`echo ${CYCLEm4} | cut -c 9-10`
   GESDIRm4=$icgespath/gurtma.${YYYYMMDDm4}

   CYCLEm5=`/nwprod/util/exec/ndate -05 $CDATE`
   YYYYMMDDm5=`echo ${CYCLEm5} | cut -c 1-8`
   HHm5=`echo ${CYCLEm5} | cut -c 9-10`
   GESDIRm5=$icgespath/gurtma.${YYYYMMDDm5}

   CYCLEm6=`/nwprod/util/exec/ndate -06 $CDATE`
   YYYYMMDDm6=`echo ${CYCLEm6} | cut -c 1-8`
   HHm6=`echo ${CYCLEm6} | cut -c 9-10`
   GESDIRm6=$icgespath/gurtma.${YYYYMMDDm6}

   fgpath=${COMGFS:-/com/gfs/prod}             #CONFIRM PATH FOR THE FIRST GUESS
                                                  #COMES FROM HUI-YA's JOB
###################################################################################
#==> FIND BEST FORECAST CYCLE AND BACKUP CYCLE 
#    FOR CURRENT ANALYSIS TIME
###################################################################################
   cyclefinder $CDATE
   typeset -2Z FHHbest
   typeset -2Z FHHbckup

   path0h[1]=$fgpath/gfs.${YYYYMMDDbest}  ; f0h[1]=gfs.t${HHbest}z.smartguam${FHHbest}.tm00
   path0h[2]=$fgpath/gfs.${YYYYMMDDbckup} ; f0h[2]=gfs.t${HHbckup}z.smartguam${FHHbckup}.tm00
   
   t0h[1]=${CYCLEbest}f${FHHbest}
   t0h[2]=${CYCLEbckup}f${FHHbckup}


   nsearch=2
   found0h=no

   it=1
   while [ $it -le $nsearch ] ; do
      if [ -s ${path0h[$it]}/${f0h[$it]} ] ; then
         path0h=${path0h[$it]}
         f0h=${f0h[$it]}
         t0h=${t0h[$it]}
         found0h=yes
         break
      fi
      let "it=it+1"
   done

   if [[ ${found0h} = no ]] ; then
       echo 'NDFD guess is unavailable-exiting'
       err_exit
   fi 

   echo "export CDATEges=$t0h" > $COMOUT/gurtma.t${cyc}z.envir.sh
###################################################################################

###################################################################################
#==> FIND BEST OFF-TIME FGUESS FILES FOR FGAT
###################################################################################
   PCYCLE=`/nwprod/util/exec/ndate -01 $CDATE`
   cyclefinder $PCYCLE
   typeset -2Z FHHbest
   typeset -2Z FHHbckup

### Modified by Julia Zhu, changed "rtma" to "$RUN":
#   pathminus1h[1]=$GESDIRm1                    ; fminus1h[1]=rtma.t${HHm1}z.2dvaranl_ndfd.grb1
   pathminus1h[1]=$GESDIRm1                    ; fminus1h[1]=${RUN}.t${HHm1}z.2dvaranl_ndfd.grb1
   pathminus1h[2]=$fgpath/gfs.${YYYYMMDDbest}  ; fminus1h[2]=gfs.t${HHbest}z.smartguam${FHHbest}.tm00
   pathminus1h[3]=$fgpath/gfs.${YYYYMMDDbckup} ; fminus1h[3]=gfs.t${HHbckup}z.smartguam${FHHbckup}.tm00

   tminus1h[1]=${CYCLEm1}anl
   tminus1h[2]=${CYCLEbest}f${FHHbest}
   tminus1h[3]=${CYCLEbckup}f${FHHbckup}


   nsearch=3
   foundminus1h=no

   it=1
   while [ $it -le $nsearch ] ; do
      if [ -s ${pathminus1h[$it]}/${fminus1h[$it]} ] ; then
         pathminus1h=${pathminus1h[$it]}
         fminus1h=${fminus1h[$it]}
         tminus1h=${tminus1h[$it]}
         echo "export CDATEgesm1=$tminus1h" >> $COMOUT/gurtma.t${cyc}z.envir.sh
         foundminus1h=yes
         break
      fi
      let "it=it+1"
   done

                                ##################################
                                ##################################

   PPCYCLE=`/nwprod/util/exec/ndate -02 $CDATE`
   cyclefinder $PPCYCLE
   typeset -2Z FHHbest
   typeset -2Z FHHbckup

### Modified by Julia Zhu, changed "rtma" to "$RUN":
#   pathminus2h[1]=$GESDIRm2                    ; fminus2h[1]=rtma.t${HHm2}z.2dvaranl_ndfd.grb1
   pathminus2h[1]=$GESDIRm2                    ; fminus2h[1]=${RUN}.t${HHm2}z.2dvaranl_ndfd.grb1
   pathminus2h[2]=$fgpath/gfs.${YYYYMMDDbest}  ; fminus2h[2]=gfs.t${HHbest}z.smartguam${FHHbest}.tm00
   pathminus2h[3]=$fgpath/gfs.${YYYYMMDDbckup} ; fminus2h[3]=gfs.t${HHbckup}z.smartguam${FHHbckup}.tm00

   tminus2h[1]=${PPCYCLE}anl
   tminus2h[2]=${CYCLEbest}f${FHHbest}
   tminus2h[3]=${CYCLEbckup}f${FHHbckup}


   nsearch=3
   foundminus2h=no

   it=1
   while [ $it -le $nsearch ] ; do
      if [ -s ${pathminus2h[$it]}/${fminus2h[$it]} ] ; then
         pathminus2h=${pathminus2h[$it]}
         fminus2h=${fminus2h[$it]}
         tminus2h=${tminus2h[$it]}
         echo "export CDATEgesm2=$tminus2h" >> $COMOUT/gurtma.t${cyc}z.envir.sh
         foundminus2h=yes
         break
      fi
      let "it=it+1"
   done

                                ##################################
                                ##################################

   PPPCYCLE=`/nwprod/util/exec/ndate -03 $CDATE`
   cyclefinder $PPPCYCLE
   typeset -2Z FHHbest
   typeset -2Z FHHbckup

### Modified by Julia Zhu, changed "rtma" to "$RUN":
#   pathminus3h[1]=$GESDIRm3                    ; fminus3h[1]=rtma.t${HHm3}z.2dvaranl_ndfd.grb1
   pathminus3h[1]=$GESDIRm3                    ; fminus3h[1]=${RUN}.t${HHm3}z.2dvaranl_ndfd.grb1
   pathminus3h[2]=$fgpath/gfs.${YYYYMMDDbest}  ; fminus3h[2]=gfs.t${HHbest}z.smartguam${FHHbest}.tm00
   pathminus3h[3]=$fgpath/gfs.${YYYYMMDDbckup} ; fminus3h[3]=gfs.t${HHbckup}z.smartguam${FHHbckup}.tm00

   tminus3h[1]=${PPPCYCLE}anl
   tminus3h[2]=${CYCLEbest}f${FHHbest}
   tminus3h[3]=${CYCLEbckup}f${FHHbckup}


   nsearch=3
   foundminus3h=no

   it=1
   while [ $it -le $nsearch ] ; do
     if [ -s ${pathminus3h[$it]}/${fminus3h[$it]} ] ; then 
         pathminus3h=${pathminus3h[$it]}
         fminus3h=${fminus3h[$it]}
         tminus3h=${tminus3h[$it]}
         echo "export CDATEgesm3=$tminus3h" >> $COMOUT/gurtma.t${cyc}z.envir.sh
         foundminus3h=yes
         break
      fi
      let "it=it+1"
   done

                                ##################################
                                ##################################

   PM4CYCLE=`/nwprod/util/exec/ndate -04 $CDATE`
   cyclefinder $PM4CYCLE
   typeset -2Z FHHbest
   typeset -2Z FHHbckup

### Modified by Julia Zhu, changed "rtma" to "$RUN":
#   pathminus4h[1]=$GESDIRm4                    ; fminus4h[1]=rtma.t${HHm4}z.2dvaranl_ndfd.grb1
   pathminus4h[1]=$GESDIRm4                    ; fminus4h[1]=${RUN}.t${HHm4}z.2dvaranl_ndfd.grb1
   pathminus4h[2]=$fgpath/gfs.${YYYYMMDDbest}  ; fminus4h[2]=gfs.t${HHbest}z.smartguam${FHHbest}.tm00
   pathminus4h[3]=$fgpath/gfs.${YYYYMMDDbckup} ; fminus4h[3]=gfs.t${HHbckup}z.smartguam${FHHbckup}.tm00

   tminus4h[1]=${PM4CYCLE}anl
   tminus4h[2]=${CYCLEbest}f${FHHbest}
   tminus4h[3]=${CYCLEbckup}f${FHHbckup}


   nsearch=3
   foundminus4h=no

   it=1
   while [ $it -le $nsearch ] ; do
      if [ -s ${pathminus4h[$it]}/${fminus4h[$it]} ] ; then
         pathminus4h=${pathminus4h[$it]}
         fminus4h=${fminus4h[$it]}
         tminus4h=${tminus4h[$it]}
         echo "export CDATEgesm4=$tminus4h" >> $COMOUT/gurtma.t${cyc}z.envir.sh
         foundminus4h=yes
         break
      fi
      let "it=it+1"
   done

                                ##################################
                                ##################################

   PM5CYCLE=`/nwprod/util/exec/ndate -05 $CDATE`
   cyclefinder $PM5CYCLE
   typeset -2Z FHHbest
   typeset -2Z FHHbckup

### Modified by Julia Zhu, changed "rtma" to "$RUN":
#   pathminus5h[1]=$GESDIRm5                    ; fminus5h[1]=rtma.t${HHm5}z.2dvaranl_ndfd.grb1
   pathminus5h[1]=$GESDIRm5                    ; fminus5h[1]=${RUN}.t${HHm5}z.2dvaranl_ndfd.grb1
   pathminus5h[2]=$fgpath/gfs.${YYYYMMDDbest}  ; fminus5h[2]=gfs.t${HHbest}z.smartguam${FHHbest}.tm00
   pathminus5h[3]=$fgpath/gfs.${YYYYMMDDbckup} ; fminus5h[3]=gfs.t${HHbckup}z.smartguam${FHHbckup}.tm00

   tminus5h[1]=${PM5CYCLE}anl
   tminus5h[2]=${CYCLEbest}f${FHHbest}
   tminus5h[3]=${CYCLEbckup}f${FHHbckup}


   nsearch=3
   foundminus5h=no

   it=1
   while [ $it -le $nsearch ] ; do
      if [ -s ${pathminus5h[$it]}/${fminus5h[$it]} ] ; then
         pathminus5h=${pathminus5h[$it]}
         fminus5h=${fminus5h[$it]}
         tminus5h=${tminus5h[$it]}
         echo "export CDATEgesm5=$tminus5h" >> $COMOUT/gurtma.t${cyc}z.envir.sh
         foundminus5h=yes
         break
      fi
      let "it=it+1"
   done

                                ##################################
                                ##################################

   PM6CYCLE=`/nwprod/util/exec/ndate -06 $CDATE`
   cyclefinder $PM6CYCLE
   typeset -2Z FHHbest
   typeset -2Z FHHbckup

### Modified by Julia Zhu, changed "rtma" to "$RUN":
#   pathminus6h[1]=$GESDIRm6                    ; fminus6h[1]=rtma.t${HHm6}z.2dvaranl_ndfd.grb1
   pathminus6h[1]=$GESDIRm6                    ; fminus6h[1]=${RUN}.t${HHm6}z.2dvaranl_ndfd.grb1
   pathminus6h[2]=$fgpath/gfs.${YYYYMMDDbest}  ; fminus6h[2]=gfs.t${HHbest}z.smartguam${FHHbest}.tm00
   pathminus6h[3]=$fgpath/gfs.${YYYYMMDDbckup} ; fminus6h[3]=gfs.t${HHbckup}z.smartguam${FHHbckup}.tm00

   tminus6h[1]=${PM6CYCLE}anl
   tminus6h[2]=${CYCLEbest}f${FHHbest}
   tminus6h[3]=${CYCLEbckup}f${FHHbckup}


   nsearch=3
   foundminus6h=no

   it=1
   while [ $it -le $nsearch ] ; do
      if [ -s ${pathminus6h[$it]}/${fminus6h[$it]} ] ; then
         pathminus6h=${pathminus6h[$it]}
         fminus6h=${fminus6h[$it]}
         tminus6h=${tminus6h[$it]}
         echo "export CDATEgesm6=$tminus6h" >> $COMOUT/gurtma.t${cyc}z.envir.sh
         foundminus6h=yes
         break
      fi
      let "it=it+1"
   done

                                ##################################
                                ##################################

   NCYCLE=`/nwprod/util/exec/ndate +01 $CDATE`
   cyclefinder $NCYCLE
   typeset -2Z FHHbest
   typeset -2Z FHHbckup

   pathplus1h[1]=$fgpath/gfs.${YYYYMMDDbest}  ; fplus1h[1]=gfs.t${HHbest}z.smartguam${FHHbest}.tm00
   pathplus1h[2]=$fgpath/gfs.${YYYYMMDDbckup} ; fplus1h[2]=gfs.t${HHbckup}z.smartguam${FHHbckup}.tm00

   tplus1h[1]=${CYCLEbest}f${FHHbest}
   tplus1h[2]=${CYCLEbckup}f${FHHbckup}


   nsearch=2
   foundplus1h=no

   it=1
   while [ $it -le $nsearch ] ; do
      if [ -s ${pathplus1h[$it]}/${fplus1h[$it]} ] ; then 
         pathplus1h=${pathplus1h[$it]}
         fplus1h=${fplus1h[$it]}
         tplus1h=${tplus1h[$it]}
         echo "export CDATEgesp1=$tplus1h" >> $COMOUT/gurtma.t${cyc}z.envir.sh
         foundplus1h=yes
         break
      fi
      let "it=it+1"
   done

   usefgat=.true.
   if [[ ${foundminus1h} = no || ${foundminus2h} = no || ${foundminus3h} = no || \
         ${foundminus4h} = no || ${foundminus5h} = no || ${foundminus6h} = no || \
         ${foundplus1h} = no ]] ; then

      echo "missing at least one off-time first guess. proceed without FGAT"
      usefgat=.false.
   fi
   echo "export usefgat=$usefgat" >> $COMOUT/gurtma.t${cyc}z.envir.sh

   set +x
   echo 'foundminus1h '$foundminus1h
   echo 'foundplus1h  '$foundplus1h
   echo 'foundminus2h '$foundminus2h
   echo 'foundminus3h '$foundminus3h
   echo 'foundminus4h '$foundminus4h
   echo 'foundminus5h '$foundminus5h
   echo 'foundminus6h '$foundminus6h
   echo 'usefgat      '$usefgat
   set -x
###################################################################################
#**********************************************************************************
# COPY ALL GUESS FILES OVER TO THE WORKING DIRECTORY
#**********************************************************************************
   infile=fguess.${CDATE}
   cp ${path0h}/${f0h} $infile 


   if [[ "$usefgat" = ".true." ]] ; then
      infile2=fguess_minus1.${CDATE}
      cp ${pathminus1h}/${fminus1h} $infile2

      infile3=fguess_plus1.${CDATE}
      cp ${pathplus1h}/${fplus1h}   $infile3

      infile4=fguess_minus2h.${CDATE}
      cp ${pathminus2h}/${fminus2h} $infile4

      infile5=fguess_minus3h.${CDATE}
      cp ${pathminus3h}/${fminus3h} $infile5

      infile6=fguess_minus4h.${CDATE}
      cp ${pathminus4h}/${fminus4h} $infile6

      infile7=fguess_minus5h.${CDATE}
      cp ${pathminus5h}/${fminus5h} $infile7

      infile8=fguess_minus6h.${CDATE}
      cp ${pathminus6h}/${fminus6h} $infile8
   fi
###################################################################################

###################################################################################
#**********************************************************************************
# RETRIEVE THE OBSERVATION REJECT LISTS
#**********************************************************************************
   cp $FIXrtma/gurtma_bigrjlist.txt bigrjlist.txt 

   pdy0=`echo $CYCLEm3 | cut -c1-8`
   gesdir0=$gespath/gurtma.${pdy0}

   cp ${gesdir0}/t_rjlist.txt_dynamic_$CYCLEm3    t_rjlist.txt_dynamic
   cp ${gesdir0}/q_rjlist.txt_dynamic_$CYCLEm3    q_rjlist.txt_dynamic
   cp ${gesdir0}/p_rjlist.txt_dynamic_$CYCLEm3    p_rjlist.txt_dynamic
## cp ${gesdir0}/w_rjlist.txt_dynamic_$CYCLEm3    w_rjlist.txt_dynamic

###################################################################################


# write out records from grib file in binary format
# with header (http://www.cpc.ncep.noaa.gov/products/wesley/wgrib.html)

# write out fields in the order specified in varname_2d_ndfd of NDFDgrid.f

wgrib=${wgrib:-/nwprod/util/exec/wgrib}

FHH=`echo $t0h | cut -c 12-13`
if [[(${FHH} -le 9)]]  ; then
    typeset -1Z FHH
fi

rm -f slabs.dat
$wgrib -s $infile | grep ":PRES:sfc:${FHH}hr" | $wgrib -i $infile         -o slabs.dat
$wgrib -s $infile | grep ":HGT:sfc:${FHH}hr"  | $wgrib -i $infile -append -o slabs.dat
$wgrib -s $infile | grep ":TMP:sfc:${FHH}hr"  | $wgrib -i $infile -append -o slabs.dat
$wgrib -s $infile | grep ":DPT:sfc:${FHH}hr"  | $wgrib -i $infile -append -o slabs.dat
$wgrib -s $infile | grep ":UGRD:sfc:${FHH}hr" | $wgrib -i $infile -append -o slabs.dat
$wgrib -s $infile | grep ":VGRD:sfc:${FHH}hr" | $wgrib -i $infile -append -o slabs.dat
$wgrib -s $infile | grep ":SPFH:sfc:${FHH}hr" | $wgrib -i $infile -append -o slabs.dat
$wgrib -s $infile | grep ":LAND:sfc:${FHH}hr" | $wgrib -i $infile -append -o slabs.dat    #dummy field
$wgrib -s $infile | grep ":PRES:sfc:${FHH}hr" | $wgrib -i $infile -append -o slabs.dat    #dummy field
$wgrib -s $infile | grep ":PRES:sfc:${FHH}hr" | $wgrib -i $infile -append -o slabs.dat    #dummy field
###################################################################################

###################################################################################
# compile and run program that outputs first guess in the binary format
# required by the GSI-2DVAR. 

cat << EOF > gridname_input
&gridname
    cgrid='guam',
    lbiascor=.false.,
    lpbiascor=.false.,
    pbiascor=0.0,
    ltbiascor=.false.,
    tbiascor=0.0,
    lqbiascor=.false.,
    qbiascor=0.0,
    lubiascor=.false.,
    ubiascor=0.0,
    lvbiascor=.false.,
    vbiascor=0.0,
    ltdbiascor=.false.,
    tdbiascor=0.0,
    mkrjlists=.true.
    hwrfblend=.false.
/
EOF
#
cat << EOF > parm_ndfd_time_namelist
&timeinfo
    iyear=`echo $PDY |cut -c1-4`,
    imonth=`echo $PDY |cut -c5-6`,
    iday=`echo $PDY |cut -c7-8`,
    ihour=$cyc
/
EOF


   ln -s -f  parm_ndfd_time_namelist                    fort.9
   ln -s -f  slabs.dat                                  fort.20 
   ln -s -f  $FIXrtma/gurtma_latlon_mpfactor.dat        fort.30
   ln -s -f  $FIXrtma/gurtma_slmask.dat                 fort.40
   ln -s -f  twodvar_input_bi                           fort.88 # ndfd bckg converted 
#                                                                 to gsi format
   $EXECrtma/gurtma_firstguess >>$pgmout 2>errfile
   export err=$?; err_chk
   cat $pgmout

   if [ $SENDCOM = YES ]
   then
       cp twodvar_input_bi $COMOUT/${RUN}.t${cyc}z.2dvar_input
       cp slabs.dat  $COMOUT/${RUN}.t${cyc}z.slabs.dat
       cp slabs2.dat  $COMOUT/${RUN}.t${cyc}z.slabs2.dat
       cp slabs2_nobiasc.dat  $COMOUT/${RUN}.t${cyc}z.slabs2_nobiasc.dat
       cp $infile $COMOUT/${RUN}.t${cyc}z.${infile}             # BETTER OPTION I THINK
       cp gridname_input $COMOUT/${RUN}.t${cyc}z.gridname_input
       cp t_rejectlist $COMOUT/${RUN}.t${cyc}z.t_rejectlist
       cp q_rejectlist $COMOUT/${RUN}.t${cyc}z.q_rejectlist
       cp p_rejectlist $COMOUT/${RUN}.t${cyc}z.p_rejectlist
       cp w_rejectlist $COMOUT/${RUN}.t${cyc}z.w_rejectlist
   fi



   if [[ "$usefgat" = ".true." ]] ; then

     foundges[2]=${foundminus1h}
     foundges[3]=${foundplus1h}
     foundges[4]=${foundminus2h}
     foundges[5]=${foundminus3h}
     foundges[6]=${foundminus4h}
     foundges[7]=${foundminus5h}
     foundges[8]=${foundminus6h}

cat << EOF > gridname_input
&gridname
    cgrid='guam',
    lbiascor=.false.,
    mkrjlists=.false.
/
EOF

     it=2
     while [ $it -le 8 ] ; do

       if [[ ${foundges[${it}]} = yes ]] ; then

          typeset -2Z FUU

          if [ $it -eq 2 ] ; then
             CYCLEFG=`/nwprod/util/exec/ndate -01 $CDATE`
             slabsfg=slabsm1.dat
             infilefg=${infile2}
             suffix=m1
             FUU=`echo $tminus1h | cut -c 12-13`
             prefix=`echo $fminus1h | cut -c 1-6`
          fi

          if [ $it -eq 3 ] ; then
              CYCLEFG=`/nwprod/util/exec/ndate +01 $CDATE`
              slabsfg=slabsp1.dat
              infilefg=${infile3}
              suffix=p1
              FUU=`echo $tplus1h | cut -c 12-13`
              prefix=`echo $fplus1h | cut -c 1-6`
          fi

          if [ $it -eq 4 ] ; then
              CYCLEFG=`/nwprod/util/exec/ndate -02 $CDATE`
              slabsfg=slabsm2.dat
              infilefg=${infile4}
              suffix=m2
              FUU=`echo $tminus2h | cut -c 12-13`
              prefix=`echo $fminus2h | cut -c 1-6`
          fi

          if [ $it -eq 5 ] ; then
              CYCLEFG=`/nwprod/util/exec/ndate -03 $CDATE`
              slabsfg=slabsm3.dat
              infilefg=${infile5}
              suffix=m3
              FUU=`echo $tminus3h | cut -c 12-13`
              prefix=`echo $fminus3h | cut -c 1-6`
          fi

          if [ $it -eq 6 ] ; then
              CYCLEFG=`/nwprod/util/exec/ndate -04 $CDATE`
              slabsfg=slabsm4.dat
              infilefg=${infile6}
              suffix=m4
              FUU=`echo $tminus4h | cut -c 12-13`
              prefix=`echo $fminus4h | cut -c 1-6`
          fi

          if [ $it -eq 7 ] ; then
              CYCLEFG=`/nwprod/util/exec/ndate -05 $CDATE`
              slabsfg=slabsm5.dat
              infilefg=${infile7}
              suffix=m5
              FUU=`echo $tminus5h | cut -c 12-13`
              prefix=`echo $fminus5h | cut -c 1-6`
          fi

          if [ $it -eq 8 ] ; then
              CYCLEFG=`/nwprod/util/exec/ndate -06 $CDATE`
              slabsfg=slabsm6.dat
              infilefg=${infile8}
              suffix=m6
              FUU=`echo $tminus6h | cut -c 12-13`
              prefix=`echo $fminus6h | cut -c 1-6`
          fi

cat << EOF > parm_ndfd_time_namelist${it}
&timeinfo
   iyear=`echo  ${CYCLEFG}  | cut -c 1-4`
   imonth=`echo ${CYCLEFG}  | cut -c 5-6`
   iday=`echo   ${CYCLEFG}  | cut -c 7-8`
   ihour=`echo  ${CYCLEFG}  | cut -c 9-10`
/
EOF

          /bin/rm -rf fort.9 fort.20 fort.30 fort.40 fort.88


#          if [ $prefix = 'rtma.t' ] ; then
          if [ $prefix = 'gurtma' ] ; then
             sfcFUUhr=''
           else
             if [[ "$FUU" = "nl" || "$FUU" = "00" ]] ; then
                 sfcFUUhr=sfc:anl
               else
                if [[(${FUU} -le 9)]]  ; then
                   typeset -1Z FUU
                fi
                sfcFUUhr=sfc:${FUU}hr
             fi
          fi

          rm -f $slabsfg
          $wgrib -s $infilefg | grep ":PRES:${sfcFUUhr}" | $wgrib -i $infilefg         -o $slabsfg
          $wgrib -s $infilefg | grep ":HGT:${sfcFUUhr}"  | $wgrib -i $infilefg -append -o $slabsfg
          $wgrib -s $infilefg | grep ":TMP:${sfcFUUhr}"  | $wgrib -i $infilefg -append -o $slabsfg
          $wgrib -s $infilefg | grep ":DPT:${sfcFUUhr}"  | $wgrib -i $infilefg -append -o $slabsfg
          $wgrib -s $infilefg | grep ":UGRD:${sfcFUUhr}" | $wgrib -i $infilefg -append -o $slabsfg
          $wgrib -s $infilefg | grep ":VGRD:${sfcFUUhr}" | $wgrib -i $infilefg -append -o $slabsfg
          $wgrib -s $infilefg | grep ":SPFH:${sfcFUUhr}" | $wgrib -i $infilefg -append -o $slabsfg
          $wgrib -s $infilefg | grep ":PRES:${sfcFUUhr}" | $wgrib -i $infilefg -append -o $slabsfg #dummy field
          $wgrib -s $infilefg | grep ":PRES:${sfcFUUhr}" | $wgrib -i $infilefg -append -o $slabsfg #dummy field
          $wgrib -s $infilefg | grep ":PRES:${sfcFUUhr}" | $wgrib -i $infilefg -append -o $slabsfg #dummy field


          ln -s -f  parm_ndfd_time_namelist${it}               fort.9
          ln -s -f  $slabsfg                                   fort.20
          ln -s -f  $FIXrtma/gurtma_latlon_mpfactor.dat        fort.30
          ln -s -f  $FIXrtma/gurtma_slmask.dat                 fort.40
          ln -s -f  twodvar_input_bi${it}                      fort.88 # ndfd bckg converted

          echo "*********************************" >>$pgmout 2>errfile
          echo "*********************************" >>$pgmout 2>errfile
          $EXECrtma/gurtma_firstguess >>$pgmout 2>errfile
          export err=$?; err_chk
          cat $pgmout

         if [ $SENDCOM = YES ]
         then
             cp twodvar_input_bi${it} $COMOUT/${RUN}.t${cyc}z.2dvar_input_bi${it}
             cp $slabsfg  $COMOUT/${RUN}.t${cyc}z.${slabsfg}
             cp slabs2.dat  $COMOUT/${RUN}.t${cyc}z.slabs2${suffix}.dat
             cp slabs2_nobiasc.dat  $COMOUT/${RUN}.t${cyc}z.slabs2${suffix}_nobiasc.dat
             cp $infilefg $COMOUT/${RUN}.t${cyc}z.${infilefg}
         fi

       fi

       let "it=it+1"
     done

     if [ $SENDCOM = YES ]
     then
         cp gridname_input $COMOUT/${RUN}.t${cyc}z.gridname_input_for_fgatofftimes
     fi
   fi

###################################################################################
msg='$job ENDED NORMALLY.'
postmsg "$jlogfile" "$msg"
############################ END OF SCRIPT ########################################